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
125
126
127
128
129

//! Actual instance lifecycle and login-observation wire contracts.
use super::scalar::{LocalId, No};
use schemars::JsonSchema;
use serde::Serialize;

#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum Phase {
    WaitingQrcode,
    GeneratingQrcode,
    QrcodeScanned,
    Initializing,
    Ready,
    Offline,
    Reconnecting,
    Unknown,
}
#[derive(Debug, Eq, PartialEq, Serialize, JsonSchema)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Observation {
    pub phase: Phase,
    pub is_login: bool,
    pub is_offline: bool,
    pub qr_login_accepted: bool,
    pub core_ready: bool,
}
#[derive(Serialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ObservedState {
    Ready,
    Offline,
    AccountChanged,
}
#[derive(Serialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum PendingState {
    NotStarted,
    Preparing,
    Prepared,
    Starting,
    LoginRequired,
    Stopped,
    Stopping,
    Offline,
    Failed,
    Unknown,
}
impl PendingState {
    pub fn parse(value: &str) -> crate::core::error::Result<Self> {
        Ok(match value {
            "not_started" => Self::NotStarted,
            "preparing" => Self::Preparing,
            "prepared" => Self::Prepared,
            "starting" => Self::Starting,
            "login_required" => Self::LoginRequired,
            "stopped" => Self::Stopped,
            "stopping" => Self::Stopping,
            "offline" => Self::Offline,
            "failed" => Self::Failed,
            "unknown" => Self::Unknown,
            _ => return Err(crate::core::error::AppError::storage()),
        })
    }
}
#[derive(Serialize, JsonSchema)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Observed {
    pub state: ObservedState,
    pub online: bool,
    pub version: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[schemars(with = "String")]
    pub nickname: Option<String>,
}
#[derive(Serialize, JsonSchema)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Pending {
    pub state: PendingState,
    pub account: (),
    pub identity_verified: No,
    #[serde(skip_serializing_if = "Option::is_none")]
    #[schemars(with = "Observation")]
    pub login_observation: Option<Observation>,
}
#[derive(Serialize, JsonSchema)]
#[serde(untagged)]
pub enum Status {
    Observed(Observed),
    Pending(Pending),
}
#[derive(Serialize, JsonSchema)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Started {
    pub instance_id: LocalId,
    #[serde(flatten)]
    pub status: Observed,
    pub reused: bool,
}
#[derive(Serialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum StoppedState {
    Stopped,
}
#[derive(Serialize, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum RemovedState {
    Removed,
}
#[derive(Serialize, JsonSchema)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Stopped {
    pub instance_id: LocalId,
    pub state: StoppedState,
    pub reused: bool,
}
#[derive(Serialize, JsonSchema)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Removed {
    pub instance_id: LocalId,
    pub state: RemovedState,
    pub reused: bool,
}

#[derive(Serialize, JsonSchema)]
#[serde(untagged)]
pub enum StatusReply {
    Observed(super::reply::ScopedReply<Observed>),
    Pending(super::reply::Reply<Pending>),
}