claude-code-model-switch 1.0.3 → 2.2.0

package/README.md

@@ -4,12 +4,13 @@ A CLI tool for switching between different AI models in Claude Code.
 
 ## 🚀 Features
 
-- Quickly switch AI models used by Claude Code
+- Launch Claude Code with a preconfigured model in one command (yolo mode)
 - Support for multiple pre-configured model environments
-- Automatic handling of model-related environment variables
+- `start` injects model config as env vars; `config` persists to settings.json
+- `shared` env vars apply to all models (model-specific values override shared)
+- Automatic handling of model-related environment variables and defaults
 - Simple command-line interface
-- Secure configuration management - only modifies model-related settings
-- Reset to official models with unset command
+- `unset` removes model-related entries from settings.json
 
 ## 📦 Installation
 
@@ -22,11 +23,14 @@ npm install -g claude-code-model-switch
 ### Basic Commands
 
 ```bash
-# Switch to specified model
-ccms deepseek-chat
+# Launch Claude Code with the specified model (yolo mode enabled)
+ccms start deepseek-chat
 
-# Or use switch subcommand
-ccms switch deepseek-chat
+# Pass extra arguments directly to claude
+ccms start deepseek-chat -p "hello"
+
+# Write model configuration to ~/.claude/settings.json
+ccms config deepseek-chat
 
 # List all available models
 ccms list
@@ -34,8 +38,13 @@ ccms list
 # Show configuration file paths
 ccms config-path
 
-# Remove all model-related configuration and use official models
+# Remove model-related configuration from settings.json
 ccms unset
+
+# Manage shared environment variables for all models
+ccms shared list
+ccms shared set API_TIMEOUT_MS 600000
+ccms shared unset API_TIMEOUT_MS
 ```
 
 ### Model Configuration
@@ -44,6 +53,10 @@ Edit the configuration file `~/.claude-code-model-switch/settings.json`:
 
 ```json
 {
+  "shared": {
+    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
+    "API_TIMEOUT_MS": "600000"
+  },
   "models": {
     "deepseek-chat": {
       "ANTHROPIC_AUTH_TOKEN": "sk-your-token-here",
@@ -86,18 +99,20 @@ Edit the configuration file `~/.claude-code-model-switch/settings.json`:
 
 ### Special Rules
 
-1. **Secure Configuration**: The tool only modifies model-related environment variables and won't touch other fields in the configuration file
-2. **Default Values**:
+1. **start command**: `ccms start <model>` injects model config as environment variables and launches `claude` with `--dangerously-skip-permissions` (yolo mode)
+2. **config command**: `ccms config <model>` writes model config to `~/.claude/settings.json` for persistent configuration
+3. **shared env vars**: variables in `shared` apply to every model; model-specific values override shared ones
+4. **Default Values**:
    - `CLAUDE_CODE_MAX_OUTPUT_TOKENS` defaults to `8192`
    - `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` defaults to `1`
    - Unset model fields automatically use the value of `ANTHROPIC_MODEL`
-3. **Configuration File**: Empty configuration file `{"models": {}}` is automatically created on first run
-4. **Unset Command**: The `ccms unset` command removes only model-specific variables while preserving `CLAUDE_CODE_MAX_OUTPUT_TOKENS` and `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC`
+4. **Configuration File**: Empty configuration file `{"shared": {}, "models": {}}` is automatically created on first run
+5. **Unset Command**: `ccms unset` removes only model-specific variables from `settings.json` and restores official models
 
 ## 📁 File Locations
 
-- Claude settings file: `~/.claude/settings.json`
 - Model configuration file: `~/.claude-code-model-switch/settings.json`
+- Claude Code settings file (used by `config` / `unset`): `~/.claude/settings.json`
 
 ## 🔧 Development
 

package/README_CN.md

@@ -4,12 +4,13 @@
 
 ## 🚀 功能特性
 
-- 快速切换 Claude Code 使用的 AI 模型
+- 一条命令启动 Claude Code 并加载指定模型配置（yolo 模式）
 - 支持多个预配置模型环境
-- 自动处理模型相关环境变量
+- `start` 将模型配置注入环境变量，`config` 可持久化写入 settings.json
+- 支持 `shared` 公共环境变量，所有模型自动继承（模型配置可覆盖）
+- 自动处理模型相关环境变量及默认值
 - 命令行界面，操作简单
-- 安全的配置管理，只修改模型相关设置
-- 使用 unset 命令重置为官方模型
+- `unset` 可清除 settings.json 中的模型相关配置
 
 ## 📦 安装
 
@@ -22,11 +23,14 @@ npm install -g claude-code-model-switch
 ### 基本命令
 
 ```bash
-# 切换到指定模型
-ccms deepseek-chat
+# 用指定模型启动 Claude Code（自动启用 yolo 模式）
+ccms start deepseek-chat
 
-# 或者使用 switch 子命令
-ccms switch deepseek-chat
+# 将额外参数直接传给 claude
+ccms start deepseek-chat -p "hello"
+
+# 把模型配置写入 ~/.claude/settings.json
+ccms config deepseek-chat
 
 # 列出所有可用模型
 ccms list
@@ -34,8 +38,13 @@ ccms list
 # 查看配置文件路径
 ccms config-path
 
-# 清除所有模型相关配置，恢复使用官方模型
+# 清除 settings.json 中的模型相关配置，恢复使用官方模型
 ccms unset
+
+# 管理所有模型共享的环境变量
+ccms shared list
+ccms shared set API_TIMEOUT_MS 600000
+ccms shared unset API_TIMEOUT_MS
 ```
 
 ### 配置模型
@@ -44,6 +53,10 @@ ccms unset
 
 ```json
 {
+  "shared": {
+    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
+    "API_TIMEOUT_MS": "600000"
+  },
   "models": {
     "deepseek-chat": {
       "ANTHROPIC_AUTH_TOKEN": "sk-your-token-here",
@@ -86,18 +99,20 @@ ccms unset
 
 ### 特殊规则
 
-1. **安全配置**：工具只会修改与模型相关的环境变量，不会触及配置文件中的其他字段
-2. **默认值处理**：
+1. **start 命令**：`ccms start <model>` 将模型配置注入环境变量并启动 `claude`，默认附带 `--dangerously-skip-permissions`（yolo 模式）
+2. **config 命令**：`ccms config <model>` 将模型配置写入 `~/.claude/settings.json`，适合需要持久化配置的场景
+3. **shared 公共变量**：`shared` 中的环境变量会应用到所有模型；单个模型里同名变量会覆盖 shared
+4. **默认值处理**：
    - `CLAUDE_CODE_MAX_OUTPUT_TOKENS` 默认为 `8192`
    - `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` 默认为 `1`
    - 未设置的模型字段会自动使用 `ANTHROPIC_MODEL` 的值
-3. **配置文件**：首次运行时会自动创建空的配置文件 `{"models": {}}`
-4. **Unset 命令**：`ccms unset` 命令只删除模型特定的变量，同时保留 `CLAUDE_CODE_MAX_OUTPUT_TOKENS` 和 `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC`
+4. **配置文件**：首次运行时会自动创建空的配置文件 `{"shared": {}, "models": {}}`
+5. **Unset 命令**：`ccms unset` 只删除 `settings.json` 中的模型相关变量，恢复使用官方模型
 
 ## 📁 文件位置
 
-- Claude 设置文件：`~/.claude/settings.json`
 - 模型配置文件：`~/.claude-code-model-switch/settings.json`
+- Claude Code 设置文件（`config` / `unset` 使用）：`~/.claude/settings.json`
 
 ## 🔧 开发
 

package/example-config.json

@@ -1,4 +1,8 @@
 {
+  "shared": {
+    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
+    "API_TIMEOUT_MS": "600000"
+  },
   "models": {
     "deepseek-chat": {
       "ANTHROPIC_AUTH_TOKEN": "sk-caf695360e7f4b018bb1b308cbf992eb",
@@ -7,8 +11,7 @@
       "ANTHROPIC_SMALL_FAST_MODEL": "deepseek-chat",
       "ANTHROPIC_DEFAULT_SONNET_MODEL": "deepseek-chat",
       "ANTHROPIC_DEFAULT_OPUS_MODEL": "deepseek-chat",
-      "CLAUDE_CODE_MAX_OUTPUT_TOKENS": "8192",
-      "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
+      "CLAUDE_CODE_MAX_OUTPUT_TOKENS": "8192"
     },
     "claude-3-5-sonnet": {
       "ANTHROPIC_AUTH_TOKEN": "your-anthropic-token-here",
@@ -21,4 +24,4 @@
       "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "0"
     }
   }
-}
+}

package/index.js

@@ -2,17 +2,54 @@
 
 const fs = require('fs');
 const path = require('path');
+const { spawn } = require('child_process');
 const { program } = require('commander');
 
-// Configuration file paths
 const CLAUDE_SETTINGS_PATH = path.join(process.env.HOME, '.claude', 'settings.json');
 const MODEL_CONFIG_PATH = path.join(process.env.HOME, '.claude-code-model-switch', 'settings.json');
+const CLAUDE_BIN = process.env.CLAUDE_BIN || 'claude';
+const YOLO_ARGS = ['--dangerously-skip-permissions'];
 
-// Default values
 const DEFAULT_MAX_OUTPUT_TOKENS = '8192';
 const DEFAULT_DISABLE_NONESSENTIAL_TRAFFIC = '1';
 
-// Ensure configuration directory exists
+const MODEL_ENV_VARS = [
+  'ANTHROPIC_AUTH_TOKEN',
+  'ANTHROPIC_BASE_URL',
+  'ANTHROPIC_MODEL',
+  'ANTHROPIC_SMALL_FAST_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  'CLAUDE_CODE_MAX_OUTPUT_TOKENS',
+  'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC',
+  'CLAUDE_CODE_AUTO_COMPACT_WINDOW',
+  'API_TIMEOUT_MS'
+];
+
+const UNSET_ENV_VARS = [
+  'ANTHROPIC_AUTH_TOKEN',
+  'ANTHROPIC_BASE_URL',
+  'ANTHROPIC_MODEL',
+  'ANTHROPIC_SMALL_FAST_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  'ANTHROPIC_DEFAULT_HAIKU_MODEL'
+];
+
+const DERIVED_MODEL_FIELDS = [
+  'ANTHROPIC_SMALL_FAST_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  'ANTHROPIC_DEFAULT_HAIKU_MODEL'
+];
+
+const REQUIRED_ENV_VARS = [
+  'ANTHROPIC_MODEL',
+  'ANTHROPIC_AUTH_TOKEN',
+  'ANTHROPIC_BASE_URL'
+];
+
 function ensureConfigDir() {
   const configDir = path.dirname(MODEL_CONFIG_PATH);
   if (!fs.existsSync(configDir)) {
@@ -20,27 +57,23 @@ function ensureConfigDir() {
   }
 }
 
-// Load model configuration
 function loadModelConfig() {
   ensureConfigDir();
 
   if (!fs.existsSync(MODEL_CONFIG_PATH)) {
-    // Create empty default configuration file
-    const defaultConfig = { models: {} };
+    const defaultConfig = { shared: {}, models: {} };
     fs.writeFileSync(MODEL_CONFIG_PATH, JSON.stringify(defaultConfig, null, 2));
     return defaultConfig;
   }
 
   try {
-    const configContent = fs.readFileSync(MODEL_CONFIG_PATH, 'utf8');
-    return JSON.parse(configContent);
+    return JSON.parse(fs.readFileSync(MODEL_CONFIG_PATH, 'utf8'));
   } catch (error) {
     console.error('Error: Failed to parse model configuration file');
     process.exit(1);
   }
 }
 
-// Load Claude settings
 function loadClaudeSettings() {
   if (!fs.existsSync(CLAUDE_SETTINGS_PATH)) {
     console.error('Error: Claude settings file not found');
@@ -48,15 +81,13 @@ function loadClaudeSettings() {
   }
 
   try {
-    const settingsContent = fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8');
-    return JSON.parse(settingsContent);
+    return JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_PATH, 'utf8'));
   } catch (error) {
     console.error('Error: Failed to parse Claude settings file');
     process.exit(1);
   }
 }
 
-// Save Claude settings
 function saveClaudeSettings(settings) {
   try {
     fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
@@ -66,20 +97,52 @@ function saveClaudeSettings(settings) {
   }
 }
 
-// Get model configuration
-function getModelConfig(modelName) {
+function getValidModels(config = loadModelConfig()) {
+  return Object.keys(config.models || {}).filter(
+    (name) => config.models[name] && Object.keys(config.models[name]).length > 0
+  );
+}
+
+function reportUnknownModel(model) {
   const config = loadModelConfig();
+  const modelConfig = config.models && config.models[model];
 
-  if (!config.models || !config.models[modelName]) {
-    console.error(`Error: Model "${modelName}" not found`);
-    console.log('Available models:', Object.keys(config.models || {}).join(', ') || 'None');
-    console.log('Run "ccms --help" to see available commands');
+  if (modelConfig && Object.keys(modelConfig).length === 0) {
+    console.error(`Error: Model "${model}" configuration is empty`);
+  } else {
+    console.error(`Error: Model "${model}" not found`);
+  }
+
+  console.log('Available models:', getValidModels(config).join(', ') || 'None');
+  console.log('Run "ccms --help" to see available commands');
+  process.exit(1);
+}
+
+function saveModelConfig(config) {
+  ensureConfigDir();
+  try {
+    fs.writeFileSync(MODEL_CONFIG_PATH, JSON.stringify(config, null, 2));
+  } catch (error) {
+    console.error('Error: Failed to save model configuration file');
     process.exit(1);
   }
+}
+
+function getSharedEnv(config = loadModelConfig()) {
+  const shared = config.shared;
+  if (!shared || typeof shared !== 'object' || Array.isArray(shared)) {
+    return {};
+  }
+  return shared;
+}
+
+function getRawModelConfig(modelName, config = loadModelConfig()) {
+  if (!config.models || !config.models[modelName]) {
+    reportUnknownModel(modelName);
+  }
 
   const modelConfig = config.models[modelName];
 
-  // Check if model configuration is empty
   if (Object.keys(modelConfig).length === 0) {
     console.error(`Error: Model "${modelName}" configuration is empty`);
     console.log('Run "ccms --help" to see available commands');
@@ -89,67 +152,141 @@ function getModelConfig(modelName) {
   return modelConfig;
 }
 
-// Apply model configuration
-function applyModelConfig(modelConfig) {
-  const settings = loadClaudeSettings();
+function mergeModelConfig(modelName) {
+  const config = loadModelConfig();
+  const shared = getSharedEnv(config);
+  const modelConfig = getRawModelConfig(modelName, config);
 
-  // Ensure env object exists
-  if (!settings.env) {
-    settings.env = {};
-  }
+  return { ...shared, ...modelConfig };
+}
+
+function normalizeModelConfig(modelConfig) {
+  const normalized = { ...modelConfig };
 
-  // First, set default values for unset model fields in the config itself
-  // If ANTHROPIC_MODEL is set but other model fields are not, use ANTHROPIC_MODEL value
-  if (modelConfig.ANTHROPIC_MODEL) {
-    const derivedModelFields = [
-      'ANTHROPIC_SMALL_FAST_MODEL',
-      'ANTHROPIC_DEFAULT_SONNET_MODEL',
-      'ANTHROPIC_DEFAULT_OPUS_MODEL'
-    ];
-
-    for (const field of derivedModelFields) {
-      if (!modelConfig[field]) {
-        modelConfig[field] = modelConfig.ANTHROPIC_MODEL;
+  if (normalized.ANTHROPIC_MODEL) {
+    for (const field of DERIVED_MODEL_FIELDS) {
+      if (!normalized[field]) {
+        normalized[field] = normalized.ANTHROPIC_MODEL;
       }
     }
   }
 
-  // Only update model-related environment variables
-  const modelEnvVars = [
-    'ANTHROPIC_AUTH_TOKEN',
-    'ANTHROPIC_BASE_URL',
-    'ANTHROPIC_MODEL',
-    'ANTHROPIC_SMALL_FAST_MODEL',
-    'ANTHROPIC_DEFAULT_SONNET_MODEL',
-    'ANTHROPIC_DEFAULT_OPUS_MODEL',
-    'CLAUDE_CODE_MAX_OUTPUT_TOKENS',
-    'CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC'
-  ];
-
-  // Apply configuration
-  for (const key of modelEnvVars) {
-    if (modelConfig[key] !== undefined) {
-      settings.env[key] = modelConfig[key];
+  return normalized;
+}
+
+function buildModelEnv(modelConfig) {
+  const normalized = normalizeModelConfig(modelConfig);
+  const env = { ...process.env };
+
+  for (const [key, value] of Object.entries(normalized)) {
+    if (value !== undefined && value !== null) {
+      env[key] = String(value);
+    }
+  }
+
+  for (const envVar of REQUIRED_ENV_VARS) {
+    if (!env[envVar]) {
+      console.error(`Error: ${envVar} is required`);
+      process.exit(1);
     }
   }
 
-  // Handle default value logic
-  // Check required environment variables
-  const requiredEnvVars = [
-    'ANTHROPIC_MODEL',
-    'ANTHROPIC_AUTH_TOKEN',
-    'ANTHROPIC_BASE_URL'
-  ];
+  if (!env.CLAUDE_CODE_MAX_OUTPUT_TOKENS) {
+    env.CLAUDE_CODE_MAX_OUTPUT_TOKENS = DEFAULT_MAX_OUTPUT_TOKENS;
+  }
 
-  for (const envVar of requiredEnvVars) {
+  if (!env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC) {
+    env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = DEFAULT_DISABLE_NONESSENTIAL_TRAFFIC;
+  }
+
+  return env;
+}
+
+function getStartArgsFromArgv() {
+  const args = process.argv.slice(2);
+
+  if (args[0] !== 'start') {
+    return [];
+  }
+
+  let claudeArgs = args.slice(2);
+  if (claudeArgs[0] === '--') {
+    claudeArgs = claudeArgs.slice(1);
+  }
+
+  return claudeArgs;
+}
+
+function hasPermissionOverride(args) {
+  return args.some((arg) =>
+    arg === '--dangerously-skip-permissions' ||
+    arg === '--allow-dangerously-skip-permissions' ||
+    arg.startsWith('--permission-mode')
+  );
+}
+
+function buildStartArgs(userArgs = []) {
+  if (hasPermissionOverride(userArgs)) {
+    return userArgs;
+  }
+
+  return [...YOLO_ARGS, ...userArgs];
+}
+
+function launchClaude(env, claudeArgs = []) {
+  const child = spawn(CLAUDE_BIN, claudeArgs, {
+    env,
+    stdio: 'inherit'
+  });
+
+  child.on('error', (error) => {
+    if (error.code === 'ENOENT') {
+      console.error(`Error: "${CLAUDE_BIN}" command not found. Is Claude Code installed?`);
+    } else {
+      console.error(`Error: Failed to start Claude Code (${error.message})`);
+    }
+    process.exit(1);
+  });
+
+  child.on('close', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code ?? 0);
+  });
+}
+
+function startClaudeWithModel(modelName) {
+  const modelConfig = mergeModelConfig(modelName);
+  const env = buildModelEnv(modelConfig);
+  const claudeArgs = buildStartArgs(getStartArgsFromArgv());
+
+  console.log(`[ccms] starting claude code with model: ${env.ANTHROPIC_MODEL} (yolo mode)\n`);
+  launchClaude(env, claudeArgs);
+}
+
+function applyModelConfig(modelConfig) {
+  const settings = loadClaudeSettings();
+  const normalized = normalizeModelConfig(modelConfig);
+
+  if (!settings.env) {
+    settings.env = {};
+  }
+
+  for (const [key, value] of Object.entries(normalized)) {
+    if (value !== undefined && value !== null) {
+      settings.env[key] = String(value);
+    }
+  }
+
+  for (const envVar of REQUIRED_ENV_VARS) {
     if (!settings.env[envVar]) {
       console.error(`Error: ${envVar} is required`);
       process.exit(1);
     }
   }
 
-  
-  // Handle special environment variable defaults
   if (!settings.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS) {
     settings.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS = DEFAULT_MAX_OUTPUT_TOKENS;
   }
@@ -159,108 +296,67 @@ function applyModelConfig(modelConfig) {
   }
 
   saveClaudeSettings(settings);
-  console.log(`✅ Switched to model: ${settings.env.ANTHROPIC_MODEL}`);
+  console.log(`Switched to model: ${settings.env.ANTHROPIC_MODEL}`);
 }
 
-// List all models
-function listModels() {
-  const config = loadModelConfig();
-  const models = Object.keys(config.models || {});
+function configModel(modelName) {
+  const modelConfig = mergeModelConfig(modelName);
+  applyModelConfig(modelConfig);
+}
 
-  if (models.length === 0) {
-    console.log('No models configured');
+function listSharedEnv() {
+  const shared = getSharedEnv();
+  const keys = Object.keys(shared);
+
+  if (keys.length === 0) {
+    console.log('No shared environment variables configured');
     return;
   }
 
-  console.log('Available models:');
-  models.forEach(model => {
-    console.log(`  - ${model}`);
+  console.log('Shared environment variables:');
+  keys.forEach((key) => {
+    console.log(`  ${key}=${shared[key]}`);
   });
 }
 
-// Check if model name is valid
-function isValidModel(modelName) {
+function setSharedEnv(key, value) {
   const config = loadModelConfig();
-  return config.models &&
-         config.models[modelName] &&
-         Object.keys(config.models[modelName]).length > 0;
+
+  if (!config.shared || typeof config.shared !== 'object' || Array.isArray(config.shared)) {
+    config.shared = {};
+  }
+
+  config.shared[key] = value;
+  saveModelConfig(config);
+  console.log(`[ccms] shared env set: ${key}=${value}`);
 }
 
-// Main program
-program
-  .name('ccms')
-  .description('Claude Code Model Switch - Switch Claude Code models')
-  .version('1.0.3')
-  .argument('[model]', 'Model name to switch to')
-  .action((model) => {
-    if (model) {
-      // If model name argument provided, attempt to switch model
-      if (isValidModel(model)) {
-        const modelConfig = getModelConfig(model);
-        applyModelConfig(modelConfig);
-      } else {
-        const config = loadModelConfig();
-        const modelConfig = config.models && config.models[model];
-
-        if (modelConfig && Object.keys(modelConfig).length === 0) {
-          console.error(`Error: Model "${model}" configuration is empty`);
-        } else {
-          console.error(`Error: Model "${model}" not found`);
-        }
-
-        const validModels = Object.keys(config.models || {}).filter(name =>
-          config.models[name] && Object.keys(config.models[name]).length > 0
-        );
-        console.log('Available models:', validModels.join(', ') || 'None');
-        console.log('Run "ccms --help" to see available commands');
-        process.exit(1);
-      }
-    } else {
-      // If no arguments provided, show help information
-      program.help();
-    }
-  });
+function unsetSharedEnv(key) {
+  const config = loadModelConfig();
+  const shared = getSharedEnv(config);
 
-program
-  .command('switch <model>')
-  .description('Switch to specified model')
-  .action((model) => {
-    const modelConfig = getModelConfig(model);
-    applyModelConfig(modelConfig);
-  });
+  if (!Object.prototype.hasOwnProperty.call(shared, key)) {
+    console.log(`No shared environment variable found: ${key}`);
+    return;
+  }
 
-program
-  .command('list')
-  .description('List all available models')
-  .action(() => {
-    listModels();
-  });
+  delete config.shared[key];
+  saveModelConfig(config);
+  console.log(`[ccms] shared env removed: ${key}`);
+}
 
-// Unset all model-related configuration
 function unsetModelConfig() {
   const settings = loadClaudeSettings();
 
-  // Ensure env object exists
   if (!settings.env) {
     settings.env = {};
   }
 
-  // Model-related environment variables to remove (excluding some settings)
-  const modelEnvVars = [
-    'ANTHROPIC_AUTH_TOKEN',
-    'ANTHROPIC_BASE_URL',
-    'ANTHROPIC_MODEL',
-    'ANTHROPIC_SMALL_FAST_MODEL',
-    'ANTHROPIC_DEFAULT_SONNET_MODEL',
-    'ANTHROPIC_DEFAULT_OPUS_MODEL'
-  ];
-
   let removedCount = 0;
   const removedVars = [];
 
-  // Remove only existing model-related environment variables
-  for (const key of modelEnvVars) {
-    if (settings.env.hasOwnProperty(key)) {
+  for (const key of UNSET_ENV_VARS) {
+    if (Object.prototype.hasOwnProperty.call(settings.env, key)) {
       delete settings.env[key];
       removedCount++;
       removedVars.push(key);
@@ -277,6 +373,48 @@ function unsetModelConfig() {
   }
 }
 
+function listModels() {
+  const models = getValidModels();
+
+  if (models.length === 0) {
+    console.log('No models configured');
+    return;
+  }
+
+  console.log('Available models:');
+  models.forEach((model) => {
+    console.log(`  - ${model}`);
+  });
+}
+
+program
+  .name('ccms')
+  .description('Claude Code Model Switch - Manage and launch Claude Code with configured models')
+  .version('2.2.0');
+
+program
+  .command('start <model> [claude-args...]')
+  .description('Launch Claude Code with model env vars (yolo mode enabled)')
+  .allowUnknownOption()
+  .allowExcessArguments()
+  .action((model) => {
+    startClaudeWithModel(model);
+  });
+
+program
+  .command('config <model>')
+  .description('Write model configuration to ~/.claude/settings.json')
+  .action((model) => {
+    configModel(model);
+  });
+
+program
+  .command('list')
+  .description('List all available models')
+  .action(() => {
+    listModels();
+  });
+
 program
   .command('config-path')
   .description('Display configuration file paths')
@@ -287,9 +425,48 @@ program
 
 program
   .command('unset')
-  .description('Remove all model-related configuration and use official models')
+  .description('Remove model-related configuration from ~/.claude/settings.json')
   .action(() => {
     unsetModelConfig();
   });
 
-program.parse();
+program
+  .command('shared')
+  .description('Manage shared environment variables for all models')
+  .argument('[action]', 'list, set, or unset')
+  .argument('[key]', 'Environment variable name')
+  .argument('[value]', 'Environment variable value')
+  .action((action, key, value) => {
+    if (!action || action === 'list') {
+      listSharedEnv();
+      return;
+    }
+
+    if (action === 'set') {
+      if (!key || value === undefined) {
+        console.error('Usage: ccms shared set <key> <value>');
+        process.exit(1);
+      }
+      setSharedEnv(key, value);
+      return;
+    }
+
+    if (action === 'unset') {
+      if (!key) {
+        console.error('Usage: ccms shared unset <key>');
+        process.exit(1);
+      }
+      unsetSharedEnv(key);
+      return;
+    }
+
+    console.error(`Unknown shared action: ${action}`);
+    console.log('Usage: ccms shared [list|set <key> <value>|unset <key>]');
+    process.exit(1);
+  });
+
+program.parse();
+
+if (!process.argv.slice(2).length) {
+  program.help();
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "claude-code-model-switch",
-  "version": "1.0.3",
-  "description": "A CLI tool to switch Claude Code models",
+  "version": "2.2.0",
+  "description": "Launch Claude Code with preconfigured model environments",
   "main": "index.js",
   "bin": {
-    "ccms": "./index.js"
+    "ccms": "index.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"