@kikkimo/claude-launcher 2.4.0 → 3.0.0

package/docs/README-zh.md

@@ -13,24 +13,29 @@
 
 ### 🎨 **精美界面**
 - Claude 风格界面，采用正宗的橙色/琥珀色配色方案
+- ANSI 备用屏幕缓冲区，无漂移渲染（类似 vim/htop）
 - 方向键导航，流畅的菜单切换
+- 分页 API 表格，支持 ←→ 翻页浏览大量 API
 - API 选择和管理的交互式表格
 - 多语言支持（简体中文、繁体中文、英文、德文、法文、西班牙文、意大利文、葡萄牙文、日文、韩文、俄文）
 
 ### 🔐 **高级安全**
 - 所有敏感数据使用 AES-256-CBC 加密
 - 机器特定的加密密钥增强安全性
+- 统一密码守卫保护高风险操作（编辑、删除、导入、导出）
 - 密码保护的配置导入/导出
 - 安全的 API 令牌存储，带掩码显示
 - 强密码要求和验证
 
 ### 🚀 **第三方 API 管理**
-- 全面支持多个第三方 API 提供商（Anthropic、OpenAI、DeepSeek、Moonshot/Kimi、MiniMax、GLM/智谱AI 和自定义 API）
+- 全面支持多个第三方 API 提供商（Anthropic、DeepSeek、Kimi K2.5、MiniMax M2.7、GLM-5.1/智谱AI 和自定义 API）
 - 带验证的交互式 API 配置
+- **编辑 API**：修改已有 API 的名称、供应商、Base URL 和模型
 - API 使用统计，支持成功/失败率追踪
 - 模型升级通知和自动升级支持
 - 安全的配置备份和恢复
 - 简单的 API 切换、删除和批量清空
+- 每个配置最多支持 99 个 API
 
 ### 🌍 **企业级功能**
 - 全局安装 - 在任何地方都可以使用 `claude-launcher`
@@ -84,23 +89,25 @@ node claude-launcher
 
 1. **启动 Claude Code** - 标准 Claude Code 启动
 2. **启动 Claude Code（跳过权限）** - 使用 `--dangerously-skip-permissions` 启动
-3. **使用第三方 API 启动 Claude Code** - 使用配置的第三方 API
-4. **使用第三方 API 启动 Claude Code（跳过权限）** - 结合第三方 API 和跳过权限
-5. **第三方 API 管理** - 完整的 API 生命周期管理：
-   - 添加、切换和删除 API
+3. **启动 Claude Code（启用自动模式）** - 使用 `--enable-auto-mode` 启动，支持分类器自动审批（Team 计划；启动后按 Shift+Tab 切换）
+4. **使用第三方 API 启动 Claude Code** - 使用配置的第三方 API
+5. **使用第三方 API 启动 Claude Code（跳过权限）** - 结合第三方 API 和跳过权限
+6. **第三方 API 管理** - 完整的 API 生命周期管理：
+   - 添加、编辑、切换和删除 API
    - 查看使用统计（含成功/失败率）
    - 模型升级设置（自动/手动升级）
-   - 导入/导出配置
-6. **语言设置** - 在11种支持的语言之间切换
-7. **版本更新检查** - 检查启动器更新
-8. **退出** - 关闭启动器
+   - 导入/导出配置（密码保护）
+7. **配置管理** - 语言、遥测、启动模式、模型升级设置
+8. **版本更新检查** - 检查启动器更新
+9. **退出** - 关闭启动器
 
 ### 交互式导航
 
-- **方向键**：使用 ↑↓ 导航，Enter 选择
-- **Escape 键**：按 Esc 返回或退出
+- **方向键**：使用 ↑↓ 导航，←→ 翻页（分页表格中），Enter 选择
+- **Escape 键**：按 Esc 返回或取消
+- **Ctrl+C**：第一次按下显示警告，第二次按下干净退出
 - **多语言**：所有界面文本适应您选择的语言
-- **智能表格**：API 管理的交互式表格，具有清晰的视觉反馈
+- **智能表格**：分页交互式表格，支持每页选择记忆
 
 ### 示例会话
 
@@ -115,10 +122,11 @@ $ claude-launcher
 
   → 启动 Claude Code
     启动 Claude Code（跳过权限）
+    启动 Claude Code（启用自动模式）
     使用第三方 API 启动 Claude Code
     使用第三方 API 启动 Claude Code（跳过权限）
     第三方 API 管理
-    语言设置
+    配置管理
     版本更新检查
     退出
 ```
@@ -131,12 +139,13 @@ $ claude-launcher
 📋 第三方 API 管理
 
   → 添加新 API
+    编辑 API            → 选择 API → 编辑名称/供应商/URL/模型
     删除 API            → 删除单个 API / 清空所有 API
     切换活动 API
     查看统计信息        → 查看详情 / 重置统计
     模型升级设置        → 自动升级 [开/关] / 手动升级
-    导出配置
-    导入配置
+    导出配置              🔒（需要密码）
+    导入配置              🔒（需要密码）
     更改密码
     返回主菜单
 ```
@@ -152,7 +161,7 @@ $ claude-launcher
 
 ### 现代配置系统
 
-Claude Launcher 2.0 使用先进的配置系统：
+Claude Launcher 使用先进的配置系统：
 
 1. **加密 JSON 存储**：配置存储在 `~/.claude-launcher-apis.json`
 2. **交互式设置**：首次设置向导引导您完成所有选项
@@ -171,7 +180,7 @@ Claude Launcher 2.0 使用先进的配置系统：
 
 通过交互界面配置任何第三方 API 提供商：
 
-- **支持的提供商**：Anthropic、OpenAI、DeepSeek、Moonshot/Kimi、MiniMax（国内版/国际版）、GLM/智谱AI（GLM-4、GLM-5）和自定义 Anthropic 兼容 API
+- **支持的提供商**：Anthropic、DeepSeek、Moonshot/Kimi（K2.5）、MiniMax（国内版/国际版，M2.7）、GLM/智谱AI（GLM-5.1）和自定义 Anthropic 兼容 API
 - **安全存储**：所有 API 令牌在存储前加密
 - **验证**：URL、令牌和模型的实时验证
 - **使用跟踪**：监控 API 使用统计，支持成功/失败率追踪
@@ -212,6 +221,12 @@ cd claude-launcher
 npm install
 ```
 
+### 运行测试
+
+```bash
+npm test
+```
+
 ### 本地测试
 
 ```bash

package/lib/api-manager.js

@@ -6,7 +6,8 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { encrypt, decrypt } = require('./crypto');
-const { validateBaseUrl, validateAuthToken, validateModel } = require('./validators');
+const { validateBaseUrl, validateAuthToken, validateModel, validateApiName } = require('./validators');
+const screen = require('./ui/screen');
 
 class ApiManager {
     constructor() {
@@ -36,7 +37,7 @@ class ApiManager {
                 }
             }
         } catch (error) {
-            console.error(`[!] Could not load API config: ${error.message}`);
+            screen.debug(`[!] Could not load API config: ${error.message}`);
         }
 
         return {
@@ -60,11 +61,11 @@ class ApiManager {
                 fs.writeFileSync(this.configFile, encrypted.value);
                 return true;
             } else {
-                console.error(`[!] Failed to save API config: ${encrypted.error}`);
+                screen.debug(`[!] Failed to save API config: ${encrypted.error}`);
                 return false;
             }
         } catch (error) {
-            console.error(`[!] Error saving API config: ${error.message}`);
+            screen.debug(`[!] Error saving API config: ${error.message}`);
             return false;
         }
     }
@@ -96,6 +97,10 @@ class ApiManager {
      * Add a new API configuration
      */
     addApi(baseUrl, authToken, model, name, provider = 'custom') {
+        if (this.config.apis.length >= 99) {
+            throw new Error('Maximum 99 APIs supported. Remove unused APIs before adding new ones.');
+        }
+
         // Validate inputs
         const urlValidation = validateBaseUrl(baseUrl);
         if (!urlValidation.valid) {
@@ -241,15 +246,95 @@ class ApiManager {
      * @returns {Object} The updated API object
      */
     updateApiModel(apiId, newModel) {
+        return this.updateApiField(apiId, 'model', newModel);
+    }
+
+    /**
+     * Update a single field of an API configuration with validation
+     * @param {string} apiId - The API id
+     * @param {string} field - Field name: 'name', 'provider', 'baseUrl', 'model'
+     * @param {string} value - New value
+     * @returns {Object} The updated API object
+     */
+    updateApiField(apiId, field, value) {
+        const allowedFields = ['name', 'provider', 'baseUrl', 'model'];
+        if (!allowedFields.includes(field)) {
+            throw new Error(`Field '${field}' is not allowed. Allowed: ${allowedFields.join(', ')}`);
+        }
+
         const index = this.config.apis.findIndex(api => api.id === apiId);
         if (index === -1) {
             throw new Error(`API not found: ${apiId}`);
         }
 
-        this.config.apis[index].model = newModel;
-        this.config.apis[index].smallFastModel = newModel;
+        const api = this.config.apis[index];
+
+        // Manager-level validation
+        switch (field) {
+            case 'name': {
+                if (!value || value.trim() === '') {
+                    throw new Error('Name cannot be empty when editing');
+                }
+                const nameValidation = validateApiName(value);
+                if (!nameValidation.valid) {
+                    throw new Error(`Invalid name: ${nameValidation.error}`);
+                }
+                break;
+            }
+            case 'provider': {
+                const { getAllProviders } = require('./presets/providers');
+                const validIds = getAllProviders().map(p => p.id);
+                if (!validIds.includes(value)) {
+                    throw new Error(`Unknown provider: ${value}. Valid: ${validIds.join(', ')}`);
+                }
+                break;
+            }
+            case 'baseUrl': {
+                const urlValidation = validateBaseUrl(value);
+                if (!urlValidation.valid) {
+                    throw new Error(`Invalid URL: ${urlValidation.error}`);
+                }
+                break;
+            }
+            case 'model': {
+                const modelValidation = validateModel(value);
+                if (!modelValidation.valid) {
+                    throw new Error(`Invalid model: ${modelValidation.error}`);
+                }
+                break;
+            }
+        }
+
+        // Duplicate check for uniqueness-affecting fields
+        if (field === 'baseUrl' || field === 'model') {
+            const checkUrl = field === 'baseUrl' ? value : api.baseUrl;
+            const checkModel = field === 'model' ? value : api.model;
+            const decryptedToken = decrypt(api.authToken);
+            const tokenValue = decryptedToken.success ? decryptedToken.value : '';
+
+            // Check against all OTHER apis (exclude self)
+            const duplicate = this.config.apis.find((other, idx) => {
+                if (idx === index) return false;
+                const otherToken = decrypt(other.authToken);
+                const otherTokenValue = otherToken.success ? otherToken.value : '';
+                return other.baseUrl === checkUrl &&
+                       otherTokenValue === tokenValue &&
+                       other.model === checkModel;
+            });
+
+            if (duplicate) {
+                throw new Error(`Duplicate configuration: URL + Token + Model already exists for API '${duplicate.name}'`);
+            }
+        }
+
+        // Apply update
+        api[field] = value.trim();
+        if (field === 'model') {
+            api.smallFastModel = value.trim();
+        }
+
         this.saveConfig();
-        return this.config.apis[index];
+        return api;
     }
 
     /**
@@ -289,6 +374,40 @@ class ApiManager {
         return null;
     }
 
+    /**
+     * Record a launch attempt (optimistic success)
+     * Call rollbackLaunchAttempt() if a pre-launch sync error occurs
+     * @returns {Object|null} The updated API object or null
+     */
+    recordLaunchAttempt() {
+        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.config.apis[index].successCount = (this.config.apis[index].successCount || 0) + 1;
+            this.config.apis[index].lastError = null;
+            this.saveConfig();
+            return this.config.apis[index];
+        }
+        return null;
+    }
+
+    /**
+     * Rollback an optimistic launch attempt on pre-launch sync error
+     * @param {string} errorMessage - The error message
+     */
+    rollbackLaunchAttempt(errorMessage) {
+        const activeApi = this.getActiveApi();
+        if (activeApi) {
+            const index = this.config.activeIndex;
+            this.config.apis[index].successCount = Math.max(0, (this.config.apis[index].successCount || 0) - 1);
+            this.config.apis[index].failCount = (this.config.apis[index].failCount || 0) + 1;
+            this.config.apis[index].lastError = errorMessage;
+            this.saveConfig();
+        }
+    }
+
     /**
      * Get statistics about API usage
      */
@@ -506,12 +625,18 @@ class ApiManager {
         }
 
         configData.apis.forEach(importApi => {
+            if (this.config.apis.length >= 99) {
+                screen.debug('Import skipped: maximum 99 APIs reached');
+                skipped++;
+                return;
+            }
+
             // 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}`);
+                    screen.debug(`Skipping API "${importApi.name || 'Unknown'}" - Invalid Base URL: ${urlValidation.error}`);
                     skipped++;
                     return;
                 }
@@ -520,7 +645,7 @@ class ApiManager {
                 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}`);
+                        screen.debug(`Skipping API "${importApi.name || 'Unknown'}" - Invalid Auth Token: ${tokenValidation.error}`);
                         skipped++;
                         return;
                     }
@@ -529,7 +654,7 @@ class ApiManager {
                 // Validate Model
                 const modelValidation = validateModel(importApi.model);
                 if (!modelValidation.valid) {
-                    console.warn(`Skipping API "${importApi.name || 'Unknown'}" - Invalid Model: ${modelValidation.error}`);
+                    screen.debug(`Skipping API "${importApi.name || 'Unknown'}" - Invalid Model: ${modelValidation.error}`);
                     skipped++;
                     return;
                 }
@@ -570,7 +695,7 @@ class ApiManager {
                     }
                 }
             } catch (error) {
-                console.warn(`Skipping API "${importApi.name || 'Unknown'}" - Validation error: ${error.message}`);
+                screen.debug(`Skipping API "${importApi.name || 'Unknown'}" - Validation error: ${error.message}`);
                 skipped++;
             }
         });

package/lib/auth/password-input.js

@@ -5,6 +5,7 @@
 
 const readline = require('readline');
 const stdinManager = require('../utils/stdin-manager');
+const screen = require('../ui/screen');
 
 /**
  * Get password input with proper masking (no plaintext display)
@@ -18,7 +19,7 @@ function getPasswordInput(prompt) {
         let cleanedUp = false;
 
         // Display prompt - this is necessary for password input
-        process.stdout.write(prompt);
+        screen.write(prompt);
 
         if (!process.stdin.isTTY) {
             // Non-TTY environment fallback - use scope's createReadline
@@ -52,11 +53,14 @@ function getPasswordInput(prompt) {
             return;
         }
 
+        screen.showCursor();
+
         const cleanup = () => {
             if (cleanedUp) return;
             cleanedUp = true;
 
             try {
+                screen.hideCursor();
                 scope.removeAllListeners('data');
                 scope.release();
             } catch (error) {
@@ -85,7 +89,7 @@ function getPasswordInput(prompt) {
                 case '\r': // Enter (CR)
                 case '\n': // Line Feed (LF)
                 case '\r\n': // CRLF
-                    process.stdout.write('\n');
+                    screen.write('\n');
                     cleanup();
                     resolve(password);
                     return;
@@ -95,7 +99,7 @@ function getPasswordInput(prompt) {
                     if (password.length > 0) {
                         password = password.slice(0, -1);
                         // Clear the last asterisk
-                        process.stdout.write('\b \b');
+                        screen.write('\b \b');
                     }
                     return;
 
@@ -114,7 +118,7 @@ function getPasswordInput(prompt) {
                         // Filter out control characters (only accept ASCII printable)
                         if (charCode >= 32 && charCode < 127) {
                             password += char;
-                            process.stdout.write('*');
+                            screen.write('*');
                         }
                     }
                     return;