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

//! Optional management progress while OneBot is unavailable; never an account confirmation.
use crate::core::{
    error::{AppError, Result},
    output::Envelope,
};
use crate::storage::{
    config::Config,
    credentials::Credentials,
    state::{Instance, Registry, Store},
};
use std::time::Instant;

pub(crate) fn execute_pending(
    store: &Store,
    credentials: &impl Credentials,
    config: &Config,
    registry: &Registry,
    instance: &Instance,
    deadline: Instant,
) -> Result<Envelope> {
    let mut data = crate::messaging::session::unverified_status(instance)?;
    #[cfg(windows)]
    {
        use crate::napcat::{
            control::{self, owned::OwnedControl},
            runtime::{run_job, runtime_store},
        };
        let installation = registry
            .installations
            .iter()
            .find(|i| i.id == instance.installation_id)
            .ok_or_else(changed)?;
        let refs = crate::storage::references::References::existing(store, credentials)?;
        let (capability, material) = {
            let tx = store.transaction(deadline)?;
            let capability =
                match run_job::reopen_control(&tx, &refs, instance, installation, deadline) {
                    Ok(capability) => capability,
                    Err(error) if error.code == "CONTROL_NOT_BOUND" => {
                        return Ok(Envelope::typed(data));
                    }
                    Err(error) => return Err(error),
                };
            let material = runtime_store::recover_control(
                &tx,
                &refs,
                credentials,
                instance,
                installation,
                deadline,
            )?;
            if capability.endpoint() != material.endpoint() {
                return Err(changed());
            }
            (capability, material)
        };
        let service = capability.service();
        let backend = OwnedControl::new(
            service.job(),
            service.owner(),
            capability.endpoint(),
            config,
        )?;
        let observation = control::observe(&backend, material.token(), deadline)?;
        // No lock is held during the two bounded network operations.
        let tx = store.transaction(deadline)?;
        if tx
            .registry
            .instances
            .iter()
            .filter(|i| i.id == instance.id)
            .count()
            != 1
            || !tx.registry.instances.iter().any(|i| i == instance)
            || tx
                .registry
                .installations
                .iter()
                .filter(|i| i.id == installation.id)
                .count()
                != 1
            || !tx.registry.installations.iter().any(|i| i == installation)
        {
            return Err(changed());
        }
        data.login_observation = Some(observation);
    }
    #[cfg(not(windows))]
    {
        let _ = (store, credentials, config, registry, deadline);
    }
    crate::core::deadline::check(deadline)?;
    Ok(Envelope::typed(data))
}

#[cfg(windows)]
fn changed() -> AppError {
    AppError::new(
        "STATUS_INPUT_CHANGED",
        "Instance, installation or control binding changed during observation; no account was confirmed.",
        4,
    )
}