@pikecode/api-key-manager 1.0.32 → 1.0.34

package/src/config.js

@@ -12,6 +12,17 @@ class ConfigManager {
     this.loadPromise = null; // 防止并发加载
   }
 
+  _normalizeOptionalString(value) {
+    if (value === null || value === undefined) {
+      return null;
+    }
+    if (typeof value !== 'string') {
+      return value;
+    }
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? null : trimmed;
+  }
+
   getDefaultConfig() {
     return {
       version: '1.0.0',
@@ -78,6 +89,8 @@ class ConfigManager {
 
         // 迁移旧的认证模式
         this._migrateAuthModes();
+        // 修复 current 标记与 currentProvider 不一致的问题（兼容旧版本写入的脏数据）
+        this._syncCurrentFlags();
 
         const stat = await fs.stat(this.configPath);
         this.lastModified = stat.mtime;
@@ -195,30 +208,78 @@ class ConfigManager {
     }
   }
 
+  _syncCurrentFlags() {
+    if (!this.config || !this.config.providers) {
+      return;
+    }
+
+    const current = this.config.currentProvider;
+    const providers = this.config.providers;
+    const keys = Object.keys(providers);
+
+    if (current && providers[current]) {
+      keys.forEach((key) => {
+        providers[key].current = key === current;
+      });
+      return;
+    }
+
+    keys.forEach((key) => {
+      providers[key].current = false;
+    });
+  }
+
   async addProvider(name, providerConfig) {
     await this.ensureLoaded();
 
-    const isCodex = providerConfig.ideName === 'codex';
+    const existing = this.config.providers[name];
+    const now = new Date().toISOString();
+
+    const ideName = providerConfig.ideName || existing?.ideName || 'claude';
+    const isCodex = ideName === 'codex';
+
+    const baseUrl = this._normalizeOptionalString(
+      providerConfig.baseUrl !== undefined ? providerConfig.baseUrl : existing?.baseUrl
+    );
 
+    const authToken = providerConfig.authToken !== undefined ? providerConfig.authToken : existing?.authToken;
+
+    const launchArgs = Array.isArray(providerConfig.launchArgs)
+      ? providerConfig.launchArgs
+      : (existing?.launchArgs || []);
+
+    // 基础字段
     this.config.providers[name] = {
       name,
-      displayName: providerConfig.displayName || name,
-      ideName: providerConfig.ideName || 'claude',
-      baseUrl: providerConfig.baseUrl,
-      authToken: providerConfig.authToken,
-      launchArgs: providerConfig.launchArgs || [],
-      createdAt: new Date().toISOString(),
-      lastUsed: new Date().toISOString(),
-      current: false
+      displayName: providerConfig.displayName || existing?.displayName || name,
+      ideName,
+      baseUrl,
+      authToken,
+      launchArgs,
+      createdAt: existing?.createdAt || now,
+      lastUsed: existing?.lastUsed || now,
+      usageCount: existing?.usageCount || 0,
+      current: Boolean(existing?.current || this.config.currentProvider === name)
     };
 
     // Claude Code 特定字段
     if (!isCodex) {
-      this.config.providers[name].authMode = providerConfig.authMode || 'api_key';
-      this.config.providers[name].tokenType = providerConfig.tokenType || 'api_key';
+      const authMode = providerConfig.authMode || existing?.authMode || 'api_key';
+      const tokenType = authMode === 'api_key'
+        ? (providerConfig.tokenType ?? existing?.tokenType ?? 'api_key')
+        : null;
+      const primaryModel = providerConfig.primaryModel !== undefined
+        ? providerConfig.primaryModel
+        : (existing?.models?.primary ?? null);
+      const smallFastModel = providerConfig.smallFastModel !== undefined
+        ? providerConfig.smallFastModel
+        : (existing?.models?.smallFast ?? null);
+
+      this.config.providers[name].authMode = authMode;
+      this.config.providers[name].tokenType = tokenType;
       this.config.providers[name].models = {
-        primary: providerConfig.primaryModel || null,
-        smallFast: providerConfig.smallFastModel || null
+        primary: primaryModel,
+        smallFast: smallFastModel
       };
     } else {
       // Codex 不需要这些字段，设置为 null 以保持向后兼容
@@ -228,18 +289,15 @@ class ConfigManager {
     }
 
     // 如果是第一个供应商或设置为默认，则设为当前供应商
-    if (Object.keys(this.config.providers).length === 1 || providerConfig.setAsDefault) {
-      // 重置所有供应商的current状态
-      Object.keys(this.config.providers).forEach(key => {
-        this.config.providers[key].current = false;
-      });
-      
-      // 设置新的当前供应商
-      this.config.providers[name].current = true;
-      this.config.providers[name].lastUsed = new Date().toISOString();
+    const shouldSetCurrent = (!existing && Object.keys(this.config.providers).length === 1) || providerConfig.setAsDefault;
+    if (shouldSetCurrent) {
       this.config.currentProvider = name;
+      this.config.providers[name].lastUsed = now;
     }
 
+    // 保证 current 标记与 currentProvider 一致，避免出现多个 current 或丢失 current 的情况
+    this._syncCurrentFlags();
+
     return await this.save();
   }
 
@@ -317,4 +375,7 @@ class ConfigManager {
   }
 }
 
-module.exports = { ConfigManager };
+// 单例实例
+const configManager = new ConfigManager();
+
+module.exports = { ConfigManager, configManager };

package/src/utils/codex-launcher.js

@@ -1,46 +1,5 @@
 const spawn = require('cross-spawn');
-
-/**
- * 清理环境变量值，移除危险字符
- * @param {string} value - 要清理的值
- * @returns {string} 清理后的值
- */
-function sanitizeEnvValue(value) {
-  if (typeof value !== 'string') {
-    throw new Error('环境变量值必须是字符串');
-  }
-
-  // 移除控制字符
-  let cleaned = value.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
-
-  // 检测可能的 shell 命令注入
-  if (/[;&|`$()]/.test(cleaned)) {
-    throw new Error('环境变量值包含潜在不安全的字符');
-  }
-
-  return cleaned;
-}
-
-function clearTerminal() {
-  if (!process.stdout || typeof process.stdout.write !== 'function') {
-    return;
-  }
-
-  try {
-    process.stdout.write('\x1bc');
-  } catch (error) {
-    // 某些终端可能不支持 RIS 序列，忽略即可
-  }
-
-  const sequence = process.platform === 'win32'
-    ? '\x1b[3J\x1b[2J\x1b[0f'
-    : '\x1b[3J\x1b[2J\x1b[H';
-  try {
-    process.stdout.write(sequence);
-  } catch (error) {
-    // 忽略清屏失败
-  }
-}
+const { sanitizeEnvValue, clearTerminal } = require('./env-utils');
 
 /**
  * 构建 Codex CLI 环境变量

package/src/utils/env-launcher.js

@@ -1,46 +1,5 @@
 const spawn = require('cross-spawn');
-
-/**
- * 清理环境变量值，移除危险字符
- * @param {string} value - 要清理的值
- * @returns {string} 清理后的值
- */
-function sanitizeEnvValue(value) {
-  if (typeof value !== 'string') {
-    throw new Error('环境变量值必须是字符串');
-  }
-
-  // 移除控制字符
-  let cleaned = value.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
-
-  // 检测可能的 shell 命令注入
-  if (/[;&|`$()]/.test(cleaned)) {
-    throw new Error('环境变量值包含潜在不安全的字符');
-  }
-
-  return cleaned;
-}
-
-function clearTerminal() {
-  if (!process.stdout || typeof process.stdout.write !== 'function') {
-    return;
-  }
-
-  try {
-    process.stdout.write('\x1bc');
-  } catch (error) {
-    // 某些终端可能不支持 RIS 序列，忽略即可
-  }
-
-  const sequence = process.platform === 'win32'
-    ? '\x1b[3J\x1b[2J\x1b[0f'
-    : '\x1b[3J\x1b[2J\x1b[H';
-  try {
-    process.stdout.write(sequence);
-  } catch (error) {
-    // 忽略清屏失败
-  }
-}
+const { sanitizeEnvValue, clearTerminal } = require('./env-utils');
 
 function buildEnvVariables(config) {
   const env = { ...process.env };
@@ -50,6 +9,9 @@ function buildEnvVariables(config) {
     if (config.authMode === 'oauth_token') {
       env.CLAUDE_CODE_OAUTH_TOKEN = sanitizeEnvValue(config.authToken);
     } else if (config.authMode === 'api_key') {
+      if (!config.baseUrl) {
+        throw new Error('未配置基础地址');
+      }
       env.ANTHROPIC_BASE_URL = sanitizeEnvValue(config.baseUrl);
       // 根据 tokenType 选择设置哪种 token
       if (config.tokenType === 'auth_token') {
@@ -60,7 +22,9 @@ function buildEnvVariables(config) {
       }
     } else {
       // auth_token 模式
-      env.ANTHROPIC_BASE_URL = sanitizeEnvValue(config.baseUrl);
+      if (config.baseUrl) {
+        env.ANTHROPIC_BASE_URL = sanitizeEnvValue(config.baseUrl);
+      }
       env.ANTHROPIC_AUTH_TOKEN = sanitizeEnvValue(config.authToken);
     }
 

package/src/utils/env-utils.js

@@ -0,0 +1,52 @@
+/**
+ * 环境变量工具函数
+ * 提供 env-launcher.js 和 codex-launcher.js 共用的功能
+ */
+
+/**
+ * 清理环境变量值，移除危险字符
+ * @param {string} value - 要清理的值
+ * @returns {string} 清理后的值
+ */
+function sanitizeEnvValue(value) {
+  if (typeof value !== 'string') {
+    throw new Error('环境变量值必须是字符串');
+  }
+
+  // 移除控制字符
+  let cleaned = value.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
+
+  // 检测可能的 shell 命令注入（允许 $ 因为 token 可能包含）
+  // 只禁止明确的命令分隔符和反引号执行
+  if (/[;&|`]/.test(cleaned)) {
+    throw new Error('环境变量值包含潜在不安全的字符');
+  }
+
+  return cleaned;
+}
+
+/**
+ * 清屏函数
+ */
+function clearTerminal() {
+  if (!process.stdout || typeof process.stdout.write !== 'function') {
+    return;
+  }
+
+  try {
+    process.stdout.write('\x1bc');
+  } catch (error) {
+    // 某些终端可能不支持 RIS 序列，忽略即可
+  }
+
+  const sequence = process.platform === 'win32'
+    ? '\x1b[3J\x1b[2J\x1b[0f'
+    : '\x1b[3J\x1b[2J\x1b[H';
+  try {
+    process.stdout.write(sequence);
+  } catch (error) {
+    // 忽略清屏失败
+  }
+}
+
+module.exports = { sanitizeEnvValue, clearTerminal };

package/src/utils/error-handler.js

@@ -1,5 +1,5 @@
 const chalk = require('chalk');
-const { Logger } = require('./utils/logger');
+const { Logger } = require('./logger');
 
 class ErrorHandler {
   static handle(error, context = '') {

package/src/utils/launch-args.js

@@ -0,0 +1,96 @@
+/**
+ * 启动参数定义模块
+ * 统一管理 Claude Code 和 Codex CLI 的启动参数
+ */
+
+const claudeLaunchArgs = [
+  {
+    name: '--continue',
+    label: '继续上次对话',
+    description: '恢复上次的对话记录',
+    checked: false
+  },
+  {
+    name: '--dangerously-skip-permissions',
+    label: '最高权限',
+    description: '仅在沙盒环境中使用',
+    checked: false
+  }
+];
+
+const codexLaunchArgs = [
+  {
+    name: 'resume',
+    label: '继续上次对话',
+    description: '恢复之前的会话',
+    checked: false,
+    isSubcommand: true
+  },
+  {
+    name: '--full-auto',
+    label: '全自动模式',
+    description: '自动批准 + 工作区写入沙盒',
+    checked: false,
+    exclusive: ['--dangerously-bypass-approvals-and-sandbox']
+  },
+  {
+    name: '--dangerously-bypass-approvals-and-sandbox',
+    label: '跳过审批和沙盒',
+    description: '危险：跳过所有安全检查',
+    checked: false,
+    exclusive: ['--full-auto']
+  },
+  {
+    name: '--search',
+    label: '启用网页搜索',
+    description: '允许模型搜索网页',
+    checked: false
+  }
+];
+
+function getClaudeLaunchArgs() {
+  return claudeLaunchArgs.map(arg => ({ ...arg }));
+}
+
+function getCodexLaunchArgs() {
+  return codexLaunchArgs.map(arg => ({ ...arg }));
+}
+
+function getLaunchArgs(ideName) {
+  return ideName === 'codex' ? getCodexLaunchArgs() : getClaudeLaunchArgs();
+}
+
+/**
+ * 检查互斥参数
+ * @param {string[]} selectedArgs - 选中的参数列表
+ * @param {Array} availableArgs - 可用参数定义
+ * @returns {string|null} 冲突错误信息或 null
+ */
+function checkExclusiveArgs(selectedArgs, availableArgs) {
+  if (!selectedArgs || selectedArgs.length < 2) {
+    return null;
+  }
+
+  for (const argDef of availableArgs) {
+    if (!argDef.exclusive || !selectedArgs.includes(argDef.name)) {
+      continue;
+    }
+
+    for (const exclusiveArg of argDef.exclusive) {
+      if (selectedArgs.includes(exclusiveArg)) {
+        const arg1 = availableArgs.find(a => a.name === argDef.name);
+        const arg2 = availableArgs.find(a => a.name === exclusiveArg);
+        return `"${arg1?.label || argDef.name}" 和 "${arg2?.label || exclusiveArg}" 不能同时选择`;
+      }
+    }
+  }
+
+  return null;
+}
+
+module.exports = {
+  getClaudeLaunchArgs,
+  getCodexLaunchArgs,
+  getLaunchArgs,
+  checkExclusiveArgs
+};

package/src/utils/provider-status-checker.js

@@ -1,28 +1,94 @@
 const { Anthropic, APIConnectionTimeoutError, APIConnectionError, APIError } = require('@anthropic-ai/sdk');
 
+let authTokenEnvLock = Promise.resolve();
+
+// 状态缓存
+const statusCache = new Map();
+const DEFAULT_CACHE_TTL = 30000; // 30秒缓存
+
 class ProviderStatusChecker {
   constructor(options = {}) {
     this.timeout = options.timeout ?? 5000;
     this.testMessage = options.testMessage ?? '你好';
     this.maxTokens = options.maxTokens ?? 32;
     this.defaultModel = 'claude-haiku-4-5-20251001';
+    this.cacheTTL = options.cacheTTL ?? DEFAULT_CACHE_TTL;
+  }
+
+  _getCacheKey(provider) {
+    // 基于关键配置生成缓存键
+    return `${provider.name}:${provider.authToken}:${provider.baseUrl}:${provider.authMode}`;
+  }
+
+  _getCachedStatus(provider) {
+    const key = this._getCacheKey(provider);
+    const cached = statusCache.get(key);
+    if (cached && Date.now() - cached.timestamp < this.cacheTTL) {
+      return cached.status;
+    }
+    return null;
+  }
+
+  _setCachedStatus(provider, status) {
+    const key = this._getCacheKey(provider);
+    statusCache.set(key, {
+      status,
+      timestamp: Date.now()
+    });
+  }
+
+  clearCache() {
+    statusCache.clear();
+  }
+
+  async _withAuthTokenEnv(authToken, operation) {
+    const previous = authTokenEnvLock;
+    let release;
+    authTokenEnvLock = new Promise((resolve) => {
+      release = resolve;
+    });
+
+    await previous;
+
+    const original = process.env.ANTHROPIC_AUTH_TOKEN;
+    try {
+      process.env.ANTHROPIC_AUTH_TOKEN = authToken;
+      return await operation();
+    } finally {
+      if (original !== undefined) {
+        process.env.ANTHROPIC_AUTH_TOKEN = original;
+      } else {
+        delete process.env.ANTHROPIC_AUTH_TOKEN;
+      }
+      release();
+    }
   }
 
-  async check(provider) {
+  async check(provider, options = {}) {
     if (!provider) {
       return this._result('unknown', '未找到配置', null);
     }
 
+    // 检查缓存（除非明确跳过）
+    if (!options.skipCache) {
+      const cached = this._getCachedStatus(provider);
+      if (cached) {
+        return cached;
+      }
+    }
+
     if (provider.ideName === 'codex') {
-      return this._checkCodex(provider);
+      const result = await this._checkCodex(provider);
+      this._setCachedStatus(provider, result);
+      return result;
     }
 
     if (provider.authMode === 'oauth_token') {
       return this._result('unknown', '暂不支持 OAuth 令牌检测', null);
     }
 
-    // auth_token 和 api_key 模式在官方 API 中不需要 baseUrl
-    // 仅当 authMode 为 auth_token 且设置了 baseUrl 时，才表示使用第三方服务
+    // auth_token 模式可留空 baseUrl（使用官方默认 API）
+    // api_key 模式需要 baseUrl（用于自定义端点/代理）
     if (provider.authMode === 'auth_token' && !provider.baseUrl) {
       // 对于官方 Anthropic API 的 auth_token 模式，不需要 baseUrl
       // 直接使用官方 API
@@ -36,19 +102,12 @@ class ProviderStatusChecker {
 
     const model = this._resolveModel(provider);
     try {
-      const client = this._createClient(provider);
-      if (!client) {
-        return this._result('unknown', '认证模式不受支持', null);
-      }
-
-      // 保存原始环境变量
-      const originalEnv = {};
-      if (provider.authMode === 'auth_token') {
-        originalEnv.ANTHROPIC_AUTH_TOKEN = process.env.ANTHROPIC_AUTH_TOKEN;
-        process.env.ANTHROPIC_AUTH_TOKEN = provider.authToken;
-      }
+      const performCheck = async () => {
+        const client = this._createClient(provider);
+        if (!client) {
+          return this._result('unknown', '认证模式不受支持', null);
+        }
 
-      try {
         const start = process.hrtime.bigint();
         const response = await client.messages.create({
           model,
@@ -68,18 +127,20 @@ class ProviderStatusChecker {
         }
 
         return this._result('online', `可用 ${latency.toFixed(0)}ms`, latency);
-      } finally {
-        // 恢复原始环境变量
-        if (provider.authMode === 'auth_token') {
-          if (originalEnv.ANTHROPIC_AUTH_TOKEN !== undefined) {
-            process.env.ANTHROPIC_AUTH_TOKEN = originalEnv.ANTHROPIC_AUTH_TOKEN;
-          } else {
-            delete process.env.ANTHROPIC_AUTH_TOKEN;
-          }
-        }
+      };
+
+      let result;
+      if (provider.authMode === 'auth_token') {
+        result = await this._withAuthTokenEnv(provider.authToken, performCheck);
+      } else {
+        result = await performCheck();
       }
+      this._setCachedStatus(provider, result);
+      return result;
     } catch (error) {
-      return this._handleError(error);
+      const result = this._handleError(error);
+      this._setCachedStatus(provider, result);
+      return result;
     }
   }
 

package/src/utils/secrets.js

@@ -0,0 +1,22 @@
+function maskToken(token) {
+  if (!token || typeof token !== 'string') {
+    return token;
+  }
+
+  const value = token.trim();
+  if (value.length < 10) {
+    return '***';
+  }
+
+  return value.substring(0, 8) + '***' + value.substring(value.length - 4);
+}
+
+function maybeMaskToken(token, showToken = false) {
+  if (!token) {
+    return token;
+  }
+  return showToken ? token : maskToken(token);
+}
+
+module.exports = { maskToken, maybeMaskToken };
+

package/src/utils/update-checker.js

@@ -105,8 +105,14 @@ async function checkForUpdates({ packageName, currentVersion }) {
           return;
         }
         console.log(chalk.green('更新成功，正在重启...'));
-        const child = spawn('cc', process.argv.slice(2), {
-          shell: true,
+        const scriptPath = process.argv[1];
+        const restartCommand = scriptPath ? process.execPath : packageName;
+        const restartArgs = scriptPath
+          ? [scriptPath, ...process.argv.slice(2)]
+          : process.argv.slice(2);
+
+        const child = spawn(restartCommand, restartArgs, {
+          shell: process.platform === 'win32',
           stdio: 'inherit',
         });
         child.on('close', (code) => {

package/src/utils/validator.js

@@ -117,75 +117,10 @@ const validator = {
     return null;
   },
 
-  validateLaunchArgs(args) {
-    if (!Array.isArray(args)) {
-      return '启动参数必须是数组';
-    }
-    
-    const validArgs = [
-      '--dangerously-skip-permissions',
-      '--no-confirm', 
-      '--allow-all',
-      '--auto-approve',
-      '--yes',
-      '--force'
-    ];
-    
-    for (const arg of args) {
-      if (!validArgs.includes(arg)) {
-        return `无效的启动参数: ${arg}`;
-      }
-    }
-    
-    return null;
-  },
-
   getAvailableLaunchArgs() {
-    return [
-      {
-        name: '--continue',
-        label: '继续上次对话',
-        description: '恢复上次的对话记录',
-        checked: false
-      },
-      {
-        name: '--dangerously-skip-permissions',
-        label: '最高权限',
-        description: '仅限沙盒环境使用',
-        checked: false
-      },
-      {
-        name: '--no-confirm',
-        label: '直接执行操作',
-        description: '跳过确认提示',
-        checked: false
-      },
-      {
-        name: '--allow-all',
-        label: '允许全部操作',
-        description: '移除安全限制',
-        checked: false
-      },
-      {
-        name: '--auto-approve',
-        label: '自动批准请求',
-        description: '无需人工同意',
-        checked: false
-      },
-      {
-        name: '--yes',
-        label: '默认回答 yes',
-        description: '自动同意所有询问',
-        checked: false
-      },
-      {
-        name: '--force',
-        label: '强制执行',
-        description: '忽略可能的警告',
-        checked: false
-      }
-    ];
+    const { getClaudeLaunchArgs } = require('./launch-args');
+    return getClaudeLaunchArgs();
   }
 };
 
-module.exports = { validator };
+module.exports = { validator };