ccman 1.0.1 → 2.0.0

package/src/commands/lang.ts

@@ -0,0 +1,105 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { LanguageManager } from '../i18n/LanguageManager';
+
+export function createLanguageCommands(): Command {
+  const langCommand = new Command('lang');
+  const languageManager = new LanguageManager();
+
+  langCommand
+    .description('Manage language settings / 管理语言设置');
+
+  // ccman lang - 显示当前语言设置
+  langCommand
+    .action(async () => {
+      try {
+        const stats = await languageManager.getLanguageStats();
+        const messages = await languageManager.getMessages();
+        
+        console.log();
+        console.log(chalk.blue(`${messages.language.current} ${getLanguageDisplayName(stats.current)}`));
+        
+        if (stats.current === 'auto') {
+          console.log(chalk.gray(`Auto-detected: ${getLanguageDisplayName(stats.autoDetected!)}`));
+        }
+        
+        console.log(chalk.cyan(messages.language.availableCommands));
+        console.log();
+        
+      } catch (error) {
+        console.error(chalk.red(`✗ Error: ${error}`));
+        process.exit(1);
+      }
+    });
+
+  // ccman lang set <language> - 设置语言
+  langCommand
+    .command('set <language>')
+    .description('Set language preference / 设置语言偏好')
+    .action(async (language: string) => {
+      try {
+        if (!['zh', 'en', 'auto'].includes(language)) {
+          const messages = await languageManager.getMessages();
+          console.error(chalk.red(`✗ ${messages.language.invalidLanguage}`));
+          process.exit(1);
+        }
+
+        await languageManager.setLanguage(language as 'zh' | 'en' | 'auto');
+        
+        // 重新获取消息（可能语言已变更）
+        const messages = await languageManager.getMessages();
+        console.log(chalk.green(`✓ ${messages.language.switchSuccess}`));
+        console.log(chalk.cyan(`${messages.language.current} ${getLanguageDisplayName(language)}`));
+        
+      } catch (error) {
+        console.error(chalk.red(`✗ Error: ${error}`));
+        process.exit(1);
+      }
+    });
+
+  // ccman lang reset - 重置语言设置
+  langCommand
+    .command('reset')
+    .description('Reset language setting to first-run state / 重置语言设置为首次运行状态')
+    .action(async () => {
+      try {
+        const messages = await languageManager.getMessages();
+        
+        const answer = await inquirer.prompt([
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message: messages.language.resetConfirm,
+            default: false
+          }
+        ]);
+
+        if (answer.confirm) {
+          await languageManager.resetLanguage();
+          console.log(chalk.green(`✓ ${messages.language.resetSuccess}`));
+        } else {
+          console.log(chalk.yellow(messages.cancelled));
+        }
+        
+      } catch (error) {
+        console.error(chalk.red(`✗ Error: ${error}`));
+        process.exit(1);
+      }
+    });
+
+  return langCommand;
+}
+
+function getLanguageDisplayName(lang: string): string {
+  switch (lang) {
+    case 'zh':
+      return '中文 (Chinese)';
+    case 'en':
+      return 'English';
+    case 'auto':
+      return 'Auto-detect / 自动检测';
+    default:
+      return lang;
+  }
+}

package/src/core/CCMConfigManager.ts

@@ -0,0 +1,185 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as os from 'os';
+import { CCMConfig, ProviderConfig } from '../types';
+import { getPackageVersion } from '../utils/version';
+
+/**
+ * CCM配置管理器
+ * 负责管理 ~/.ccman/ 目录下的配置文件
+ */
+export class CCMConfigManager {
+  private configDir: string;
+  private configPath: string;
+  private providersDir: string;
+
+  constructor() {
+    // 使用环境变量支持开发时的配置隔离
+    const configDirName = process.env.CCM_CONFIG_DIR || '.ccman-dev';
+    this.configDir = path.join(os.homedir(), configDirName);
+    this.configPath = path.join(this.configDir, 'config.json');
+    this.providersDir = path.join(this.configDir, 'providers');
+  }
+
+  /**
+   * 初始化配置目录和文件
+   */
+  async init(): Promise<void> {
+    await fs.ensureDir(this.configDir);
+    await fs.ensureDir(this.providersDir);
+    
+    if (!await fs.pathExists(this.configPath)) {
+      const defaultConfig: CCMConfig = {
+        currentProvider: '',
+        claudeConfigPath: process.env.CLAUDE_CONFIG_PATH || path.join(os.homedir(), '.claude', 'settings-dev.json'),
+        providers: {},
+        settings: {
+          language: null,
+          firstRun: true
+        },
+        metadata: {
+          version: getPackageVersion(),
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString()
+        }
+      };
+      
+      await fs.writeFile(this.configPath, JSON.stringify(defaultConfig, null, 2));
+    }
+  }
+
+  /**
+   * 读取主配置
+   */
+  async readConfig(): Promise<CCMConfig> {
+    try {
+      if (!await fs.pathExists(this.configPath)) {
+        await this.init();
+      }
+      
+      const content = await fs.readFile(this.configPath, 'utf8');
+      const config = JSON.parse(content);
+      
+      // 确保providers字段存在
+      if (!config.providers) {
+        config.providers = {};
+      }
+
+      // 确保settings字段存在（兼容旧版本）
+      if (!config.settings) {
+        config.settings = {
+          language: null,
+          firstRun: true
+        };
+      }
+      
+      return config;
+    } catch (error) {
+      throw new Error(`Failed to read CCM config: ${error}`);
+    }
+  }
+
+  /**
+   * 写入主配置
+   */
+  async writeConfig(config: CCMConfig): Promise<void> {
+    try {
+      config.metadata.updatedAt = new Date().toISOString();
+      await fs.writeFile(this.configPath, JSON.stringify(config, null, 2));
+    } catch (error) {
+      throw new Error(`Failed to write CCM config: ${error}`);
+    }
+  }
+
+  /**
+   * 读取供应商配置
+   */
+  async readProviderConfig(providerId: string): Promise<ProviderConfig | null> {
+    try {
+      const providerPath = path.join(this.providersDir, `${providerId}.json`);
+      
+      if (!await fs.pathExists(providerPath)) {
+        return null;
+      }
+      
+      const content = await fs.readFile(providerPath, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      throw new Error(`Failed to read provider config: ${error}`);
+    }
+  }
+
+  /**
+   * 写入供应商配置
+   */
+  async writeProviderConfig(providerId: string, config: ProviderConfig): Promise<void> {
+    try {
+      const providerPath = path.join(this.providersDir, `${providerId}.json`);
+      config.metadata.updatedAt = new Date().toISOString();
+      
+      await fs.writeFile(providerPath, JSON.stringify(config, null, 2));
+    } catch (error) {
+      throw new Error(`Failed to write provider config: ${error}`);
+    }
+  }
+
+  /**
+   * 删除供应商配置
+   */
+  async deleteProviderConfig(providerId: string): Promise<void> {
+    try {
+      const providerPath = path.join(this.providersDir, `${providerId}.json`);
+      
+      if (await fs.pathExists(providerPath)) {
+        await fs.remove(providerPath);
+      }
+    } catch (error) {
+      throw new Error(`Failed to delete provider config: ${error}`);
+    }
+  }
+
+  /**
+   * 列出所有供应商配置文件
+   */
+  async listProviderFiles(): Promise<string[]> {
+    try {
+      if (!await fs.pathExists(this.providersDir)) {
+        return [];
+      }
+      
+      const files = await fs.readdir(this.providersDir);
+      return files
+        .filter((file: string) => file.endsWith('.json'))
+        .map((file: string) => file.replace('.json', ''));
+    } catch (error) {
+      throw new Error(`Failed to list provider files: ${error}`);
+    }
+  }
+
+  /**
+   * 清除所有配置
+   */
+  async clearAll(): Promise<void> {
+    try {
+      if (await fs.pathExists(this.configDir)) {
+        await fs.remove(this.configDir);
+      }
+    } catch (error) {
+      throw new Error(`Failed to clear all configs: ${error}`);
+    }
+  }
+
+  /**
+   * 获取配置目录路径
+   */
+  getConfigDir(): string {
+    return this.configDir;
+  }
+
+  /**
+   * 获取供应商配置目录路径
+   */
+  getProvidersDir(): string {
+    return this.providersDir;
+  }
+}

package/src/core/ClaudeConfigManager.ts

@@ -0,0 +1,127 @@
+import * as fs from 'fs-extra';
+import * as path from 'path';
+import * as os from 'os';
+import { ClaudeSettings } from '../types';
+
+/**
+ * Claude配置管理器
+ * 负责直接修改 ~/.claude/settings.json
+ */
+export class ClaudeConfigManager {
+  private claudeConfigPath: string;
+
+  constructor(claudeConfigPath?: string) {
+    // 优先使用传入参数，其次使用环境变量，最后使用开发默认路径
+    this.claudeConfigPath = claudeConfigPath || 
+                           process.env.CLAUDE_CONFIG_PATH || 
+                           path.join(os.homedir(), '.claude', 'settings-dev.json');
+  }
+
+  /**
+   * 读取Claude配置
+   */
+  async readClaudeConfig(): Promise<ClaudeSettings | null> {
+    try {
+      if (!await fs.pathExists(this.claudeConfigPath)) {
+        return null;
+      }
+      
+      const content = await fs.readFile(this.claudeConfigPath, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      throw new Error(`Failed to read Claude config: ${error}`);
+    }
+  }
+
+  /**
+   * 选择性写入Claude配置
+   * 只覆盖指定的key，保留其他用户配置
+   */
+  async writeClaudeConfig(config: ClaudeSettings): Promise<void> {
+    try {
+      await fs.ensureDir(path.dirname(this.claudeConfigPath));
+      
+      let existingConfig: any = {};
+      
+      // 如果文件已存在，先读取现有配置
+      if (await fs.pathExists(this.claudeConfigPath)) {
+        const content = await fs.readFile(this.claudeConfigPath, 'utf8');
+        existingConfig = JSON.parse(content);
+      }
+      
+      // 选择性覆盖只有CCM管理的key
+      const mergedConfig = {
+        ...existingConfig, // 保留现有配置
+        env: {
+          ...existingConfig.env, // 保留现有env配置
+          // 只覆盖CCM管理的环境变量
+          ANTHROPIC_AUTH_TOKEN: config.env.ANTHROPIC_AUTH_TOKEN,
+          ANTHROPIC_BASE_URL: config.env.ANTHROPIC_BASE_URL,
+          CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: config.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC
+        },
+        permissions: {
+          ...existingConfig.permissions, // 保留现有permissions配置
+          // 覆盖CCM管理的权限设置
+          allow: config.permissions.allow,
+          deny: config.permissions.deny
+        },
+        // 覆盖apiKeyHelper
+        apiKeyHelper: config.apiKeyHelper
+      };
+      
+      await fs.writeFile(this.claudeConfigPath, JSON.stringify(mergedConfig, null, 2), 'utf8');
+    } catch (error) {
+      throw new Error(`Failed to write Claude config: ${error}`);
+    }
+  }
+
+  /**
+   * 备份当前Claude配置
+   */
+  async backupClaudeConfig(): Promise<string> {
+    try {
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const backupPath = `${this.claudeConfigPath}.backup-${timestamp}`;
+      
+      if (await fs.pathExists(this.claudeConfigPath)) {
+        await fs.copy(this.claudeConfigPath, backupPath);
+        return backupPath;
+      }
+      
+      return '';
+    } catch (error) {
+      throw new Error(`Failed to backup Claude config: ${error}`);
+    }
+  }
+
+  /**
+   * 恢复Claude配置
+   */
+  async restoreClaudeConfig(backupPath: string): Promise<void> {
+    try {
+      if (await fs.pathExists(backupPath)) {
+        await fs.copy(backupPath, this.claudeConfigPath);
+      }
+    } catch (error) {
+      throw new Error(`Failed to restore Claude config: ${error}`);
+    }
+  }
+
+  /**
+   * 验证Claude配置目录是否存在
+   */
+  async ensureClaudeConfigDir(): Promise<void> {
+    const claudeDir = path.dirname(this.claudeConfigPath);
+    
+    if (!await fs.pathExists(claudeDir)) {
+      throw new Error(`Claude config directory not found: ${claudeDir}. Please ensure Claude Code is installed and initialized.`);
+    }
+  }
+
+  /**
+   * 获取Claude配置路径
+   */
+  getClaudeConfigPath(): string {
+    return this.claudeConfigPath;
+  }
+}

package/src/i18n/LanguageManager.ts

@@ -0,0 +1,169 @@
+import inquirer from 'inquirer';
+import { MessageBundle, chineseMessages, englishMessages } from './messages';
+import { CCMConfigManager } from '../core/CCMConfigManager';
+import { LanguageStats } from '../types';
+
+export class LanguageManager {
+  private configManager: CCMConfigManager;
+  
+  constructor() {
+    this.configManager = new CCMConfigManager();
+  }
+
+  /**
+   * 检测系统是否为英文环境
+   */
+  private shouldUseEnglish(): boolean {
+    const locale = process.env.LANG || process.env.LANGUAGE || '';
+    return locale.toLowerCase().startsWith('en');
+  }
+
+  /**
+   * 检查是否为首次运行
+   */
+  async isFirstRun(): Promise<boolean> {
+    try {
+      await this.configManager.init();
+      const config = await this.configManager.readConfig();
+      return !config.settings || config.settings.language === null || config.settings.firstRun !== false;
+    } catch (error) {
+      // 配置不存在，视为首次运行
+      return true;
+    }
+  }
+
+  /**
+   * 获取当前语言设置
+   */
+  async getCurrentLanguage(): Promise<'zh' | 'en'> {
+    try {
+      await this.configManager.init();
+      const config = await this.configManager.readConfig();
+      const langSetting = config.settings?.language;
+
+      switch (langSetting) {
+        case 'zh':
+          return 'zh';
+        case 'en':
+          return 'en';
+        case 'auto':
+          return this.shouldUseEnglish() ? 'en' : 'zh';
+        default:
+          // 首次运行或未设置，根据系统环境决定
+          return this.shouldUseEnglish() ? 'en' : 'zh';
+      }
+    } catch (error) {
+      // 配置读取失败，使用自动检测
+      return this.shouldUseEnglish() ? 'en' : 'zh';
+    }
+  }
+
+  /**
+   * 获取当前语言的消息包
+   */
+  async getMessages(): Promise<MessageBundle> {
+    const currentLang = await this.getCurrentLanguage();
+    return currentLang === 'en' ? englishMessages : chineseMessages;
+  }
+
+  /**
+   * 首次运行语言选择向导
+   */
+  async promptLanguageChoice(): Promise<'zh' | 'en' | 'auto'> {
+    console.log('🌍 Welcome to CCM! / 欢迎使用 CCM!\n');
+    console.log('This is your first time running CCM.');
+    console.log('这是您首次运行 CCM。\n');
+
+    const answer = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'language',
+        message: 'Please choose your preferred language:\n请选择您偏好的语言：',
+        choices: [
+          {
+            name: '🇨🇳 中文 (Chinese)',
+            value: 'zh'
+          },
+          {
+            name: '🇺🇸 English',
+            value: 'en'
+          },
+          {
+            name: '🌐 自动检测 (Auto-detect based on system)',
+            value: 'auto'
+          }
+        ]
+      }
+    ]);
+
+    return answer.language;
+  }
+
+  /**
+   * 设置语言
+   */
+  async setLanguage(language: 'zh' | 'en' | 'auto'): Promise<void> {
+    await this.configManager.init();
+    const config = await this.configManager.readConfig();
+    
+    // 更新配置
+    const updatedConfig = {
+      ...config,
+      settings: {
+        ...config.settings,
+        language,
+        firstRun: false
+      }
+    };
+
+    await this.configManager.writeConfig(updatedConfig);
+  }
+
+  /**
+   * 重置语言设置（恢复首次运行状态）
+   */
+  async resetLanguage(): Promise<void> {
+    await this.configManager.init();
+    const config = await this.configManager.readConfig();
+    
+    const updatedConfig = {
+      ...config,
+      settings: {
+        ...config.settings,
+        language: null,
+        firstRun: true
+      }
+    };
+
+    await this.configManager.writeConfig(updatedConfig);
+  }
+
+  /**
+   * 获取语言统计信息
+   */
+  async getLanguageStats(): Promise<LanguageStats> {
+    await this.configManager.init();
+    const config = await this.configManager.readConfig();
+    
+    return {
+      current: config.settings?.language || 'auto',
+      isFirstRun: await this.isFirstRun(),
+      autoDetected: this.shouldUseEnglish() ? 'en' : 'zh'
+    };
+  }
+
+  /**
+   * 处理首次运行流程
+   */
+  async handleFirstRun(): Promise<void> {
+    if (await this.isFirstRun()) {
+      const selectedLang = await this.promptLanguageChoice();
+      await this.setLanguage(selectedLang);
+      
+      // 显示设置成功消息（双语）
+      const messages = await this.getMessages();
+      console.log(`\n✓ ${messages.languageSetSuccess}`);
+      console.log(`✓ ${messages.languageChangeHint}\n`);
+    }
+  }
+}