1use serde::{Deserialize, Deserializer, Serialize, Serializer};
2use std::collections::BTreeMap;
3
4type ConfigMap = BTreeMap<String, Configuration>;
6type EnvMap = BTreeMap<String, String>;
8type JsonMap = BTreeMap<String, serde_json::Value>;
10type CodexConfigMap = BTreeMap<String, crate::codex::CodexConfiguration>;
12type OmpConfigMap = BTreeMap<String, crate::omp::OmpConfiguration>;
14
15#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
17pub enum StorageMode {
18 #[serde(rename = "env")]
20 #[default]
21 Env,
22 #[serde(rename = "config")]
24 Config,
25}
26
27#[derive(Serialize, Deserialize, Default, Clone)]
36pub struct Configuration {
37 pub alias_name: String,
39 pub token: String,
41 #[serde(skip_serializing_if = "Option::is_none")]
43 pub api_key: Option<String>,
44 pub url: String,
46 #[serde(skip_serializing_if = "Option::is_none")]
48 pub model: Option<String>,
49 #[serde(skip_serializing_if = "Option::is_none")]
51 pub small_fast_model: Option<String>,
52 #[serde(skip_serializing_if = "Option::is_none")]
54 pub max_thinking_tokens: Option<u32>,
55 #[serde(skip_serializing_if = "Option::is_none")]
57 pub api_timeout_ms: Option<u32>,
58 #[serde(skip_serializing_if = "Option::is_none")]
60 pub claude_code_disable_nonessential_traffic: Option<u32>,
61 #[serde(skip_serializing_if = "Option::is_none")]
63 pub anthropic_default_sonnet_model: Option<String>,
64 #[serde(skip_serializing_if = "Option::is_none")]
66 pub anthropic_default_opus_model: Option<String>,
67 #[serde(skip_serializing_if = "Option::is_none")]
69 pub anthropic_default_haiku_model: Option<String>,
70 #[serde(skip_serializing_if = "Option::is_none")]
72 pub claude_code_experimental_agent_teams: Option<u32>,
73 #[serde(skip_serializing_if = "Option::is_none")]
75 pub claude_code_disable_1m_context: Option<u32>,
76 #[serde(skip_serializing_if = "Option::is_none")]
78 pub claude_code_subagent_model: Option<String>,
79 #[serde(skip_serializing_if = "Option::is_none")]
81 pub claude_code_disable_nonstreaming_fallback: Option<u32>,
82 #[serde(skip_serializing_if = "Option::is_none")]
84 pub claude_code_effort_level: Option<String>,
85 #[serde(skip_serializing_if = "Option::is_none")]
87 pub disable_prompt_caching: Option<u32>,
88 #[serde(skip_serializing_if = "Option::is_none")]
90 pub claude_code_disable_experimental_betas: Option<u32>,
91 #[serde(skip_serializing_if = "Option::is_none")]
93 pub disable_autoupdater: Option<u32>,
94}
95
96impl Configuration {
97 pub fn get_env_field_names() -> Vec<&'static str> {
103 vec![
104 "ANTHROPIC_AUTH_TOKEN",
105 "ANTHROPIC_API_KEY",
106 "ANTHROPIC_BASE_URL",
107 "ANTHROPIC_MODEL",
108 "ANTHROPIC_SMALL_FAST_MODEL",
109 "ANTHROPIC_MAX_THINKING_TOKENS",
110 "API_TIMEOUT_MS",
111 "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
112 "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
113 "CLAUDE_CODE_DISABLE_1M_CONTEXT",
114 "CLAUDE_CODE_SUBAGENT_MODEL",
115 "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
116 "CLAUDE_CODE_EFFORT_LEVEL",
117 "DISABLE_PROMPT_CACHING",
118 "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
119 "DISABLE_AUTOUPDATER",
120 "ANTHROPIC_DEFAULT_SONNET_MODEL",
121 "ANTHROPIC_DEFAULT_OPUS_MODEL",
122 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
123 ]
124 }
125
126 pub fn auth_env_pair(&self) -> (&'static str, &str) {
131 if let Some(ref key) = self.api_key {
132 ("ANTHROPIC_API_KEY", key)
133 } else {
134 ("ANTHROPIC_AUTH_TOKEN", &self.token)
135 }
136 }
137
138 pub fn get_clearable_env_field_names() -> Vec<&'static str> {
144 vec![
145 "ANTHROPIC_AUTH_TOKEN",
146 "ANTHROPIC_API_KEY",
147 "ANTHROPIC_BASE_URL",
148 "ANTHROPIC_MODEL",
149 "ANTHROPIC_SMALL_FAST_MODEL",
150 "ANTHROPIC_MAX_THINKING_TOKENS",
151 "API_TIMEOUT_MS",
152 "ANTHROPIC_DEFAULT_SONNET_MODEL",
153 "ANTHROPIC_DEFAULT_OPUS_MODEL",
154 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
155 "CLAUDE_CODE_SUBAGENT_MODEL",
156 "CLAUDE_CODE_EFFORT_LEVEL",
157 ]
166 }
167}
168
169#[cfg(test)]
170mod tests {
171 use super::*;
172
173 #[test]
174 fn test_get_env_field_names() {
175 let fields = Configuration::get_env_field_names();
176
177 let expected_fields = vec![
179 "ANTHROPIC_AUTH_TOKEN",
180 "ANTHROPIC_API_KEY",
181 "ANTHROPIC_BASE_URL",
182 "ANTHROPIC_MODEL",
183 "ANTHROPIC_SMALL_FAST_MODEL",
184 "ANTHROPIC_MAX_THINKING_TOKENS",
185 "API_TIMEOUT_MS",
186 "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
187 "ANTHROPIC_DEFAULT_SONNET_MODEL",
188 "ANTHROPIC_DEFAULT_OPUS_MODEL",
189 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
190 "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
191 "CLAUDE_CODE_DISABLE_1M_CONTEXT",
192 "CLAUDE_CODE_SUBAGENT_MODEL",
193 "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
194 "CLAUDE_CODE_EFFORT_LEVEL",
195 "DISABLE_PROMPT_CACHING",
196 "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
197 "DISABLE_AUTOUPDATER",
198 ];
199
200 assert_eq!(
201 fields.len(),
202 expected_fields.len(),
203 "Should have exactly 19 fields"
204 );
205
206 for expected_field in expected_fields {
207 assert!(
208 fields.contains(&expected_field),
209 "Missing field: {}",
210 expected_field
211 );
212 }
213
214 for field in &fields {
216 assert_eq!(
217 field,
218 &field.to_uppercase(),
219 "Field {} should be uppercase",
220 field
221 );
222 }
223 }
224
225 #[test]
226 fn test_get_clearable_env_field_names() {
227 let fields = Configuration::get_clearable_env_field_names();
228
229 let expected_fields = vec![
231 "ANTHROPIC_AUTH_TOKEN",
232 "ANTHROPIC_API_KEY",
233 "ANTHROPIC_BASE_URL",
234 "ANTHROPIC_MODEL",
235 "ANTHROPIC_SMALL_FAST_MODEL",
236 "ANTHROPIC_MAX_THINKING_TOKENS",
237 "API_TIMEOUT_MS",
238 "ANTHROPIC_DEFAULT_SONNET_MODEL",
239 "ANTHROPIC_DEFAULT_OPUS_MODEL",
240 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
241 "CLAUDE_CODE_SUBAGENT_MODEL",
242 "CLAUDE_CODE_EFFORT_LEVEL",
243 ];
244
245 let excluded_fields = vec![
247 "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
248 "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
249 "CLAUDE_CODE_DISABLE_1M_CONTEXT",
250 "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
251 "DISABLE_PROMPT_CACHING",
252 "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
253 "DISABLE_AUTOUPDATER",
254 ];
255
256 assert_eq!(
257 fields.len(),
258 expected_fields.len(),
259 "Should have exactly 12 clearable fields"
260 );
261
262 for expected_field in expected_fields {
263 assert!(
264 fields.contains(&expected_field),
265 "Missing clearable field: {}",
266 expected_field
267 );
268 }
269
270 for excluded_field in excluded_fields {
272 assert!(
273 !fields.contains(&excluded_field),
274 "User preference field {} should NOT be in clearable list",
275 excluded_field
276 );
277 }
278 }
279
280 #[test]
281 fn test_remove_anthropic_env_uses_dynamic_fields() {
282 let mut settings = ClaudeSettings::default();
283
284 let env_fields = Configuration::get_env_field_names();
286 for field in &env_fields {
287 settings
288 .env
289 .insert(field.to_string(), "test_value".to_string());
290 }
291
292 settings
294 .env
295 .insert("OTHER_VAR".to_string(), "other_value".to_string());
296 settings
297 .env
298 .insert("CLAUDE_THEME".to_string(), "dark".to_string());
299
300 settings.remove_anthropic_env();
302
303 for field in &env_fields {
305 assert!(
306 !settings.env.contains_key(*field),
307 "Field {} should be removed",
308 field
309 );
310 }
311
312 assert!(
314 settings.env.contains_key("OTHER_VAR"),
315 "Other variables should be preserved"
316 );
317 assert!(
318 settings.env.contains_key("CLAUDE_THEME"),
319 "Other variables should be preserved"
320 );
321 assert_eq!(
322 settings.env.get("OTHER_VAR"),
323 Some(&"other_value".to_string())
324 );
325 assert_eq!(settings.env.get("CLAUDE_THEME"), Some(&"dark".to_string()));
326 }
327
328 #[test]
329 fn test_switch_to_config_uses_dynamic_fields() {
330 let mut settings = ClaudeSettings::default();
331
332 let env_fields = Configuration::get_env_field_names();
334 for field in &env_fields {
335 settings
336 .env
337 .insert(field.to_string(), "old_value".to_string());
338 }
339
340 let config = Configuration {
342 alias_name: "test".to_string(),
343 token: "new_token".to_string(),
344 api_key: None,
345 url: "https://api.new.com".to_string(),
346 model: Some("new_model".to_string()),
347 small_fast_model: Some("new_fast_model".to_string()),
348 max_thinking_tokens: Some(50000),
349 api_timeout_ms: Some(300000),
350 claude_code_disable_nonessential_traffic: Some(1),
351 anthropic_default_sonnet_model: Some("new_sonnet".to_string()),
352 anthropic_default_opus_model: Some("new_opus".to_string()),
353 anthropic_default_haiku_model: Some("new_haiku".to_string()),
354 claude_code_experimental_agent_teams: None,
355 claude_code_disable_1m_context: None,
356 claude_code_subagent_model: None,
357 claude_code_disable_nonstreaming_fallback: None,
358 claude_code_effort_level: None,
359 disable_prompt_caching: None,
360 claude_code_disable_experimental_betas: None,
361 disable_autoupdater: None,
362 };
363
364 settings.switch_to_config(&config);
366
367 assert_eq!(
369 settings.env.get("ANTHROPIC_AUTH_TOKEN"),
370 Some(&"new_token".to_string())
371 );
372 assert_eq!(
373 settings.env.get("ANTHROPIC_BASE_URL"),
374 Some(&"https://api.new.com".to_string())
375 );
376 assert_eq!(
377 settings.env.get("ANTHROPIC_MODEL"),
378 Some(&"new_model".to_string())
379 );
380 assert_eq!(
381 settings.env.get("ANTHROPIC_SMALL_FAST_MODEL"),
382 Some(&"new_fast_model".to_string())
383 );
384
385 assert_eq!(
387 settings.env.get("ANTHROPIC_MAX_THINKING_TOKENS"),
388 Some(&"50000".to_string())
389 );
390 assert_eq!(
391 settings.env.get("API_TIMEOUT_MS"),
392 Some(&"300000".to_string())
393 );
394 assert_eq!(
395 settings.env.get("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC"),
396 Some(&"1".to_string())
397 );
398 assert_eq!(
399 settings.env.get("ANTHROPIC_DEFAULT_SONNET_MODEL"),
400 Some(&"new_sonnet".to_string())
401 );
402 assert_eq!(
403 settings.env.get("ANTHROPIC_DEFAULT_OPUS_MODEL"),
404 Some(&"new_opus".to_string())
405 );
406 assert_eq!(
407 settings.env.get("ANTHROPIC_DEFAULT_HAIKU_MODEL"),
408 Some(&"new_haiku".to_string())
409 );
410 }
411
412 #[test]
413 fn test_switch_to_config_removes_optional_fields_when_not_provided() {
414 let mut settings = ClaudeSettings::default();
415
416 let env_fields = Configuration::get_env_field_names();
418 for field in &env_fields {
419 settings
420 .env
421 .insert(field.to_string(), "old_value".to_string());
422 }
423
424 let config = Configuration {
426 alias_name: "test".to_string(),
427 token: "new_token".to_string(),
428 api_key: None,
429 url: "https://api.new.com".to_string(),
430 model: Some("new_model".to_string()),
431 small_fast_model: Some("new_fast_model".to_string()),
432 max_thinking_tokens: None,
433 api_timeout_ms: None,
434 claude_code_disable_nonessential_traffic: None,
435 anthropic_default_sonnet_model: None,
436 anthropic_default_opus_model: None,
437 anthropic_default_haiku_model: None,
438 claude_code_experimental_agent_teams: None,
439 claude_code_disable_1m_context: None,
440 claude_code_subagent_model: None,
441 claude_code_disable_nonstreaming_fallback: None,
442 claude_code_effort_level: None,
443 disable_prompt_caching: None,
444 claude_code_disable_experimental_betas: None,
445 disable_autoupdater: None,
446 };
447
448 settings.switch_to_config(&config);
450
451 assert_eq!(
453 settings.env.get("ANTHROPIC_AUTH_TOKEN"),
454 Some(&"new_token".to_string())
455 );
456 assert_eq!(
457 settings.env.get("ANTHROPIC_BASE_URL"),
458 Some(&"https://api.new.com".to_string())
459 );
460 assert_eq!(
461 settings.env.get("ANTHROPIC_MODEL"),
462 Some(&"new_model".to_string())
463 );
464 assert_eq!(
465 settings.env.get("ANTHROPIC_SMALL_FAST_MODEL"),
466 Some(&"new_fast_model".to_string())
467 );
468
469 assert!(!settings.env.contains_key("ANTHROPIC_MAX_THINKING_TOKENS"));
471 assert!(!settings.env.contains_key("API_TIMEOUT_MS"));
472 assert!(
473 !settings
474 .env
475 .contains_key("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC")
476 );
477 assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_SONNET_MODEL"));
478 assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_OPUS_MODEL"));
479 assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_HAIKU_MODEL"));
480 assert!(!settings.env.contains_key("CLAUDE_CODE_SUBAGENT_MODEL"));
481 assert!(
482 !settings
483 .env
484 .contains_key("CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK")
485 );
486 assert!(!settings.env.contains_key("CLAUDE_CODE_EFFORT_LEVEL"));
487 assert!(!settings.env.contains_key("DISABLE_PROMPT_CACHING"));
488 assert!(
489 !settings
490 .env
491 .contains_key("CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS")
492 );
493 assert!(!settings.env.contains_key("DISABLE_AUTOUPDATER"));
494 }
495}
496
497#[derive(Serialize, Deserialize, Default)]
502pub struct ConfigStorage {
503 pub configurations: ConfigMap,
505 pub claude_settings_dir: Option<String>,
507 #[serde(skip_serializing_if = "Option::is_none")]
509 pub default_storage_mode: Option<StorageMode>,
510 #[serde(skip_serializing_if = "Option::is_none")]
512 pub codex_configurations: Option<CodexConfigMap>,
513 #[serde(skip_serializing_if = "Option::is_none")]
515 pub omp_configurations: Option<OmpConfigMap>,
516}
517
518#[derive(Default, Clone)]
523#[allow(dead_code)]
524pub struct ClaudeSettings {
525 pub env: EnvMap,
527 pub other: JsonMap,
529}
530
531impl Serialize for ClaudeSettings {
532 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
533 where
534 S: Serializer,
535 {
536 use serde::ser::SerializeMap;
537
538 let mut map = serializer.serialize_map(Some(
539 self.other.len() + if self.env.is_empty() { 0 } else { 1 },
540 ))?;
541
542 if !self.env.is_empty() {
544 map.serialize_entry("env", &self.env)?;
545 }
546
547 for (key, value) in &self.other {
549 map.serialize_entry(key, value)?;
550 }
551
552 map.end()
553 }
554}
555
556impl<'de> Deserialize<'de> for ClaudeSettings {
557 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
558 where
559 D: Deserializer<'de>,
560 {
561 #[derive(Deserialize)]
562 struct ClaudeSettingsHelper {
563 #[serde(default)]
564 env: EnvMap,
565 #[serde(flatten)]
566 other: JsonMap,
567 }
568
569 let helper = ClaudeSettingsHelper::deserialize(deserializer)?;
570 Ok(ClaudeSettings {
571 env: helper.env,
572 other: helper.other,
573 })
574 }
575}
576
577#[allow(dead_code)]
579pub struct AddCommandParams {
580 pub alias_name: String,
581 pub token: Option<String>,
582 pub api_key: Option<String>,
583 pub url: Option<String>,
584 pub model: Option<String>,
585 pub small_fast_model: Option<String>,
586 pub max_thinking_tokens: Option<u32>,
587 pub api_timeout_ms: Option<u32>,
588 pub claude_code_disable_nonessential_traffic: Option<u32>,
589 pub anthropic_default_sonnet_model: Option<String>,
590 pub anthropic_default_opus_model: Option<String>,
591 pub anthropic_default_haiku_model: Option<String>,
592 pub claude_code_subagent_model: Option<String>,
593 pub claude_code_disable_nonstreaming_fallback: Option<u32>,
594 pub claude_code_effort_level: Option<String>,
595 pub disable_prompt_caching: Option<u32>,
596 pub claude_code_disable_experimental_betas: Option<u32>,
597 pub disable_autoupdater: Option<u32>,
598 pub force: bool,
599 pub interactive: bool,
600 pub token_arg: Option<String>,
601 pub url_arg: Option<String>,
602 pub from_file: Option<String>,
603}