@pikecode/api-key-manager 1.0.31 → 1.0.33

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 };

package/src/utils/storage.js

@@ -1,55 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const os = require('os');
-
-class Storage {
-  static async ensureConfigDir() {
-    const configDir = path.join(os.homedir(), '.akm-config');
-    await fs.ensureDir(configDir);
-    return configDir;
-  }
-
-  static async readConfig() {
-    const configPath = path.join(os.homedir(), '.akm-config.json');
-    try {
-      if (await fs.pathExists(configPath)) {
-        return await fs.readJSON(configPath);
-      }
-      return null;
-    } catch (error) {
-      throw new Error(`读取配置文件失败: ${error.message}`);
-    }
-  }
-
-  static async writeConfig(config) {
-    const configPath = path.join(os.homedir(), '.akm-config.json');
-    try {
-      await fs.writeJSON(configPath, config, { spaces: 2 });
-      return true;
-    } catch (error) {
-      throw new Error(`写入配置文件失败: ${error.message}`);
-    }
-  }
-
-  static async backupConfig() {
-    const configPath = path.join(os.homedir(), '.akm-config.json');
-    const backupPath = path.join(os.homedir(), '.akm-config.backup.json');
-
-    if (await fs.pathExists(configPath)) {
-      await fs.copy(configPath, backupPath);
-      return backupPath;
-    }
-    return null;
-  }
-
-  static async restoreConfig(backupPath) {
-    const configPath = path.join(os.homedir(), '.akm-config.json');
-    if (await fs.pathExists(backupPath)) {
-      await fs.copy(backupPath, configPath);
-      return true;
-    }
-    return false;
-  }
-}
-
-module.exports = { Storage };