@kikkimo/claude-launcher 1.0.0 → 2.0.0

package/docs/README-zh.md

@@ -1,6 +1,6 @@
 # Claude Launcher
 
-一个优雅的 Claude Code 交互式启动器，具有美观的 Claude 风格界面。通过直观的命令行菜单使用各种配置启动 Claude Code。
+一个优雅的 Claude Code 交互式启动器，具有美观的 Claude 风格界面和全面的第三方 API 管理功能。通过直观的多语言命令行菜单使用各种配置启动 Claude Code。
 
 ## 📖 文档
 
@@ -9,13 +9,33 @@
 
 ## ✨ 特性
 
-- 🎨 **Claude 风格界面** - 采用正宗的橙色/琥珀色配色方案
-- ⌨️ **方向键导航** - 支持方向键导航，非 TTY 环境下支持数字选择
-- 🔐 **加密 API 密钥存储** - 使用 AES-256-CBC 加密
-- 🚀 **多种启动选项** - 包括跳过权限检查和 Kimi K2 API
-- 🌍 **全局安装** - 在任何地方都可以使用 `claude-launcher`
-- 🔧 **智能配置** - 自动查找/创建配置文件
-- 💻 **跨平台支持** - Windows、macOS 和 Linux
+### 🎨 **精美界面**
+- Claude 风格界面，采用正宗的橙色/琥珀色配色方案
+- 方向键导航，流畅的菜单切换
+- API 选择和管理的交互式表格
+- 多语言支持（8种语言包括中文、英文、德文、法文、日文、韩文、俄文、西班牙文）
+
+### 🔐 **高级安全**
+- 所有敏感数据使用 AES-256-CBC 加密
+- 机器特定的加密密钥增强安全性
+- 密码保护的配置导入/导出
+- 安全的 API 令牌存储，带掩码显示
+- 强密码要求和验证
+
+### 🚀 **第三方 API 管理**
+- 全面支持多个第三方 API 提供商
+- 带验证的交互式 API 配置
+- API 使用统计和跟踪
+- 安全的配置备份和恢复
+- 简单的 API 切换和删除
+
+### 🌍 **企业级功能**
+- 全局安装 - 在任何地方都可以使用 `claude-launcher`
+- 模块化架构，包含 28+ 个专门模块
+- 全面的错误处理和恢复
+- 版本更新检查，自动通知
+- 跨平台支持（Windows、macOS、Linux）
+- 新用户首次设置向导
 
 ## 🚀 快速开始
 
@@ -29,9 +49,12 @@
    claude-launcher
    ```
 
-3. **Kimi API 用户:** 首次使用时，输入以 `sk-` 开头的 Kimi API 密钥
+3. **首次设置:** 启动器将引导您完成：
+   - 语言选择（提供8种语言）
+   - 安全设置（配置导入/导出的密码）
+   - 第三方 API 配置（如果需要）
 
-就这么简单！启动器会引导您完成设置过程。
+就这么简单！直观的界面会引导您了解所有可用选项。
 
 ## 📦 安装
 
@@ -54,19 +77,23 @@ node claude-launcher
 
 ## 🎮 使用方法
 
-### 可用的启动选项
+### 可用的选项
 
 1. **启动 Claude Code** - 标准 Claude Code 启动
 2. **启动 Claude Code（跳过权限）** - 使用 `--dangerously-skip-permissions` 启动
-3. **使用 Kimi K2 API 启动 Claude Code** - 使用加密存储的 Kimi API
-4. **使用 Kimi K2 API 启动 Claude Code（跳过权限）** - 结合 Kimi API 和跳过权限
-5. **退出** - 关闭启动器
+3. **使用第三方 API 启动 Claude Code** - 使用配置的第三方 API
+4. **使用第三方 API 启动 Claude Code（跳过权限）** - 结合第三方 API 和跳过权限
+5. **第三方 API 管理** - 配置、切换、删除 API，查看统计信息
+6. **语言设置** - 在8种支持的语言之间切换
+7. **版本更新检查** - 检查启动器更新
+8. **退出** - 关闭启动器
 
 ### 交互式导航
 
-- **方向键**：使用 ↑↓ 导航，Enter 选择（在 TTY 环境中）
-- **数字选择**：输入 1-5 并按 Enter（在非 TTY 环境中）
-- **快速退出**：随时按 Esc 或 Q 退出
+- **方向键**：使用 ↑↓ 导航，Enter 选择
+- **Escape 键**：按 Esc 返回或退出
+- **多语言**：所有界面文本适应您选择的语言
+- **智能表格**：API 管理的交互式表格，具有清晰的视觉反馈
 
 ### 示例会话
 
@@ -77,48 +104,80 @@ $ claude-launcher
   │           Claude Code Launcher         │
   └────────────────────────────────────────┘
 
-  Use ↑↓ arrow keys to navigate, Enter to select
+  使用 ↑↓ 方向键导航，Enter 选择
 
-  → Launch Claude Code
-    Launch Claude Code (Skip Permissions)
-    Launch Claude Code with Kimi K2 API
-    Launch Claude Code with Kimi K2 API (Skip Permissions)
-    Exit
+  → 启动 Claude Code
+    启动 Claude Code（跳过权限）
+    使用第三方 API 启动 Claude Code
+    使用第三方 API 启动 Claude Code（跳过权限）
+    第三方 API 管理
+    语言设置
+    版本更新检查
+    退出
+```
+
+### 第三方 API 管理
+
+通过专门的菜单访问全面的 API 管理：
+
+```bash
+📋 第三方 API 管理
+
+  → 添加新 API
+    删除 API
+    切换活动 API
+    查看统计信息
+    导出配置
+    导入配置
+    更改密码
+    返回主菜单
 ```
 
 ## ⚙️ 配置
 
-### 自动配置
+### 现代配置系统
 
-首次运行时，如果您选择 Kimi API 选项且没有现有配置，启动器将：
+Claude Launcher 2.0 使用先进的配置系统：
 
-1. 自动在 `~/.claude-launcher.env` 创建配置文件
-2. 引导您输入 Kimi API 密钥
-3. 使用机器特定的加密安全存储您的 API 密钥
+1. **加密 JSON 存储**：配置存储在 `~/.claude-launcher-apis.json`
+2. **交互式设置**：首次设置向导引导您完成所有选项
+3. **多语言支持**：界面适应您的首选语言
+4. **安全第一**：所有敏感数据使用 AES-256-CBC 加密
 
-### 手动配置
+### 首次设置流程
 
-如果您更喜欢手动设置，配置文件搜索顺序如下：
+1. **语言选择**：从8种支持的语言中选择
+2. **安全设置**：
+   - 设置导入/导出的密码保护（推荐）
+   - 或跳过基本使用（功能有限）
+3. **API 配置**：根据需要添加第三方 API
 
-1. 当前目录中的 `.claude-launcher.env`
-2. 用户主目录中的 `.claude-launcher.env`
-3. 安装目录中的 `.claude-launcher.env`
+### 第三方 API 配置
 
-### 配置文件格式
+通过交互界面配置任何第三方 API 提供商：
 
-```env
-KIMI_API_KEY=your_encrypted_api_key_here
-KIMI_BASE_URL=https://api.moonshot.cn/anthropic/
-```
+- **支持的提供商**：OpenAI、Anthropic、自定义 API 等
+- **安全存储**：所有 API 令牌在存储前加密
+- **验证**：URL、令牌和模型的实时验证
+- **使用跟踪**：监控 API 使用统计
+
+### 配置导入/导出
+
+启用密码保护后：
 
-**注意**: `KIMI_API_KEY` 通过启动器输入时会自动加密。请勿手动编辑加密值。
+- **导出**：所有配置的安全备份
+- **导入**：在新机器上恢复配置
+- **密码保护**：所有导出都使用您的密码加密
+- **自动验证**：导入验证确保数据完整性
 
-### 安全功能
+### 增强的安全功能
 
-- **AES-256-CBC 加密**: 使用行业标准加密算法加密 API 密钥
-- **机器特定密钥**: 加密密钥从机器特定数据派生
-- **仅本地存储**: 加密密钥无法在其他机器上解密
-- **安全输入**: API 密钥输入支持复制/粘贴和验证
+- **AES-256-CBC 加密**：所有敏感数据使用行业标准算法加密
+- **机器特定密钥**：从独特机器特征派生的加密密钥
+- **密码保护**：配置导入/导出的可选密码层
+- **安全令牌显示**：所有界面显示中的 API 令牌都经过掩码处理
+- **强密码要求**：强制执行密码复杂性以确保最大安全性
+- **仅本地存储**：所有数据保留在您的机器上，无法在其他地方解密
 
 ## 📋 系统要求
 
@@ -174,4 +233,4 @@ node claude-launcher
 
 ---
 
-**注意**: 此启动器设计用于 Claude Code 和 Kimi K2 API。使用此工具前请确保已安装 Claude Code。
+**注意**: 此启动器设计用于 Claude Code 和各种第三方 API。使用此工具前请确保已安装 Claude Code。使用第三方 API 时，请确保您拥有首选提供商的有效 API 凭据。

package/lib/api-manager.js

@@ -0,0 +1,449 @@
+/**
+ * API Manager Module - Manages third-party API configurations
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { encrypt, decrypt } = require('./crypto');
+const { validateBaseUrl, validateAuthToken, validateModel } = require('./validators');
+
+class ApiManager {
+    constructor() {
+        this.configFile = path.join(os.homedir(), '.claude-launcher-apis.json');
+        this.config = this.loadConfig();
+    }
+
+    /**
+     * Load configuration from encrypted file
+     */
+    loadConfig() {
+        try {
+            if (fs.existsSync(this.configFile)) {
+                const encryptedData = fs.readFileSync(this.configFile, 'utf8');
+                const decrypted = decrypt(encryptedData);
+                if (decrypted.success) {
+                    const config = JSON.parse(decrypted.value);
+                    // Ensure required fields exist
+                    if (!config.hasOwnProperty('exportPassword')) {
+                        config.exportPassword = null;
+                    }
+                    if (!config.hasOwnProperty('passwordSkipped')) {
+                        config.passwordSkipped = false;
+                    }
+
+                    return config;
+                }
+            }
+        } catch (error) {
+            console.error(`[!] Could not load API config: ${error.message}`);
+        }
+
+        return {
+            apis: [],
+            activeIndex: -1,
+            version: '2.0.0',
+            createdAt: new Date().toISOString(),
+            exportPassword: null, // Hashed export password for validation
+            passwordSkipped: false // Whether user permanently skipped password setup
+        };
+    }
+
+    /**
+     * Save configuration to encrypted file
+     */
+    saveConfig() {
+        try {
+            const configJson = JSON.stringify(this.config, null, 2);
+            const encrypted = encrypt(configJson);
+            if (encrypted.success) {
+                fs.writeFileSync(this.configFile, encrypted.value);
+                return true;
+            } else {
+                console.error(`[!] Failed to save API config: ${encrypted.error}`);
+                return false;
+            }
+        } catch (error) {
+            console.error(`[!] Error saving API config: ${error.message}`);
+            return false;
+        }
+    }
+
+    /**
+     * Check for duplicate API configurations - URL + authToken + model must be unique
+     */
+    checkDuplicate(baseUrl, authToken, model) {
+        const existing = this.config.apis.find(api => {
+            const decryptedToken = decrypt(api.authToken);
+            const existingToken = decryptedToken.success ? decryptedToken.value : '';
+            return api.baseUrl === baseUrl &&
+                   existingToken === authToken &&
+                   api.model === model;
+        });
+
+        if (existing) {
+            return {
+                isDuplicate: true,
+                type: 'Complete Configuration (URL + Token + Model)',
+                existing
+            };
+        }
+
+        return { isDuplicate: false };
+    }
+
+    /**
+     * Add a new API configuration
+     */
+    addApi(baseUrl, authToken, model, name, provider = 'custom') {
+        // Validate inputs
+        const urlValidation = validateBaseUrl(baseUrl);
+        if (!urlValidation.valid) {
+            throw new Error(`Invalid Base URL: ${urlValidation.error}`);
+        }
+
+        const tokenValidation = validateAuthToken(authToken);
+        if (!tokenValidation.valid) {
+            throw new Error(`Invalid Auth Token: ${tokenValidation.error}`);
+        }
+
+        const modelValidation = validateModel(model);
+        if (!modelValidation.valid) {
+            throw new Error(`Invalid Model: ${modelValidation.error}`);
+        }
+
+        // Check for duplicates
+        const duplicate = this.checkDuplicate(baseUrl, authToken, model);
+        if (duplicate.isDuplicate) {
+            throw new Error(`${duplicate.type} already exists for API: ${duplicate.existing.name}`);
+        }
+
+        // Encrypt the auth token before storing
+        const encryptedToken = encrypt(tokenValidation.value);
+        if (!encryptedToken.success) {
+            throw new Error(`Failed to encrypt auth token: ${encryptedToken.error}`);
+        }
+
+        const newApi = {
+            id: Date.now().toString(),
+            name: name || `API-${this.config.apis.length + 1}`,
+            provider: provider,
+            baseUrl: urlValidation.value,
+            authToken: encryptedToken.value,
+            model: modelValidation.value,
+            smallFastModel: modelValidation.value, // Same as model as requested
+            createdAt: new Date().toISOString(),
+            lastUsed: null,
+            usageCount: 0
+        };
+
+        this.config.apis.push(newApi);
+
+        // Set as active if it's the first API
+        if (this.config.apis.length === 1) {
+            this.config.activeIndex = 0;
+        }
+
+        this.saveConfig();
+        return newApi;
+    }
+
+    /**
+     * Remove an API configuration
+     */
+    removeApi(index) {
+        if (index < 0 || index >= this.config.apis.length) {
+            throw new Error('Invalid API index');
+        }
+
+        const removedApi = this.config.apis[index];
+        this.config.apis.splice(index, 1);
+
+        // Adjust active index
+        if (this.config.activeIndex >= index) {
+            this.config.activeIndex = this.config.activeIndex > 0 ? this.config.activeIndex - 1 : -1;
+        }
+
+        if (this.config.apis.length === 0) {
+            this.config.activeIndex = -1;
+        }
+
+        this.saveConfig();
+        return removedApi;
+    }
+
+    /**
+     * Get all API configurations
+     */
+    getApis() {
+        return this.config.apis;
+    }
+
+    /**
+     * Set the active API
+     */
+    setActiveApi(index) {
+        if (index < 0 || index >= this.config.apis.length) {
+            throw new Error('Invalid API index');
+        }
+
+        this.config.activeIndex = index;
+        this.saveConfig();
+        return this.config.apis[index];
+    }
+
+    /**
+     * Get the currently active API
+     */
+    getActiveApi() {
+        if (this.config.activeIndex >= 0 && this.config.activeIndex < this.config.apis.length) {
+            return this.config.apis[this.config.activeIndex];
+        }
+        return null;
+    }
+
+    /**
+     * Increment usage count for the active API when actually used
+     */
+    incrementActiveApiUsage() {
+        const activeApi = this.getActiveApi();
+        if (activeApi) {
+            const index = this.config.activeIndex;
+            this.config.apis[index].lastUsed = new Date().toISOString();
+            this.config.apis[index].usageCount = (this.config.apis[index].usageCount || 0) + 1;
+            this.saveConfig();
+            return this.config.apis[index];
+        }
+        return null;
+    }
+
+
+
+    /**
+     * Get statistics about API usage
+     */
+    getStatistics() {
+        const totalApis = this.config.apis.length;
+        const activeApi = this.getActiveApi();
+        const mostUsed = this.config.apis.reduce((prev, current) =>
+            (current.usageCount > (prev?.usageCount || 0)) ? current : prev, null);
+
+        return {
+            totalApis,
+            activeApiName: activeApi?.name || 'None',
+            mostUsedApi: mostUsed?.name || 'None',
+            totalUsage: this.config.apis.reduce((sum, api) => sum + api.usageCount, 0)
+        };
+    }
+
+    /**
+     * Check if this is first time usage (no password set AND no APIs configured)
+     */
+    isFirstTimeUsage() {
+        return this.config.exportPassword === null &&
+               this.config.apis.length === 0 &&
+               !this.config.passwordSkipped;
+    }
+
+    /**
+     * Check if export password is set
+     */
+    hasExportPassword() {
+        return this.config.exportPassword !== null;
+    }
+
+    /**
+     * Check if password was permanently skipped
+     */
+    isPasswordSkipped() {
+        return this.config.passwordSkipped === true;
+    }
+
+    /**
+     * Check if import/export features should be available
+     */
+    canUseImportExport() {
+        return this.hasExportPassword();
+    }
+
+    /**
+     * Set export password (hashed)
+     */
+    setExportPassword(password) {
+        const crypto = require('crypto');
+        this.config.exportPassword = crypto.createHash('sha256').update(password).digest('hex');
+        this.saveConfig();
+    }
+
+    /**
+     * Permanently skip password setup (one-time only, can't be undone)
+     */
+    skipPasswordSetup() {
+        if (!this.isFirstTimeUsage()) {
+            throw new Error('Password setup can only be skipped during first time usage');
+        }
+        this.config.passwordSkipped = true;
+        this.saveConfig();
+    }
+
+    /**
+     * Verify export password
+     */
+    verifyExportPassword(password) {
+        if (!this.hasExportPassword()) {
+            return false;
+        }
+        const crypto = require('crypto');
+        const hashedInput = crypto.createHash('sha256').update(password).digest('hex');
+        return hashedInput === this.config.exportPassword;
+    }
+
+    /**
+     * Remove export password
+     */
+    removeExportPassword() {
+        this.config.exportPassword = null;
+        this.saveConfig();
+    }
+
+    /**
+     * Export configuration as plaintext JSON (password verification required)
+     */
+    exportConfig(password) {
+        // Verify password before export
+        if (!this.verifyExportPassword(password)) {
+            throw new Error('Invalid password for export operation');
+        }
+
+        return this.exportConfigAuthenticated();
+    }
+
+    /**
+     * Export configuration as plaintext JSON (already authenticated)
+     */
+    exportConfigAuthenticated() {
+        // Create export data with plaintext API keys
+        const exportData = {
+            version: this.config.version,
+            exportedAt: new Date().toISOString(),
+            apis: this.config.apis.map(api => {
+                const decrypted = decrypt(api.authToken);
+                return {
+                    ...api,
+                    authToken: decrypted.success ? decrypted.value : '***DECRYPTION_FAILED***'
+                };
+            }),
+            activeIndex: this.config.activeIndex
+        };
+
+        return JSON.stringify(exportData, null, 2);
+    }
+
+    /**
+     * Import configuration from plaintext JSON (password verification required)
+     */
+    importConfig(plaintextData, password) {
+        // Verify password before import
+        if (!this.verifyExportPassword(password)) {
+            throw new Error('Invalid password for import operation');
+        }
+
+        return this.importConfigAuthenticated(plaintextData);
+    }
+
+    /**
+     * Import configuration from plaintext JSON (already authenticated)
+     */
+    importConfigAuthenticated(plaintextData) {
+        const configData = JSON.parse(plaintextData);
+        return this.processImportData(configData);
+    }
+
+
+    /**
+     * Process import data (merge with existing)
+     */
+    processImportData(configData) {
+        let imported = 0;
+        let skipped = 0;
+
+        if (!configData.apis || !Array.isArray(configData.apis)) {
+            throw new Error('Invalid configuration format - no APIs found');
+        }
+
+        configData.apis.forEach(importApi => {
+            // Validate the API configuration before importing
+            try {
+                // Validate Base URL
+                const urlValidation = validateBaseUrl(importApi.baseUrl);
+                if (!urlValidation.valid) {
+                    console.warn(`Skipping API "${importApi.name || 'Unknown'}" - Invalid Base URL: ${urlValidation.error}`);
+                    skipped++;
+                    return;
+                }
+
+                // Validate Auth Token (skip validation for placeholder tokens)
+                if (importApi.authToken !== '***REQUIRES_MANUAL_INPUT***') {
+                    const tokenValidation = validateAuthToken(importApi.authToken);
+                    if (!tokenValidation.valid) {
+                        console.warn(`Skipping API "${importApi.name || 'Unknown'}" - Invalid Auth Token: ${tokenValidation.error}`);
+                        skipped++;
+                        return;
+                    }
+                }
+
+                // Validate Model
+                const modelValidation = validateModel(importApi.model);
+                if (!modelValidation.valid) {
+                    console.warn(`Skipping API "${importApi.name || 'Unknown'}" - Invalid Model: ${modelValidation.error}`);
+                    skipped++;
+                    return;
+                }
+
+                // Check for duplicates using the same logic as addApi
+                const importToken = importApi.authToken === '***REQUIRES_MANUAL_INPUT***' ? '' : importApi.authToken;
+                const duplicate = this.checkDuplicate(importApi.baseUrl, importToken, importApi.model);
+
+                if (duplicate.isDuplicate) {
+                    skipped++;
+                } else {
+                    // Encrypt the auth token if it's not already encrypted or masked
+                    let encryptedToken;
+                    if (importApi.authToken === '***REQUIRES_MANUAL_INPUT***') {
+                        encryptedToken = encrypt('').value; // Empty encrypted token
+                    } else {
+                        encryptedToken = encrypt(importApi.authToken).value;
+                    }
+
+                    const newApi = {
+                        id: Date.now() + Math.random(),
+                        name: importApi.name || `Imported API ${this.config.apis.length + 1}`,
+                        baseUrl: urlValidation.value,
+                        authToken: encryptedToken,
+                        model: modelValidation.value,
+                        provider: importApi.provider || 'custom',
+                        createdAt: new Date().toISOString(),
+                        lastUsed: null,
+                        usageCount: 0
+                    };
+
+                    this.config.apis.push(newApi);
+                    imported++;
+
+                    // Set as active if this is the first API
+                    if (this.config.apis.length === 1) {
+                        this.config.activeIndex = 0;
+                    }
+                }
+            } catch (error) {
+                console.warn(`Skipping API "${importApi.name || 'Unknown'}" - Validation error: ${error.message}`);
+                skipped++;
+            }
+        });
+
+        this.saveConfig();
+        return { imported, skipped };
+    }
+}
+
+module.exports = ApiManager;