ai-account-switch 1.9.0 → 1.12.0

package/src/constants.js

@@ -0,0 +1,86 @@
+/**
+ * Constants for AI Account Switch (AIS)
+ * Centralized constants definition for the entire application
+ */
+
+// Wire API modes for Codex accounts
+const WIRE_API_MODES = {
+  CHAT: 'chat',
+  RESPONSES: 'responses',
+  ENV: 'env'
+};
+
+const DEFAULT_WIRE_API = WIRE_API_MODES.CHAT;
+
+// Account types
+const ACCOUNT_TYPES = {
+  CLAUDE: 'Claude',
+  CODEX: 'Codex',
+  CCR: 'CCR',
+  DROIDS: 'Droids'
+};
+
+// Account type values as array (for iteration)
+const ACCOUNT_TYPE_VALUES = ['Claude', 'Codex', 'CCR', 'Droids', 'Other'];
+
+// MCP server scopes
+const MCP_SCOPES = {
+  LOCAL: 'local',      // Only available in current project
+  PROJECT: 'project',  // Shared with project members via .mcp.json
+  USER: 'user'         // Available to all projects for current user (global)
+};
+
+const DEFAULT_MCP_SCOPE = MCP_SCOPES.LOCAL;
+
+// Model-related environment variable keys
+const MODEL_KEYS = [
+  'DEFAULT_MODEL',
+  'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  'CLAUDE_CODE_SUBAGENT_MODEL',
+  'ANTHROPIC_MODEL'
+];
+
+// Configuration file names
+const CONFIG_FILES = {
+  GLOBAL_DIR: '.ai-account-switch',
+  GLOBAL_CONFIG: 'config.json',
+  PROJECT_CONFIG: '.ais-project-config',
+  CLAUDE_DIR: '.claude',
+  CLAUDE_LOCAL_CONFIG: 'settings.local.json',
+  CLAUDE_USER_CONFIG: 'settings.json',
+  CODEX_DIR: '.codex',
+  CODEX_CONFIG: 'config.toml',
+  CODEX_AUTH: 'auth.json',
+  CODEX_PROFILE: '.codex-profile',
+  CCR_DIR: '.claude-code-router',
+  CCR_CONFIG: 'config.json',
+  DROIDS_DIR: '.droids',
+  DROIDS_CONFIG: 'config.json',
+  MCP_CONFIG: '.mcp.json'
+};
+
+// Default CCR port
+const DEFAULT_CCR_PORT = 3456;
+
+// Gitignore entries for AIS
+const GITIGNORE_ENTRIES = [
+  CONFIG_FILES.PROJECT_CONFIG,
+  `${CONFIG_FILES.CLAUDE_DIR}/${CONFIG_FILES.CLAUDE_LOCAL_CONFIG}`,
+  CONFIG_FILES.CODEX_PROFILE,
+  `${CONFIG_FILES.DROIDS_DIR}/${CONFIG_FILES.DROIDS_CONFIG}`
+];
+
+module.exports = {
+  WIRE_API_MODES,
+  DEFAULT_WIRE_API,
+  ACCOUNT_TYPES,
+  ACCOUNT_TYPE_VALUES,
+  MCP_SCOPES,
+  DEFAULT_MCP_SCOPE,
+  MODEL_KEYS,
+  CONFIG_FILES,
+  DEFAULT_CCR_PORT,
+  GITIGNORE_ENTRIES
+};

package/src/generators/base-generator.js

@@ -0,0 +1,124 @@
+/**
+ * Base Generator Class
+ * Provides common functionality for all configuration generators
+ */
+const fs = require('fs');
+const path = require('path');
+const { CONFIG_FILES, DEFAULT_CCR_PORT } = require('../constants');
+
+class BaseGenerator {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+  }
+
+  /**
+   * Ensure a directory exists, create if not
+   */
+  ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  /**
+   * Read and parse a JSON file
+   */
+  readJsonFile(filePath, defaultValue = {}) {
+    if (fs.existsSync(filePath)) {
+      try {
+        const data = fs.readFileSync(filePath, 'utf8');
+        return JSON.parse(data);
+      } catch (error) {
+        return defaultValue;
+      }
+    }
+    return defaultValue;
+  }
+
+  /**
+   * Write data to a JSON file
+   */
+  writeJsonFile(filePath, data) {
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf8');
+  }
+
+  /**
+   * Read auth.json file
+   */
+  readAuthJson(authJsonFile) {
+    if (!fs.existsSync(authJsonFile)) {
+      return {};
+    }
+
+    try {
+      const content = fs.readFileSync(authJsonFile, 'utf8');
+      return JSON.parse(content);
+    } catch (parseError) {
+      const chalk = require('chalk');
+      console.warn(
+        chalk.yellow(
+          `⚠ Warning: Could not parse existing auth.json, will create new file (警告: 无法解析现有 auth.json，将创建新文件)`
+        )
+      );
+      return {};
+    }
+  }
+
+  /**
+   * Write auth.json file atomically with proper permissions
+   */
+  writeAuthJson(authJsonFile, authData) {
+    const tempFile = `${authJsonFile}.tmp.${process.pid}`;
+
+    try {
+      // Write to temporary file first (atomic operation)
+      fs.writeFileSync(tempFile, JSON.stringify(authData, null, 2), 'utf8');
+
+      // Set file permissions to 600 (owner read/write only) for security
+      if (process.platform !== 'win32') {
+        fs.chmodSync(tempFile, 0o600);
+      }
+
+      // Atomically rename temp file to actual file
+      fs.renameSync(tempFile, authJsonFile);
+    } catch (error) {
+      // Clean up temp file if it exists
+      if (fs.existsSync(tempFile)) {
+        try {
+          fs.unlinkSync(tempFile);
+        } catch (cleanupError) {
+          // Ignore cleanup errors
+        }
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Get CCR port from config file
+   */
+  getCcrPort() {
+    const ccrConfigFile = path.join(require('os').homedir(), CONFIG_FILES.CCR_DIR, CONFIG_FILES.CCR_CONFIG);
+    let port = DEFAULT_CCR_PORT;
+    if (fs.existsSync(ccrConfigFile)) {
+      try {
+        const ccrConfig = JSON.parse(fs.readFileSync(ccrConfigFile, 'utf8'));
+        if (ccrConfig.PORT) {
+          port = ccrConfig.PORT;
+        }
+      } catch (e) {
+        // Use default port if reading fails
+      }
+    }
+    return port;
+  }
+
+  /**
+   * Generate configuration - to be implemented by subclasses
+   */
+  generate(account, options = {}) {
+    throw new Error('generate() must be implemented by subclass');
+  }
+}
+
+module.exports = BaseGenerator;

package/src/generators/ccr-generator.js

@@ -0,0 +1,113 @@
+/**
+ * CCR Configuration Generator
+ * Generates ~/.claude-code-router/config.json and Claude config for CCR
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const BaseGenerator = require('./base-generator');
+const ClaudeGenerator = require('./claude-generator');
+const { CONFIG_FILES } = require('../constants');
+
+class CCRGenerator extends BaseGenerator {
+  constructor(projectRoot) {
+    super(projectRoot);
+    this.ccrConfigDir = path.join(os.homedir(), CONFIG_FILES.CCR_DIR);
+    this.ccrConfigFile = path.join(this.ccrConfigDir, CONFIG_FILES.CCR_CONFIG);
+    this.claudeGenerator = new ClaudeGenerator(projectRoot);
+  }
+
+  /**
+   * Generate CCR configuration in ~/.claude-code-router/config.json
+   */
+  generateCCRConfig(account) {
+    // Read existing config
+    let config = {};
+    if (fs.existsSync(this.ccrConfigFile)) {
+      const data = fs.readFileSync(this.ccrConfigFile, 'utf8');
+      config = JSON.parse(data);
+    }
+
+    if (!account.ccrConfig) return;
+
+    const { providerName, models, defaultModel, backgroundModel, thinkModel } = account.ccrConfig;
+
+    // Check if provider exists
+    const providerIndex = config.Providers?.findIndex(p => p.name === providerName);
+
+    const provider = {
+      api_base_url: account.apiUrl || '',
+      api_key: account.apiKey,
+      models: models,
+      name: providerName
+    };
+
+    if (providerIndex >= 0) {
+      config.Providers[providerIndex] = provider;
+    } else {
+      if (!config.Providers) config.Providers = [];
+      config.Providers.push(provider);
+    }
+
+    // Update Router configuration
+    if (!config.Router) config.Router = {};
+    config.Router.default = `${providerName},${defaultModel}`;
+    config.Router.background = `${providerName},${backgroundModel}`;
+    config.Router.think = `${providerName},${thinkModel}`;
+
+    fs.writeFileSync(this.ccrConfigFile, JSON.stringify(config, null, 2), 'utf8');
+  }
+
+  /**
+   * Generate Claude configuration for CCR type accounts
+   */
+  generateClaudeConfigForCCR(account) {
+    const port = this.getCcrPort();
+
+    // Create .claude directory if it doesn't exist
+    const claudeDir = path.join(this.projectRoot, CONFIG_FILES.CLAUDE_DIR);
+    const claudeConfigFile = path.join(claudeDir, CONFIG_FILES.CLAUDE_LOCAL_CONFIG);
+    this.ensureDir(claudeDir);
+
+    // Read existing config if it exists
+    const existingConfig = this.readJsonFile(claudeConfigFile, {});
+
+    const claudeConfig = {
+      ...existingConfig,
+      env: {
+        ...(existingConfig.env || {}),
+        ANTHROPIC_AUTH_TOKEN: account.apiKey,
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${port}`
+      }
+    };
+
+    // Add custom environment variables if specified
+    if (account.customEnv && typeof account.customEnv === 'object') {
+      Object.keys(account.customEnv).forEach(key => {
+        claudeConfig.env[key] = account.customEnv[key];
+      });
+    }
+
+    // Preserve existing permissions if any
+    if (!claudeConfig.permissions) {
+      claudeConfig.permissions = existingConfig.permissions || {
+        allow: [],
+        deny: [],
+        ask: []
+      };
+    }
+
+    // Write Claude configuration
+    this.writeJsonFile(claudeConfigFile, claudeConfig);
+  }
+
+  /**
+   * Generate both CCR and Claude configurations
+   */
+  generate(account, options = {}) {
+    this.generateCCRConfig(account);
+    this.generateClaudeConfigForCCR(account);
+  }
+}
+
+module.exports = CCRGenerator;

package/src/generators/claude-generator.js

@@ -0,0 +1,124 @@
+/**
+ * Claude Configuration Generator
+ * Generates .claude/settings.local.json for Claude Code
+ */
+const fs = require('fs');
+const path = require('path');
+const BaseGenerator = require('./base-generator');
+const { MODEL_KEYS, CONFIG_FILES } = require('../constants');
+
+class ClaudeGenerator extends BaseGenerator {
+  constructor(projectRoot) {
+    super(projectRoot);
+    this.claudeDir = path.join(this.projectRoot, CONFIG_FILES.CLAUDE_DIR);
+    this.claudeConfigFile = path.join(this.claudeDir, CONFIG_FILES.CLAUDE_LOCAL_CONFIG);
+  }
+
+  /**
+   * Generate Claude Code .claude/settings.local.json configuration
+   */
+  generate(account, options = {}) {
+    this.ensureDir(this.claudeDir);
+
+    // Read existing config if it exists
+    const existingConfig = this.readJsonFile(this.claudeConfigFile, {});
+
+    // Build Claude configuration - preserve existing env but clear model configs
+    const existingEnv = existingConfig.env || {};
+    const cleanedEnv = {};
+
+    // Copy all existing env vars except model-related ones
+    Object.keys(existingEnv).forEach(key => {
+      if (!MODEL_KEYS.includes(key)) {
+        cleanedEnv[key] = existingEnv[key];
+      }
+    });
+
+    const claudeConfig = {
+      ...existingConfig,
+      env: {
+        ...cleanedEnv,
+        ANTHROPIC_AUTH_TOKEN: account.apiKey
+      }
+    };
+
+    // Add API URL if specified
+    if (account.apiUrl) {
+      claudeConfig.env.ANTHROPIC_BASE_URL = account.apiUrl;
+    }
+
+    // Add custom environment variables if specified
+    if (account.customEnv && typeof account.customEnv === 'object') {
+      Object.keys(account.customEnv).forEach(key => {
+        claudeConfig.env[key] = account.customEnv[key];
+      });
+    }
+
+    // Add model configuration from active model group
+    this._applyModelConfig(claudeConfig, account);
+
+    // Preserve existing permissions if any
+    if (!claudeConfig.permissions) {
+      claudeConfig.permissions = existingConfig.permissions || {
+        allow: [],
+        deny: [],
+        ask: []
+      };
+    }
+
+    // Add MCP servers if provided
+    if (options.mcpServers) {
+      claudeConfig.mcpServers = options.mcpServers;
+    }
+
+    // Write Claude configuration
+    this.writeJsonFile(this.claudeConfigFile, claudeConfig);
+  }
+
+  /**
+   * Apply model configuration from account
+   * @private
+   */
+  _applyModelConfig(claudeConfig, account) {
+    // Add model configuration from active model group
+    if (account.modelGroups && account.activeModelGroup) {
+      const activeGroup = account.modelGroups[account.activeModelGroup];
+
+      if (activeGroup && typeof activeGroup === 'object') {
+        const defaultModel = activeGroup.DEFAULT_MODEL;
+
+        // Set DEFAULT_MODEL if specified
+        if (defaultModel) {
+          claudeConfig.env.DEFAULT_MODEL = defaultModel;
+        }
+
+        // Set other model configs, using DEFAULT_MODEL as fallback if they're not specified
+        MODEL_KEYS.slice(1).forEach(key => {
+          if (activeGroup[key]) {
+            claudeConfig.env[key] = activeGroup[key];
+          } else if (defaultModel) {
+            claudeConfig.env[key] = defaultModel;
+          }
+        });
+      }
+    }
+    // Backward compatibility: support old modelConfig structure
+    else if (account.modelConfig && typeof account.modelConfig === 'object') {
+      const defaultModel = account.modelConfig.DEFAULT_MODEL;
+
+      if (defaultModel) {
+        claudeConfig.env.DEFAULT_MODEL = defaultModel;
+      }
+
+      MODEL_KEYS.slice(1).forEach(key => {
+        if (account.modelConfig[key]) {
+          claudeConfig.env[key] = account.modelConfig[key];
+        } else if (defaultModel) {
+          claudeConfig.env[key] = defaultModel;
+        }
+      });
+    }
+  }
+}
+
+module.exports = ClaudeGenerator;

package/src/generators/codex-generator.js

@@ -0,0 +1,207 @@
+/**
+ * Codex Configuration Generator
+ * Generates ~/.codex/config.toml and handles auth.json
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const chalk = require('chalk');
+const BaseGenerator = require('./base-generator');
+const { CONFIG_FILES } = require('../constants');
+
+class CodexGenerator extends BaseGenerator {
+  constructor(projectRoot) {
+    super(projectRoot);
+    this.codexConfigDir = path.join(os.homedir(), CONFIG_FILES.CODEX_DIR);
+    this.codexConfigFile = path.join(this.codexConfigDir, CONFIG_FILES.CODEX_CONFIG);
+    this.authJsonFile = path.join(this.codexConfigDir, CONFIG_FILES.CODEX_AUTH);
+  }
+
+  /**
+   * Generate Codex profile in global ~/.codex/config.toml
+   */
+  generate(account, options = {}) {
+    const { WIRE_API_MODES, DEFAULT_WIRE_API } = require('../constants');
+
+    // Create .codex directory if it doesn't exist
+    this.ensureDir(this.codexConfigDir);
+
+    // Read existing config if it exists
+    let existingConfig = '';
+    if (fs.existsSync(this.codexConfigFile)) {
+      existingConfig = fs.readFileSync(this.codexConfigFile, 'utf8');
+    }
+
+    // Generate profile name based on project path
+    const projectName = path.basename(this.projectRoot);
+    const profileName = `ais_${projectName}`;
+
+    // Build profile configuration
+    let profileConfig = `\n# AIS Profile for project: ${this.projectRoot}\n`;
+    profileConfig += `[profiles.${profileName}]\n`;
+
+    // For Codex type accounts, use custom provider configuration
+    const providerName = `ais_${account.name || 'provider'}`;
+    const escapedProviderName = providerName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+    profileConfig += `model_provider = "${providerName}"\n`;
+
+    // Add model configuration
+    if (account.model) {
+      profileConfig += `model = "${account.model}"\n`;
+    }
+
+    // Smart /v1 path handling
+    let baseUrl = account.apiUrl || '';
+    if (baseUrl) {
+      baseUrl = baseUrl.replace(/\/+$/, '');
+      const isDomainOnly = baseUrl.match(/^https?:\/\/[^\/]+$/);
+      if (isDomainOnly) {
+        baseUrl += '/v1';
+      }
+    }
+
+    // Remove existing provider if it exists
+    const providerPattern = new RegExp(`\\[model_providers\\.${escapedProviderName}\\][\\s\\S]*?(?=\\n\\[|$)`, 'g');
+    existingConfig = existingConfig.replace(providerPattern, '');
+
+    // Add new provider details
+    profileConfig += `\n[model_providers.${providerName}]\n`;
+    profileConfig += `name = "${providerName}"\n`;
+
+    if (baseUrl) {
+      profileConfig += `base_url = "${baseUrl}"\n`;
+    }
+
+    // Determine wire_api based on account configuration
+    const wireApi = account.wireApi || DEFAULT_WIRE_API;
+
+    if (wireApi === WIRE_API_MODES.CHAT) {
+      profileConfig += `wire_api = "${WIRE_API_MODES.CHAT}"\n`;
+      profileConfig += `http_headers = { "Authorization" = "Bearer ${account.apiKey}" }\n`;
+    } else if (wireApi === WIRE_API_MODES.RESPONSES) {
+      profileConfig += `wire_api = "${WIRE_API_MODES.RESPONSES}"\n`;
+      profileConfig += `requires_openai_auth = true\n`;
+      this.updateCodexAuthJson(account.apiKey);
+    } else if (wireApi === WIRE_API_MODES.ENV) {
+      profileConfig += `wire_api = "${WIRE_API_MODES.CHAT}"\n`;
+      const envKey = account.envKey || 'AIS_USER_API_KEY';
+      profileConfig += `env_key = "${envKey}"\n`;
+      this.clearCodexAuthJson();
+    }
+
+    // Remove all old profiles with the same name
+    existingConfig = this._removeProfileFromConfig(existingConfig, profileName);
+
+    // Append new profile
+    const newConfig = existingConfig.trimEnd() + '\n' + profileConfig;
+
+    // Write Codex configuration
+    fs.writeFileSync(this.codexConfigFile, newConfig, 'utf8');
+
+    // Create a helper script in project directory
+    const helperScript = path.join(this.projectRoot, '.codex-profile');
+    fs.writeFileSync(helperScript, profileName, 'utf8');
+
+    return { profileName };
+  }
+
+  /**
+   * Remove a profile from TOML config string
+   * @private
+   */
+  _removeProfileFromConfig(configContent, profileName) {
+    const lines = configContent.split('\n');
+    const cleanedLines = [];
+    let skipUntilNextSection = false;
+    const profileSectionHeader = `[profiles.${profileName}]`;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmedLine = line.trim();
+
+      if (trimmedLine === profileSectionHeader) {
+        skipUntilNextSection = true;
+
+        if (cleanedLines.length > 0) {
+          const lastLine = cleanedLines[cleanedLines.length - 1].trim();
+          if (lastLine.startsWith('# AIS Profile for project:')) {
+            cleanedLines.pop();
+          }
+        }
+
+        while (cleanedLines.length > 0 && cleanedLines[cleanedLines.length - 1].trim() === '') {
+          cleanedLines.pop();
+        }
+
+        continue;
+      }
+
+      if (skipUntilNextSection) {
+        if (trimmedLine.startsWith('[')) {
+          skipUntilNextSection = false;
+        } else {
+          continue;
+        }
+      }
+
+      cleanedLines.push(line);
+    }
+
+    let result = cleanedLines.join('\n');
+    result = result.replace(/\n{3,}/g, '\n\n');
+
+    return result;
+  }
+
+  /**
+   * Clear OPENAI_API_KEY in ~/.codex/auth.json for chat mode
+   */
+  clearCodexAuthJson() {
+    try {
+      this.ensureDir(this.codexConfigDir);
+      const authData = this.readAuthJson(this.authJsonFile);
+      authData.OPENAI_API_KEY = "";
+      this.writeAuthJson(this.authJsonFile, authData);
+
+      console.log(
+        chalk.cyan(
+          `✓ Cleared OPENAI_API_KEY in auth.json (chat mode) (已清空 auth.json 中的 OPENAI_API_KEY)`
+        )
+      );
+    } catch (error) {
+      console.error(
+        chalk.yellow(
+          `⚠ Warning: Failed to clear auth.json: ${error.message} (警告: 清空 auth.json 失败)`
+        )
+      );
+    }
+  }
+
+  /**
+   * Update ~/.codex/auth.json with API key for responses mode
+   */
+  updateCodexAuthJson(apiKey) {
+    try {
+      this.ensureDir(this.codexConfigDir);
+      const authData = this.readAuthJson(this.authJsonFile);
+      authData.OPENAI_API_KEY = apiKey;
+      this.writeAuthJson(this.authJsonFile, authData);
+
+      console.log(
+        chalk.green(
+          `✓ Updated auth.json at: ${this.authJsonFile} (已更新 auth.json)`
+        )
+      );
+    } catch (error) {
+      console.error(
+        chalk.red(
+          `✗ Failed to update auth.json: ${error.message} (更新 auth.json 失败)`
+        )
+      );
+      throw error;
+    }
+  }
+}
+
+module.exports = CodexGenerator;

package/src/generators/droids-generator.js

@@ -0,0 +1,49 @@
+/**
+ * Droids Configuration Generator
+ * Generates .droids/config.json
+ */
+const fs = require('fs');
+const path = require('path');
+const BaseGenerator = require('./base-generator');
+const { CONFIG_FILES } = require('../constants');
+
+class DroidsGenerator extends BaseGenerator {
+  constructor(projectRoot) {
+    super(projectRoot);
+    this.droidsDir = path.join(this.projectRoot, CONFIG_FILES.DROIDS_DIR);
+    this.droidsConfigFile = path.join(this.droidsDir, CONFIG_FILES.DROIDS_CONFIG);
+  }
+
+  /**
+   * Generate Droids configuration in .droids/config.json
+   */
+  generate(account, options = {}) {
+    // Create .droids directory if it doesn't exist
+    this.ensureDir(this.droidsDir);
+
+    // Build Droids configuration
+    const droidsConfig = {
+      apiKey: account.apiKey
+    };
+
+    // Add API URL if specified
+    if (account.apiUrl) {
+      droidsConfig.baseUrl = account.apiUrl;
+    }
+
+    // Add model configuration
+    if (account.model) {
+      droidsConfig.model = account.model;
+    }
+
+    // Add custom environment variables as customSettings
+    if (account.customEnv && typeof account.customEnv === 'object') {
+      droidsConfig.customSettings = account.customEnv;
+    }
+
+    // Write Droids configuration
+    this.writeJsonFile(this.droidsConfigFile, droidsConfig);
+  }
+}
+
+module.exports = DroidsGenerator;