1use std::collections::HashMap;
2
3use serde::{Deserialize, Serialize};
4use serde_json::{Map, Value};
5
6#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
7pub struct DaemonConfig {
8 #[serde(default)]
9 pub quiet_restart: bool,
10 #[serde(default = "default_working_dirs")]
11 pub working_dirs: Vec<String>,
12}
13
14fn default_working_dirs() -> Vec<String> {
15 vec!["~".to_string()]
16}
17
18impl Default for DaemonConfig {
19 fn default() -> Self {
20 Self {
21 quiet_restart: false,
22 working_dirs: default_working_dirs(),
23 }
24 }
25}
26
27#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
28pub struct WebConfig {
29 #[serde(default = "default_web_host")]
30 pub host: String,
31 #[serde(default = "default_proxy_base_port")]
32 pub proxy_base_port: u16,
33}
34
35fn default_web_host() -> String {
36 "0.0.0.0".to_string()
37}
38
39fn default_proxy_base_port() -> u16 {
40 8800
41}
42
43impl Default for WebConfig {
44 fn default() -> Self {
45 Self {
46 host: default_web_host(),
47 proxy_base_port: default_proxy_base_port(),
48 }
49 }
50}
51
52#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Default)]
53pub struct Config {
54 #[serde(default)]
55 pub daemon: DaemonConfig,
56 #[serde(default)]
57 pub web: WebConfig,
58 #[serde(default)]
59 pub lark: LarkConfig,
60 #[serde(default, rename = "screenAnalyzer")]
61 pub screen_analyzer: ScreenAnalyzerConfig,
62}
63
64#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
65pub struct BotConfig {
66 #[serde(default)]
67 pub name: Option<String>,
68 #[serde(rename = "larkAppId")]
69 pub lark_app_id: String,
70 #[serde(rename = "larkAppSecret")]
71 pub lark_app_secret: String,
72 #[serde(rename = "cliId")]
73 pub cli_id: String,
74 #[serde(rename = "cliBin", default)]
75 pub cli_bin: Option<String>,
76 #[serde(rename = "cliArgs", default)]
77 pub cli_args: Vec<String>,
78 #[serde(default)]
79 pub model: Option<String>,
80 #[serde(rename = "workingDir", default)]
81 pub working_dir: Option<String>,
82 #[serde(rename = "skipWorkingDirPrompt", default)]
83 pub skip_working_dir_prompt: bool,
84 #[serde(rename = "larkEncryptKey", default)]
85 pub lark_encrypt_key: Option<String>,
86 #[serde(rename = "larkVerificationToken", default)]
87 pub lark_verification_token: Option<String>,
88 #[serde(rename = "allowedUsers", default)]
89 pub allowed_users: Vec<String>,
90 #[serde(rename = "privateCard", default)]
91 pub private_card: bool,
92 #[serde(rename = "allowedChatGroups", default)]
93 pub allowed_chat_groups: Vec<String>,
94 #[serde(rename = "chatGrants", default)]
95 pub chat_grants: std::collections::HashMap<String, Vec<String>>,
96 #[serde(rename = "globalGrants", default)]
97 pub global_grants: Vec<String>,
98 #[serde(rename = "oncallChats", default)]
99 pub oncall_chats: Vec<OncallChatBinding>,
100 #[serde(rename = "restrictGrantCommands", default)]
101 pub restrict_grant_commands: bool,
102 #[serde(rename = "messageQuota", default)]
103 pub message_quota: Option<MessageQuotaConfig>,
104 #[serde(rename = "quotaState", default)]
105 pub quota_state: std::collections::HashMap<String, QuotaEntry>,
106}
107
108#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
109pub struct OncallChatBinding {
110 #[serde(rename = "chatId")]
111 pub chat_id: String,
112 #[serde(rename = "workingDir", default)]
113 pub working_dir: Option<String>,
114}
115
116#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
117pub struct MessageQuotaConfig {
118 #[serde(rename = "defaultLimit", default)]
119 pub default_limit: Option<u32>,
120}
121
122#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
123pub struct QuotaEntry {
124 pub limit: u32,
125 pub used: u32,
126}
127
128#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
129pub struct LarkConfig {
130 #[serde(default)]
131 pub verification_token: Option<String>,
132 #[serde(default)]
133 pub encrypt_key: Option<String>,
134}
135
136#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq, Eq)]
137pub struct ScreenAnalyzerConfig {
138 #[serde(default)]
139 pub enabled: bool,
140 #[serde(default)]
141 pub base_url: String,
142 #[serde(default)]
143 pub api_key: String,
144 #[serde(default)]
145 pub model: String,
146 #[serde(default = "default_screen_analyzer_interval_ms")]
147 pub interval_ms: u64,
148 #[serde(default = "default_screen_analyzer_stable_count")]
149 pub stable_count: u32,
150 #[serde(default = "default_screen_analyzer_snapshot_max_chars")]
151 pub snapshot_max_chars: usize,
152 #[serde(default)]
153 pub extra_headers: HashMap<String, String>,
154 #[serde(default)]
155 pub extra_body: Map<String, Value>,
156}
157
158fn default_screen_analyzer_interval_ms() -> u64 {
159 2_000
160}
161
162fn default_screen_analyzer_stable_count() -> u32 {
163 6
164}
165
166fn default_screen_analyzer_snapshot_max_chars() -> usize {
167 8_000
168}
169
170impl Default for ScreenAnalyzerConfig {
171 fn default() -> Self {
172 Self {
173 enabled: false,
174 base_url: String::new(),
175 api_key: String::new(),
176 model: String::new(),
177 interval_ms: default_screen_analyzer_interval_ms(),
178 stable_count: default_screen_analyzer_stable_count(),
179 snapshot_max_chars: default_screen_analyzer_snapshot_max_chars(),
180 extra_headers: HashMap::new(),
181 extra_body: Map::new(),
182 }
183 }
184}
185
186impl Default for LarkConfig {
187 fn default() -> Self {
188 Self {
189 verification_token: None,
190 encrypt_key: None,
191 }
192 }
193}
194
195#[cfg(test)]
196mod tests {
197 use super::BotConfig;
198
199 #[test]
200 fn bot_config_defaults_missing_cli_args_and_skip_prompt_fields() {
201 let raw = r#"{
202 "larkAppId":"app-1",
203 "larkAppSecret":"secret",
204 "cliId":"codex"
205 }"#;
206 let bot: BotConfig = serde_json::from_str(raw).expect("deserialize bot");
207 assert!(bot.cli_args.is_empty());
208 assert!(!bot.skip_working_dir_prompt);
209 }
210
211 #[test]
212 fn bot_config_deserializes_traex_cli_args() {
213 let raw = r#"{
214 "larkAppId":"app-1",
215 "larkAppSecret":"secret",
216 "cliId":"traex",
217 "cliArgs":["-y"]
218 }"#;
219 let bot: BotConfig = serde_json::from_str(raw).expect("deserialize bot");
220 assert_eq!(bot.cli_args, vec!["-y".to_string()]);
221 }
222}