Skip to main content

cc_switch/config/
types.rs

1use serde::{Deserialize, Deserializer, Serialize, Serializer};
2use std::collections::BTreeMap;
3
4/// Type alias for configuration map
5type ConfigMap = BTreeMap<String, Configuration>;
6/// Type alias for environment variable map
7type EnvMap = BTreeMap<String, String>;
8/// Type alias for JSON value map
9type JsonMap = BTreeMap<String, serde_json::Value>;
10/// Type alias for Codex configuration map
11type CodexConfigMap = BTreeMap<String, crate::codex::CodexConfiguration>;
12/// Type alias for OMP configuration map
13type OmpConfigMap = BTreeMap<String, crate::omp::OmpConfiguration>;
14
15/// Storage mode for how configuration should be written to settings.json
16#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
17pub enum StorageMode {
18    /// Write to env field with uppercase environment variable names (default)
19    #[serde(rename = "env")]
20    #[default]
21    Env,
22    /// Write to root level with camelCase field names
23    #[serde(rename = "config")]
24    Config,
25}
26
27/// Represents a Claude API configuration
28///
29/// Contains the components needed to configure Claude API access:
30/// - alias_name: User-friendly identifier for the configuration
31/// - token: API authentication token
32/// - url: Base URL for the API endpoint
33/// - model: Optional custom model name
34/// - small_fast_model: Optional Haiku-class model for background tasks
35#[derive(Serialize, Deserialize, Default, Clone)]
36pub struct Configuration {
37    /// User-friendly alias name for this configuration
38    pub alias_name: String,
39    /// ANTHROPIC_AUTH_TOKEN value (API authentication token)
40    pub token: String,
41    /// ANTHROPIC_API_KEY value (alternative to AUTH_TOKEN, mutually exclusive)
42    #[serde(skip_serializing_if = "Option::is_none")]
43    pub api_key: Option<String>,
44    /// ANTHROPIC_BASE_URL value (API endpoint URL)
45    pub url: String,
46    /// ANTHROPIC_MODEL value (custom model name)
47    #[serde(skip_serializing_if = "Option::is_none")]
48    pub model: Option<String>,
49    /// ANTHROPIC_SMALL_FAST_MODEL value (Haiku-class model for background tasks)
50    #[serde(skip_serializing_if = "Option::is_none")]
51    pub small_fast_model: Option<String>,
52    /// ANTHROPIC_MAX_THINKING_TOKENS value (Maximum thinking tokens limit)
53    #[serde(skip_serializing_if = "Option::is_none")]
54    pub max_thinking_tokens: Option<u32>,
55    /// API timeout in milliseconds
56    #[serde(skip_serializing_if = "Option::is_none")]
57    pub api_timeout_ms: Option<u32>,
58    /// Disable non-essential traffic flag
59    #[serde(skip_serializing_if = "Option::is_none")]
60    pub claude_code_disable_nonessential_traffic: Option<u32>,
61    /// Default Sonnet model name
62    #[serde(skip_serializing_if = "Option::is_none")]
63    pub anthropic_default_sonnet_model: Option<String>,
64    /// Default Opus model name
65    #[serde(skip_serializing_if = "Option::is_none")]
66    pub anthropic_default_opus_model: Option<String>,
67    /// Default Haiku model name
68    #[serde(skip_serializing_if = "Option::is_none")]
69    pub anthropic_default_haiku_model: Option<String>,
70    /// Enable experimental agent teams flag
71    #[serde(skip_serializing_if = "Option::is_none")]
72    pub claude_code_experimental_agent_teams: Option<u32>,
73    /// Disable 1M context limit flag
74    #[serde(skip_serializing_if = "Option::is_none")]
75    pub claude_code_disable_1m_context: Option<u32>,
76    /// Subagent model name
77    #[serde(skip_serializing_if = "Option::is_none")]
78    pub claude_code_subagent_model: Option<String>,
79    /// Disable non-streaming fallback flag
80    #[serde(skip_serializing_if = "Option::is_none")]
81    pub claude_code_disable_nonstreaming_fallback: Option<u32>,
82    /// Effort level for Claude Code
83    #[serde(skip_serializing_if = "Option::is_none")]
84    pub claude_code_effort_level: Option<String>,
85    /// Disable prompt caching flag
86    #[serde(skip_serializing_if = "Option::is_none")]
87    pub disable_prompt_caching: Option<u32>,
88    /// Disable experimental betas flag
89    #[serde(skip_serializing_if = "Option::is_none")]
90    pub claude_code_disable_experimental_betas: Option<u32>,
91    /// Disable auto-updater flag
92    #[serde(skip_serializing_if = "Option::is_none")]
93    pub disable_autoupdater: Option<u32>,
94}
95
96impl Configuration {
97    /// Get all environment variable names that this configuration can set
98    ///
99    /// Returns a vector of all UPPERCASE environment variable names
100    /// that can be set by this configuration, used for conflict detection
101    /// in config mode.
102    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    /// Get the authentication credential and its environment variable name.
127    ///
128    /// Returns `("ANTHROPIC_API_KEY", key)` when `api_key` is set,
129    /// otherwise `("ANTHROPIC_AUTH_TOKEN", token)`.
130    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    /// Get environment variable names that should be cleared in env mode
139    ///
140    /// Returns a vector of UPPERCASE environment variable names that are
141    /// configuration-specific and should be cleared from settings.json when
142    /// switching in env mode. User preference fields are excluded.
143    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            // User preference fields are NOT included:
158            // - CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC
159            // - CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS
160            // - CLAUDE_CODE_DISABLE_1M_CONTEXT
161            // - CLAUDE_CODE_DISABLE_NONSTREAMING_FALLBACK
162            // - DISABLE_PROMPT_CACHING
163            // - CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS
164            // - DISABLE_AUTOUPDATER
165        ]
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        // Verify all expected fields are present
178        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        // Verify all fields are uppercase
215        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        // Verify clearable fields (excludes user preference fields)
230        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        // User preference fields should NOT be in clearable list
246        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        // Verify excluded fields are NOT present
271        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        // Add all possible environment variables
285        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        // Add some other env variables that shouldn't be removed
293        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        // Remove Anthropic environment variables
301        settings.remove_anthropic_env();
302
303        // Verify all Anthropic fields are removed
304        for field in &env_fields {
305            assert!(
306                !settings.env.contains_key(*field),
307                "Field {} should be removed",
308                field
309            );
310        }
311
312        // Verify other fields are preserved
313        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        // Add all possible environment variables
333        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        // Create a test configuration
341        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        // Switch to new configuration
365        settings.switch_to_config(&config);
366
367        // Verify the required fields are set correctly
368        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        // Verify additional fields are set correctly when provided in config
386        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        // Add all possible environment variables with old values
417        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        // Create a test configuration without optional fields
425        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        // Switch to new configuration
449        settings.switch_to_config(&config);
450
451        // Verify the required fields are set correctly
452        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        // Verify optional fields are removed when not provided in config
470        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/// Storage manager for Claude API configurations
498///
499/// Handles persistence and retrieval of multiple API configurations
500/// stored in `~/.cc_auto_switch/configurations.json`
501#[derive(Serialize, Deserialize, Default)]
502pub struct ConfigStorage {
503    /// Map of alias names to configuration objects
504    pub configurations: ConfigMap,
505    /// Custom directory for Claude settings (optional)
506    pub claude_settings_dir: Option<String>,
507    /// Default storage mode for writing configurations (None = use env mode)
508    #[serde(skip_serializing_if = "Option::is_none")]
509    pub default_storage_mode: Option<StorageMode>,
510    /// Codex (OpenAI) configurations, stored separately from Claude configurations
511    #[serde(skip_serializing_if = "Option::is_none")]
512    pub codex_configurations: Option<CodexConfigMap>,
513    /// OMP configurations, stored separately from Claude configurations
514    #[serde(skip_serializing_if = "Option::is_none")]
515    pub omp_configurations: Option<OmpConfigMap>,
516}
517
518/// Claude settings manager for API configuration
519///
520/// Manages the Claude settings.json file to control Claude's API configuration
521/// Handles environment variables and preserves other settings
522#[derive(Default, Clone)]
523#[allow(dead_code)]
524pub struct ClaudeSettings {
525    /// Environment variables map (ANTHROPIC_AUTH_TOKEN, ANTHROPIC_BASE_URL, ANTHROPIC_MODEL, ANTHROPIC_SMALL_FAST_MODEL)
526    pub env: EnvMap,
527    /// Other settings to preserve when modifying API configuration
528    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        // Serialize env field only if it has content
543        if !self.env.is_empty() {
544            map.serialize_entry("env", &self.env)?;
545        }
546
547        // Serialize other fields
548        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/// Parameters for adding a new configuration
578#[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}