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 disable_prompt_caching: Option<u32>,
90 #[serde(skip_serializing_if = "Option::is_none")]
92 pub claude_code_disable_experimental_betas: Option<u32>,
93 #[serde(skip_serializing_if = "Option::is_none")]
95 pub disable_autoupdater: Option<u32>,
96}
97
98impl Configuration {
99 pub fn get_env_field_names() -> Vec<&'static str> {
105 vec![
106 "ANTHROPIC_AUTH_TOKEN",
107 "ANTHROPIC_API_KEY",
108 "ANTHROPIC_BASE_URL",
109 "ANTHROPIC_MODEL",
110 "ANTHROPIC_SMALL_FAST_MODEL",
111 "ANTHROPIC_MAX_THINKING_TOKENS",
112 "API_TIMEOUT_MS",
113 "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
114 "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
115 "CLAUDE_CODE_DISABLE_1M_CONTEXT",
116 "CLAUDE_CODE_SUBAGENT_MODEL",
117 "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
118 "CLAUDE_CODE_EFFORT_LEVEL",
119 "DISABLE_PROMPT_CACHING",
120 "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
121 "DISABLE_AUTOUPDATER",
122 "ANTHROPIC_DEFAULT_SONNET_MODEL",
123 "ANTHROPIC_DEFAULT_OPUS_MODEL",
124 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
125 ]
126 }
127
128 pub fn auth_env_pair(&self) -> (&'static str, &str) {
133 if let Some(ref key) = self.api_key {
134 ("ANTHROPIC_API_KEY", key)
135 } else {
136 ("ANTHROPIC_AUTH_TOKEN", &self.token)
137 }
138 }
139
140 pub fn get_clearable_env_field_names() -> Vec<&'static str> {
146 vec![
147 "ANTHROPIC_AUTH_TOKEN",
148 "ANTHROPIC_API_KEY",
149 "ANTHROPIC_BASE_URL",
150 "ANTHROPIC_MODEL",
151 "ANTHROPIC_SMALL_FAST_MODEL",
152 "ANTHROPIC_MAX_THINKING_TOKENS",
153 "API_TIMEOUT_MS",
154 "ANTHROPIC_DEFAULT_SONNET_MODEL",
155 "ANTHROPIC_DEFAULT_OPUS_MODEL",
156 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
157 "CLAUDE_CODE_SUBAGENT_MODEL",
158 "CLAUDE_CODE_EFFORT_LEVEL",
159 ]
168 }
169}
170
171#[cfg(test)]
172mod tests {
173 use super::*;
174
175 #[test]
176 fn test_get_env_field_names() {
177 let fields = Configuration::get_env_field_names();
178
179 let expected_fields = vec![
181 "ANTHROPIC_AUTH_TOKEN",
182 "ANTHROPIC_API_KEY",
183 "ANTHROPIC_BASE_URL",
184 "ANTHROPIC_MODEL",
185 "ANTHROPIC_SMALL_FAST_MODEL",
186 "ANTHROPIC_MAX_THINKING_TOKENS",
187 "API_TIMEOUT_MS",
188 "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
189 "ANTHROPIC_DEFAULT_SONNET_MODEL",
190 "ANTHROPIC_DEFAULT_OPUS_MODEL",
191 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
192 "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
193 "CLAUDE_CODE_DISABLE_1M_CONTEXT",
194 "CLAUDE_CODE_SUBAGENT_MODEL",
195 "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
196 "CLAUDE_CODE_EFFORT_LEVEL",
197 "DISABLE_PROMPT_CACHING",
198 "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
199 "DISABLE_AUTOUPDATER",
200 ];
201
202 assert_eq!(
203 fields.len(),
204 expected_fields.len(),
205 "Should have exactly 19 fields"
206 );
207
208 for expected_field in expected_fields {
209 assert!(
210 fields.contains(&expected_field),
211 "Missing field: {}",
212 expected_field
213 );
214 }
215
216 for field in &fields {
218 assert_eq!(
219 field,
220 &field.to_uppercase(),
221 "Field {} should be uppercase",
222 field
223 );
224 }
225 }
226
227 #[test]
228 fn test_get_clearable_env_field_names() {
229 let fields = Configuration::get_clearable_env_field_names();
230
231 let expected_fields = vec![
233 "ANTHROPIC_AUTH_TOKEN",
234 "ANTHROPIC_API_KEY",
235 "ANTHROPIC_BASE_URL",
236 "ANTHROPIC_MODEL",
237 "ANTHROPIC_SMALL_FAST_MODEL",
238 "ANTHROPIC_MAX_THINKING_TOKENS",
239 "API_TIMEOUT_MS",
240 "ANTHROPIC_DEFAULT_SONNET_MODEL",
241 "ANTHROPIC_DEFAULT_OPUS_MODEL",
242 "ANTHROPIC_DEFAULT_HAIKU_MODEL",
243 "CLAUDE_CODE_SUBAGENT_MODEL",
244 "CLAUDE_CODE_EFFORT_LEVEL",
245 ];
246
247 let excluded_fields = vec![
249 "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
250 "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
251 "CLAUDE_CODE_DISABLE_1M_CONTEXT",
252 "CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK",
253 "DISABLE_PROMPT_CACHING",
254 "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
255 "DISABLE_AUTOUPDATER",
256 ];
257
258 assert_eq!(
259 fields.len(),
260 expected_fields.len(),
261 "Should have exactly 12 clearable fields"
262 );
263
264 for expected_field in expected_fields {
265 assert!(
266 fields.contains(&expected_field),
267 "Missing clearable field: {}",
268 expected_field
269 );
270 }
271
272 for excluded_field in excluded_fields {
274 assert!(
275 !fields.contains(&excluded_field),
276 "User preference field {} should NOT be in clearable list",
277 excluded_field
278 );
279 }
280 }
281
282 #[test]
283 fn test_remove_anthropic_env_uses_dynamic_fields() {
284 let mut settings = ClaudeSettings::default();
285
286 let env_fields = Configuration::get_env_field_names();
288 for field in &env_fields {
289 settings
290 .env
291 .insert(field.to_string(), "test_value".to_string());
292 }
293
294 settings
296 .env
297 .insert("OTHER_VAR".to_string(), "other_value".to_string());
298 settings
299 .env
300 .insert("CLAUDE_THEME".to_string(), "dark".to_string());
301
302 settings.remove_anthropic_env();
304
305 for field in &env_fields {
307 assert!(
308 !settings.env.contains_key(*field),
309 "Field {} should be removed",
310 field
311 );
312 }
313
314 assert!(
316 settings.env.contains_key("OTHER_VAR"),
317 "Other variables should be preserved"
318 );
319 assert!(
320 settings.env.contains_key("CLAUDE_THEME"),
321 "Other variables should be preserved"
322 );
323 assert_eq!(
324 settings.env.get("OTHER_VAR"),
325 Some(&"other_value".to_string())
326 );
327 assert_eq!(settings.env.get("CLAUDE_THEME"), Some(&"dark".to_string()));
328 }
329
330 #[test]
331 fn test_switch_to_config_uses_dynamic_fields() {
332 let mut settings = ClaudeSettings::default();
333
334 let env_fields = Configuration::get_env_field_names();
336 for field in &env_fields {
337 settings
338 .env
339 .insert(field.to_string(), "old_value".to_string());
340 }
341
342 let config = Configuration {
344 alias_name: "test".to_string(),
345 token: "new_token".to_string(),
346 api_key: None,
347 url: "https://api.new.com".to_string(),
348 model: Some("new_model".to_string()),
349 small_fast_model: Some("new_fast_model".to_string()),
350 max_thinking_tokens: Some(50000),
351 api_timeout_ms: Some(300000),
352 claude_code_disable_nonessential_traffic: Some(1),
353 anthropic_default_sonnet_model: Some("new_sonnet".to_string()),
354 anthropic_default_opus_model: Some("new_opus".to_string()),
355 anthropic_default_haiku_model: Some("new_haiku".to_string()),
356 claude_code_experimental_agent_teams: None,
357 claude_code_disable_1m_context: None,
358 claude_code_subagent_model: None,
359 claude_code_disable_nonstreaming_fallback: None,
360 claude_code_effort_level: None,
361 disable_prompt_caching: None,
362 claude_code_disable_experimental_betas: None,
363 disable_autoupdater: None,
364 };
365
366 settings.switch_to_config(&config);
368
369 assert_eq!(
371 settings.env.get("ANTHROPIC_AUTH_TOKEN"),
372 Some(&"new_token".to_string())
373 );
374 assert_eq!(
375 settings.env.get("ANTHROPIC_BASE_URL"),
376 Some(&"https://api.new.com".to_string())
377 );
378 assert_eq!(
379 settings.env.get("ANTHROPIC_MODEL"),
380 Some(&"new_model".to_string())
381 );
382 assert_eq!(
383 settings.env.get("ANTHROPIC_SMALL_FAST_MODEL"),
384 Some(&"new_fast_model".to_string())
385 );
386
387 assert_eq!(
389 settings.env.get("ANTHROPIC_MAX_THINKING_TOKENS"),
390 Some(&"50000".to_string())
391 );
392 assert_eq!(
393 settings.env.get("API_TIMEOUT_MS"),
394 Some(&"300000".to_string())
395 );
396 assert_eq!(
397 settings.env.get("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC"),
398 Some(&"1".to_string())
399 );
400 assert_eq!(
401 settings.env.get("ANTHROPIC_DEFAULT_SONNET_MODEL"),
402 Some(&"new_sonnet".to_string())
403 );
404 assert_eq!(
405 settings.env.get("ANTHROPIC_DEFAULT_OPUS_MODEL"),
406 Some(&"new_opus".to_string())
407 );
408 assert_eq!(
409 settings.env.get("ANTHROPIC_DEFAULT_HAIKU_MODEL"),
410 Some(&"new_haiku".to_string())
411 );
412 }
413
414 #[test]
415 fn test_switch_to_config_removes_optional_fields_when_not_provided() {
416 let mut settings = ClaudeSettings::default();
417
418 let env_fields = Configuration::get_env_field_names();
420 for field in &env_fields {
421 settings
422 .env
423 .insert(field.to_string(), "old_value".to_string());
424 }
425
426 let config = Configuration {
428 alias_name: "test".to_string(),
429 token: "new_token".to_string(),
430 api_key: None,
431 url: "https://api.new.com".to_string(),
432 model: Some("new_model".to_string()),
433 small_fast_model: Some("new_fast_model".to_string()),
434 max_thinking_tokens: None,
435 api_timeout_ms: None,
436 claude_code_disable_nonessential_traffic: None,
437 anthropic_default_sonnet_model: None,
438 anthropic_default_opus_model: None,
439 anthropic_default_haiku_model: None,
440 claude_code_experimental_agent_teams: None,
441 claude_code_disable_1m_context: None,
442 claude_code_subagent_model: None,
443 claude_code_disable_nonstreaming_fallback: None,
444 claude_code_effort_level: None,
445 disable_prompt_caching: None,
446 claude_code_disable_experimental_betas: None,
447 disable_autoupdater: None,
448 };
449
450 settings.switch_to_config(&config);
452
453 assert_eq!(
455 settings.env.get("ANTHROPIC_AUTH_TOKEN"),
456 Some(&"new_token".to_string())
457 );
458 assert_eq!(
459 settings.env.get("ANTHROPIC_BASE_URL"),
460 Some(&"https://api.new.com".to_string())
461 );
462 assert_eq!(
463 settings.env.get("ANTHROPIC_MODEL"),
464 Some(&"new_model".to_string())
465 );
466 assert_eq!(
467 settings.env.get("ANTHROPIC_SMALL_FAST_MODEL"),
468 Some(&"new_fast_model".to_string())
469 );
470
471 assert!(!settings.env.contains_key("ANTHROPIC_MAX_THINKING_TOKENS"));
473 assert!(!settings.env.contains_key("API_TIMEOUT_MS"));
474 assert!(
475 !settings
476 .env
477 .contains_key("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC")
478 );
479 assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_SONNET_MODEL"));
480 assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_OPUS_MODEL"));
481 assert!(!settings.env.contains_key("ANTHROPIC_DEFAULT_HAIKU_MODEL"));
482 assert!(!settings.env.contains_key("CLAUDE_CODE_SUBAGENT_MODEL"));
483 assert!(
484 !settings
485 .env
486 .contains_key("CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK")
487 );
488 assert!(!settings.env.contains_key("CLAUDE_CODE_EFFORT_LEVEL"));
489 assert!(!settings.env.contains_key("DISABLE_PROMPT_CACHING"));
490 assert!(
491 !settings
492 .env
493 .contains_key("CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS")
494 );
495 assert!(!settings.env.contains_key("DISABLE_AUTOUPDATER"));
496 }
497}
498
499#[derive(Serialize, Deserialize, Default)]
504pub struct ConfigStorage {
505 pub configurations: ConfigMap,
507 pub claude_settings_dir: Option<String>,
509 #[serde(skip_serializing_if = "Option::is_none")]
511 pub default_storage_mode: Option<StorageMode>,
512 #[serde(skip_serializing_if = "Option::is_none")]
514 pub codex_configurations: Option<CodexConfigMap>,
515 #[serde(skip_serializing_if = "Option::is_none")]
517 pub omp_configurations: Option<OmpConfigMap>,
518 #[serde(skip_serializing_if = "Option::is_none")]
520 pub grok_configurations: Option<GrokConfigMap>,
521}
522
523#[derive(Default, Clone)]
528#[allow(dead_code)]
529pub struct ClaudeSettings {
530 pub env: EnvMap,
532 pub other: JsonMap,
534}
535
536impl Serialize for ClaudeSettings {
537 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
538 where
539 S: Serializer,
540 {
541 use serde::ser::SerializeMap;
542
543 let mut map = serializer.serialize_map(Some(
544 self.other.len() + if self.env.is_empty() { 0 } else { 1 },
545 ))?;
546
547 if !self.env.is_empty() {
549 map.serialize_entry("env", &self.env)?;
550 }
551
552 for (key, value) in &self.other {
554 map.serialize_entry(key, value)?;
555 }
556
557 map.end()
558 }
559}
560
561impl<'de> Deserialize<'de> for ClaudeSettings {
562 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
563 where
564 D: Deserializer<'de>,
565 {
566 #[derive(Deserialize)]
567 struct ClaudeSettingsHelper {
568 #[serde(default)]
569 env: EnvMap,
570 #[serde(flatten)]
571 other: JsonMap,
572 }
573
574 let helper = ClaudeSettingsHelper::deserialize(deserializer)?;
575 Ok(ClaudeSettings {
576 env: helper.env,
577 other: helper.other,
578 })
579 }
580}
581
582#[allow(dead_code)]
584pub struct AddCommandParams {
585 pub alias_name: String,
586 pub token: Option<String>,
587 pub api_key: Option<String>,
588 pub url: Option<String>,
589 pub model: Option<String>,
590 pub small_fast_model: Option<String>,
591 pub max_thinking_tokens: Option<u32>,
592 pub api_timeout_ms: Option<u32>,
593 pub claude_code_disable_nonessential_traffic: Option<u32>,
594 pub anthropic_default_sonnet_model: Option<String>,
595 pub anthropic_default_opus_model: Option<String>,
596 pub anthropic_default_haiku_model: Option<String>,
597 pub claude_code_subagent_model: Option<String>,
598 pub claude_code_disable_nonstreaming_fallback: Option<u32>,
599 pub claude_code_effort_level: Option<String>,
600 pub disable_prompt_caching: Option<u32>,
601 pub claude_code_disable_experimental_betas: Option<u32>,
602 pub disable_autoupdater: Option<u32>,
603 pub force: bool,
604 pub interactive: bool,
605 pub token_arg: Option<String>,
606 pub url_arg: Option<String>,
607 pub from_file: Option<String>,
608}