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>;
14type GrokConfigMap = BTreeMap<String, crate::grok::GrokConfiguration>;
16
17#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
19pub enum StorageMode {
20 #[serde(rename = "env")]
22 #[default]
23 Env,
24 #[serde(rename = "config")]
26 Config,
27}
28
29#[derive(Serialize, Deserialize, Default, Clone)]
38pub struct Configuration {
39 pub alias_name: String,
41 pub token: String,
43 #[serde(skip_serializing_if = "Option::is_none")]
45 pub api_key: Option<String>,
46 pub url: String,
48 #[serde(skip_serializing_if = "Option::is_none")]
50 pub model: Option<String>,
51 #[serde(skip_serializing_if = "Option::is_none")]
53 pub small_fast_model: Option<String>,
54 #[serde(skip_serializing_if = "Option::is_none")]
56 pub max_thinking_tokens: Option<u32>,
57 #[serde(skip_serializing_if = "Option::is_none")]
59 pub api_timeout_ms: Option<u32>,
60 #[serde(skip_serializing_if = "Option::is_none")]
62 pub claude_code_disable_nonessential_traffic: Option<u32>,
63 #[serde(skip_serializing_if = "Option::is_none")]
65 pub anthropic_default_sonnet_model: Option<String>,
66 #[serde(skip_serializing_if = "Option::is_none")]
68 pub anthropic_default_opus_model: Option<String>,
69 #[serde(skip_serializing_if = "Option::is_none")]
71 pub anthropic_default_haiku_model: Option<String>,
72 #[serde(skip_serializing_if = "Option::is_none")]
74 pub claude_code_experimental_agent_teams: Option<u32>,
75 #[serde(skip_serializing_if = "Option::is_none")]
77 pub claude_code_disable_1m_context: Option<u32>,
78 #[serde(skip_serializing_if = "Option::is_none")]
80 pub claude_code_subagent_model: Option<String>,
81 #[serde(skip_serializing_if = "Option::is_none")]
83 pub claude_code_disable_nonstreaming_fallback: Option<u32>,
84 #[serde(skip_serializing_if = "Option::is_none")]
86 pub claude_code_effort_level: Option<String>,
87 #[serde(skip_serializing_if = "Option::is_none")]
89 pub claude_code_auto_compact_window: Option<String>,
90 #[serde(skip_serializing_if = "Option::is_none")]
92 pub disable_prompt_caching: Option<u32>,
93 #[serde(skip_serializing_if = "Option::is_none")]
95 pub claude_code_disable_experimental_betas: Option<u32>,
96 #[serde(skip_serializing_if = "Option::is_none")]
98 pub disable_autoupdater: Option<u32>,
99}
100
101impl Configuration {
102 pub fn get_env_field_names() -> Vec<&'static str> {
108 vec![
109 "ANTHROPIC_AUTH_TOKEN",
110 "ANTHROPIC_API_KEY",
111 "ANTHROPIC_BASE_URL",
112 "ANTHROPIC_MODEL",
113 "ANTHROPIC_SMALL_FAST_MODEL",
114 "ANTHROPIC_MAX_THINKING_TOKENS",
115 "API_TIMEOUT_MS",
116 "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
117 "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
118 "CLAUDE_CODE_DISABLE_1M_CONTEXT",
119 "CLAUDE_CODE_SUBAGENT_MODEL",
120 "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
121 "CLAUDE_CODE_EFFORT_LEVEL",
122 "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
123 "DISABLE_PROMPT_CACHING",
124 "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
125 "DISABLE_AUTOUPDATER",
126 "ANTHROPIC_DEFAULT_SONNET_MODEL",
127 "ANTHROPIC_DEFAULT_OPUS_MODEL",
128 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
129 ]
130 }
131
132 pub fn auth_env_pair(&self) -> (&'static str, &str) {
137 if let Some(ref key) = self.api_key {
138 ("ANTHROPIC_API_KEY", key)
139 } else {
140 ("ANTHROPIC_AUTH_TOKEN", &self.token)
141 }
142 }
143
144 pub fn get_clearable_env_field_names() -> Vec<&'static str> {
150 vec![
151 "ANTHROPIC_AUTH_TOKEN",
152 "ANTHROPIC_API_KEY",
153 "ANTHROPIC_BASE_URL",
154 "ANTHROPIC_MODEL",
155 "ANTHROPIC_SMALL_FAST_MODEL",
156 "ANTHROPIC_MAX_THINKING_TOKENS",
157 "API_TIMEOUT_MS",
158 "ANTHROPIC_DEFAULT_SONNET_MODEL",
159 "ANTHROPIC_DEFAULT_OPUS_MODEL",
160 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
161 "CLAUDE_CODE_SUBAGENT_MODEL",
162 "CLAUDE_CODE_EFFORT_LEVEL",
163 "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
164 ]
173 }
174}
175
176#[cfg(test)]
177mod tests {
178 use super::*;
179
180 #[test]
181 fn test_get_env_field_names() {
182 let fields = Configuration::get_env_field_names();
183
184 let expected_fields = vec![
186 "ANTHROPIC_AUTH_TOKEN",
187 "ANTHROPIC_API_KEY",
188 "ANTHROPIC_BASE_URL",
189 "ANTHROPIC_MODEL",
190 "ANTHROPIC_SMALL_FAST_MODEL",
191 "ANTHROPIC_MAX_THINKING_TOKENS",
192 "API_TIMEOUT_MS",
193 "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
194 "ANTHROPIC_DEFAULT_SONNET_MODEL",
195 "ANTHROPIC_DEFAULT_OPUS_MODEL",
196 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
197 "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
198 "CLAUDE_CODE_DISABLE_1M_CONTEXT",
199 "CLAUDE_CODE_SUBAGENT_MODEL",
200 "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
201 "CLAUDE_CODE_EFFORT_LEVEL",
202 "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
203 "DISABLE_PROMPT_CACHING",
204 "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
205 "DISABLE_AUTOUPDATER",
206 ];
207
208 assert_eq!(
209 fields.len(),
210 expected_fields.len(),
211 "Should have exactly 20 fields"
212 );
213
214 for expected_field in expected_fields {
215 assert!(
216 fields.contains(&expected_field),
217 "Missing field: {}",
218 expected_field
219 );
220 }
221
222 for field in &fields {
224 assert_eq!(
225 field,
226 &field.to_uppercase(),
227 "Field {} should be uppercase",
228 field
229 );
230 }
231 }
232
233 #[test]
234 fn test_get_clearable_env_field_names() {
235 let fields = Configuration::get_clearable_env_field_names();
236
237 let expected_fields = vec![
239 "ANTHROPIC_AUTH_TOKEN",
240 "ANTHROPIC_API_KEY",
241 "ANTHROPIC_BASE_URL",
242 "ANTHROPIC_MODEL",
243 "ANTHROPIC_SMALL_FAST_MODEL",
244 "ANTHROPIC_MAX_THINKING_TOKENS",
245 "API_TIMEOUT_MS",
246 "ANTHROPIC_DEFAULT_SONNET_MODEL",
247 "ANTHROPIC_DEFAULT_OPUS_MODEL",
248 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
249 "CLAUDE_CODE_SUBAGENT_MODEL",
250 "CLAUDE_CODE_EFFORT_LEVEL",
251 "CLAUDE_CODE_AUTO_COMPACT_WINDOW",
252 ];
253
254 let excluded_fields = vec![
256 "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
257 "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
258 "CLAUDE_CODE_DISABLE_1M_CONTEXT",
259 "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
260 "DISABLE_PROMPT_CACHING",
261 "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
262 "DISABLE_AUTOUPDATER",
263 ];
264
265 assert_eq!(
266 fields.len(),
267 expected_fields.len(),
268 "Should have exactly 13 clearable fields"
269 );
270
271 for expected_field in expected_fields {
272 assert!(
273 fields.contains(&expected_field),
274 "Missing clearable field: {}",
275 expected_field
276 );
277 }
278
279 for excluded_field in excluded_fields {
281 assert!(
282 !fields.contains(&excluded_field),
283 "User preference field {} should NOT be in clearable list",
284 excluded_field
285 );
286 }
287 }
288
289 #[test]
290 fn test_remove_anthropic_env_uses_dynamic_fields() {
291 let mut settings = ClaudeSettings::default();
292
293 let env_fields = Configuration::get_env_field_names();
295 for field in &env_fields {
296 settings
297 .env
298 .insert(field.to_string(), "test_value".to_string());
299 }
300
301 settings
303 .env
304 .insert("OTHER_VAR".to_string(), "other_value".to_string());
305 settings
306 .env
307 .insert("CLAUDE_THEME".to_string(), "dark".to_string());
308
309 settings.remove_anthropic_env();
311
312 for field in &env_fields {
314 assert!(
315 !settings.env.contains_key(*field),
316 "Field {} should be removed",
317 field
318 );
319 }
320
321 assert!(
323 settings.env.contains_key("OTHER_VAR"),
324 "Other variables should be preserved"
325 );
326 assert!(
327 settings.env.contains_key("CLAUDE_THEME"),
328 "Other variables should be preserved"
329 );
330 assert_eq!(
331 settings.env.get("OTHER_VAR"),
332 Some(&"other_value".to_string())
333 );
334 assert_eq!(settings.env.get("CLAUDE_THEME"), Some(&"dark".to_string()));
335 }
336
337 #[test]
338 fn test_switch_to_config_uses_dynamic_fields() {
339 let mut settings = ClaudeSettings::default();
340
341 let env_fields = Configuration::get_env_field_names();
343 for field in &env_fields {
344 settings
345 .env
346 .insert(field.to_string(), "old_value".to_string());
347 }
348
349 let config = Configuration {
351 alias_name: "test".to_string(),
352 token: "new_token".to_string(),
353 api_key: None,
354 url: "https://api.new.com".to_string(),
355 model: Some("new_model".to_string()),
356 small_fast_model: Some("new_fast_model".to_string()),
357 max_thinking_tokens: Some(50000),
358 api_timeout_ms: Some(300000),
359 claude_code_disable_nonessential_traffic: Some(1),
360 anthropic_default_sonnet_model: Some("new_sonnet".to_string()),
361 anthropic_default_opus_model: Some("new_opus".to_string()),
362 anthropic_default_haiku_model: Some("new_haiku".to_string()),
363 claude_code_experimental_agent_teams: None,
364 claude_code_disable_1m_context: None,
365 claude_code_subagent_model: None,
366 claude_code_disable_nonstreaming_fallback: None,
367 claude_code_effort_level: None,
368 claude_code_auto_compact_window: None,
369 disable_prompt_caching: None,
370 claude_code_disable_experimental_betas: None,
371 disable_autoupdater: None,
372 };
373
374 settings.switch_to_config(&config);
376
377 assert_eq!(
379 settings.env.get("ANTHROPIC_AUTH_TOKEN"),
380 Some(&"new_token".to_string())
381 );
382 assert_eq!(
383 settings.env.get("ANTHROPIC_BASE_URL"),
384 Some(&"https://api.new.com".to_string())
385 );
386 assert_eq!(
387 settings.env.get("ANTHROPIC_MODEL"),
388 Some(&"new_model".to_string())
389 );
390 assert_eq!(
391 settings.env.get("ANTHROPIC_SMALL_FAST_MODEL"),
392 Some(&"new_fast_model".to_string())
393 );
394
395 assert_eq!(
397 settings.env.get("ANTHROPIC_MAX_THINKING_TOKENS"),
398 Some(&"50000".to_string())
399 );
400 assert_eq!(
401 settings.env.get("API_TIMEOUT_MS"),
402 Some(&"300000".to_string())
403 );
404 assert_eq!(
405 settings.env.get("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC"),
406 Some(&"1".to_string())
407 );
408 assert_eq!(
409 settings.env.get("ANTHROPIC_DEFAULT_SONNET_MODEL"),
410 Some(&"new_sonnet".to_string())
411 );
412 assert_eq!(
413 settings.env.get("ANTHROPIC_DEFAULT_OPUS_MODEL"),
414 Some(&"new_opus".to_string())
415 );
416 assert_eq!(
417 settings.env.get("ANTHROPIC_DEFAULT_HAIKU_MODEL"),
418 Some(&"new_haiku".to_string())
419 );
420 }
421
422 #[test]
423 fn test_switch_to_config_removes_optional_fields_when_not_provided() {
424 let mut settings = ClaudeSettings::default();
425
426 let env_fields = Configuration::get_env_field_names();
428 for field in &env_fields {
429 settings
430 .env
431 .insert(field.to_string(), "old_value".to_string());
432 }
433
434 let config = Configuration {
436 alias_name: "test".to_string(),
437 token: "new_token".to_string(),
438 api_key: None,
439 url: "https://api.new.com".to_string(),
440 model: Some("new_model".to_string()),
441 small_fast_model: Some("new_fast_model".to_string()),
442 max_thinking_tokens: None,
443 api_timeout_ms: None,
444 claude_code_disable_nonessential_traffic: None,
445 anthropic_default_sonnet_model: None,
446 anthropic_default_opus_model: None,
447 anthropic_default_haiku_model: None,
448 claude_code_experimental_agent_teams: None,
449 claude_code_disable_1m_context: None,
450 claude_code_subagent_model: None,
451 claude_code_disable_nonstreaming_fallback: None,
452 claude_code_effort_level: None,
453 claude_code_auto_compact_window: None,
454 disable_prompt_caching: None,
455 claude_code_disable_experimental_betas: None,
456 disable_autoupdater: None,
457 };
458
459 settings.switch_to_config(&config);
461
462 assert_eq!(
464 settings.env.get("ANTHROPIC_AUTH_TOKEN"),
465 Some(&"new_token".to_string())
466 );
467 assert_eq!(
468 settings.env.get("ANTHROPIC_BASE_URL"),
469 Some(&"https://api.new.com".to_string())
470 );
471 assert_eq!(
472 settings.env.get("ANTHROPIC_MODEL"),
473 Some(&"new_model".to_string())
474 );
475 assert_eq!(
476 settings.env.get("ANTHROPIC_SMALL_FAST_MODEL"),
477 Some(&"new_fast_model".to_string())
478 );
479
480 assert!(!settings.env.contains_key("ANTHROPIC_MAX_THINKING_TOKENS"));
482 assert!(!settings.env.contains_key("API_TIMEOUT_MS"));
483 assert!(
484 !settings
485 .env
486 .contains_key("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC")
487 );
488 assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_SONNET_MODEL"));
489 assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_OPUS_MODEL"));
490 assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_HAIKU_MODEL"));
491 assert!(!settings.env.contains_key("CLAUDE_CODE_SUBAGENT_MODEL"));
492 assert!(
493 !settings
494 .env
495 .contains_key("CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK")
496 );
497 assert!(!settings.env.contains_key("CLAUDE_CODE_EFFORT_LEVEL"));
498 assert!(!settings.env.contains_key("DISABLE_PROMPT_CACHING"));
499 assert!(
500 !settings
501 .env
502 .contains_key("CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS")
503 );
504 assert!(!settings.env.contains_key("DISABLE_AUTOUPDATER"));
505 }
506}
507
508#[derive(Serialize, Deserialize, Default)]
513pub struct ConfigStorage {
514 pub configurations: ConfigMap,
516 pub claude_settings_dir: Option<String>,
518 #[serde(skip_serializing_if = "Option::is_none")]
520 pub default_storage_mode: Option<StorageMode>,
521 #[serde(skip_serializing_if = "Option::is_none")]
523 pub codex_configurations: Option<CodexConfigMap>,
524 #[serde(skip_serializing_if = "Option::is_none")]
526 pub omp_configurations: Option<OmpConfigMap>,
527 #[serde(skip_serializing_if = "Option::is_none")]
529 pub grok_configurations: Option<GrokConfigMap>,
530}
531
532#[derive(Default, Clone)]
537#[allow(dead_code)]
538pub struct ClaudeSettings {
539 pub env: EnvMap,
541 pub other: JsonMap,
543}
544
545impl Serialize for ClaudeSettings {
546 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
547 where
548 S: Serializer,
549 {
550 use serde::ser::SerializeMap;
551
552 let mut map = serializer.serialize_map(Some(
553 self.other.len() + if self.env.is_empty() { 0 } else { 1 },
554 ))?;
555
556 if !self.env.is_empty() {
558 map.serialize_entry("env", &self.env)?;
559 }
560
561 for (key, value) in &self.other {
563 map.serialize_entry(key, value)?;
564 }
565
566 map.end()
567 }
568}
569
570impl<'de> Deserialize<'de> for ClaudeSettings {
571 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
572 where
573 D: Deserializer<'de>,
574 {
575 #[derive(Deserialize)]
576 struct ClaudeSettingsHelper {
577 #[serde(default)]
578 env: EnvMap,
579 #[serde(flatten)]
580 other: JsonMap,
581 }
582
583 let helper = ClaudeSettingsHelper::deserialize(deserializer)?;
584 Ok(ClaudeSettings {
585 env: helper.env,
586 other: helper.other,
587 })
588 }
589}
590
591#[allow(dead_code)]
593pub struct AddCommandParams {
594 pub alias_name: String,
595 pub token: Option<String>,
596 pub api_key: Option<String>,
597 pub url: Option<String>,
598 pub model: Option<String>,
599 pub small_fast_model: Option<String>,
600 pub max_thinking_tokens: Option<u32>,
601 pub api_timeout_ms: Option<u32>,
602 pub claude_code_disable_nonessential_traffic: Option<u32>,
603 pub anthropic_default_sonnet_model: Option<String>,
604 pub anthropic_default_opus_model: Option<String>,
605 pub anthropic_default_haiku_model: Option<String>,
606 pub claude_code_subagent_model: Option<String>,
607 pub claude_code_disable_nonstreaming_fallback: Option<u32>,
608 pub claude_code_effort_level: Option<String>,
609 pub claude_code_auto_compact_window: Option<String>,
610 pub disable_prompt_caching: Option<u32>,
611 pub claude_code_disable_experimental_betas: Option<u32>,
612 pub disable_autoupdater: Option<u32>,
613 pub force: bool,
614 pub interactive: bool,
615 pub token_arg: Option<String>,
616 pub url_arg: Option<String>,
617 pub from_file: Option<String>,
618 pub from_json: Option<String>,
619 pub from_stdin: bool,
620}