qq-cli 0.1.0

A modular Rust QQ task interface for coding agents
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Promote only an exact, still-running original Framework dispatch to local evidence.
use crate::core::error::{AppError, Result};
use crate::napcat::{
    compatibility,
    doctor::Probe,
    install::catalog,
    runtime::{dispatch, launch, run_job, runtime_store, startup},
};
use crate::storage::{
    config::Config,
    credentials::SystemCredentials,
    references::References,
    state::{Instance, Store},
};
use std::time::Instant;

pub(crate) fn record(
    store: &Store,
    config: &Config,
    selected: &Instance,
    probe: &impl Probe,
    deadline: Instant,
) -> Result<()> {
    if selected.state != "ready" {
        return Ok(());
    }
    let registry = store.read()?;
    let installation = registry
        .installations
        .iter()
        .find(|i| i.id == selected.installation_id)
        .ok_or_else(AppError::storage)?;
    let release = catalog::lookup(&installation.version)?;
    let witnesses = compatibility::available_witnesses(store)?;
    let inputs = startup::inspect_trial(store, &registry, &release, &witnesses, probe, deadline)?;
    if compatibility::evaluate(inputs.compatibility(), &witnesses).state
        == compatibility::Verdict::Supported
    {
        return Ok(());
    }
    let online = probe.api(store, config, selected, &installation.version, deadline)?;
    if !online.online || selected.account.as_deref() != Some(online.account.as_str()) {
        return Err(conflict());
    }
    let credentials = SystemCredentials::new(store.root())?;
    let refs = References::existing(store, &credentials)?;
    let tx = store.transaction(deadline)?;
    if !tx.registry.instances.iter().any(|i| i == selected)
        || !tx.registry.installations.iter().any(|i| i == installation)
    {
        return Err(conflict());
    }
    // Fresh immutable inputs under the same transaction; this never permits a launch.
    let fresh = startup::inspect_trial(store, &tx.registry, &release, &witnesses, probe, deadline)?;
    if inputs.compatibility() != fresh.compatibility() {
        return Err(conflict());
    }
    let material =
        runtime_store::recover_control(&tx, &refs, &credentials, selected, installation, deadline)?;
    let environment = launch::environment(
        std::env::vars_os(),
        inputs
            .application()
            .executable
            .parent()
            .ok_or_else(conflict)?,
        &material.directory,
    )?;
    let mut bootstrap = launch::bootstrap(
        &inputs.application().executable,
        &installation.directory,
        &material.directory,
    )?;
    let mut hashes = vec![dispatch::input_hash(
        inputs.compatibility(),
        &material.plan,
        &bootstrap,
        &environment,
        &material.bundle,
    )?];
    // Legacy v1 runs used the verified installation as CWD. Do not rewrite the old journal.
    bootstrap.current_directory = installation
        .directory
        .canonicalize()
        .map_err(|_| conflict())?;
    hashes.push(dispatch::input_hash(
        inputs.compatibility(),
        &material.plan,
        &bootstrap,
        &environment,
        &material.bundle,
    )?);
    let target = run_job::observed_target(
        store,
        &refs,
        selected,
        installation,
        &inputs.application().executable,
        &hashes,
        deadline,
    )?;
    let after = probe.api(store, config, selected, &installation.version, deadline)?;
    if !after.online || after.account != online.account || after.version != online.version {
        return Err(conflict());
    }
    // Require the original input/process association again immediately before publication.
    run_job::observed_target(
        store,
        &refs,
        selected,
        installation,
        &inputs.application().executable,
        &hashes,
        deadline,
    )?;
    compatibility::local::record(&tx, &refs, inputs.compatibility().clone(), target)
}
fn conflict() -> AppError {
    AppError::new(
        "STARTUP_EVIDENCE_UNVERIFIED",
        "Original launch inputs and live Framework identity could not be verified; no local compatibility evidence was recorded.",
        4,
    )
}