@pikecode/api-key-manager 2.0.0

package/src/utils/env-launcher.js

@@ -0,0 +1,80 @@
+const spawn = require('cross-spawn');
+
+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) {
+    // 忽略清屏失败
+  }
+}
+
+function buildEnvVariables(config) {
+  const env = { ...process.env };
+
+  if (config.authMode === 'oauth_token') {
+    env.CLAUDE_CODE_OAUTH_TOKEN = config.authToken;
+  } else if (config.authMode === 'api_key') {
+    env.ANTHROPIC_BASE_URL = config.baseUrl;
+    // 根据 tokenType 选择设置哪种 token
+    if (config.tokenType === 'auth_token') {
+      env.ANTHROPIC_AUTH_TOKEN = config.authToken;
+    } else {
+      // 默认使用 ANTHROPIC_API_KEY
+      env.ANTHROPIC_API_KEY = config.authToken;
+    }
+  } else {
+    // auth_token 模式
+    env.ANTHROPIC_BASE_URL = config.baseUrl;
+    env.ANTHROPIC_AUTH_TOKEN = config.authToken;
+  }
+
+  if (config.models && config.models.primary) {
+    env.ANTHROPIC_MODEL = config.models.primary;
+  }
+
+  if (config.models && config.models.smallFast) {
+    env.ANTHROPIC_SMALL_FAST_MODEL = config.models.smallFast;
+  }
+
+  return env;
+}
+
+async function executeWithEnv(config, launchArgs = []) {
+  const env = buildEnvVariables(config);
+  const args = [...launchArgs];
+
+  clearTerminal();
+
+  return new Promise((resolve, reject) => {
+    const child = spawn('claude', args, {
+      stdio: 'inherit',
+      env,
+      shell: true
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Claude Code 退出，代码: ${code}`));
+      }
+    });
+
+    child.on('error', reject);
+  });
+}
+
+module.exports = { executeWithEnv };

package/src/utils/error-handler.js

@@ -0,0 +1,53 @@
+const chalk = require('chalk');
+const { Logger } = require('./utils/logger');
+
+class ErrorHandler {
+  static handle(error, context = '') {
+    const contextStr = context ? `[${context}] ` : '';
+    
+    switch (error.type) {
+      case 'CONFIG_NOT_FOUND':
+        Logger.error(`${contextStr}配置文件不存在，请先添加供应商`);
+        break;
+      case 'PROVIDER_NOT_FOUND':
+        Logger.error(`${contextStr}指定的供应商不存在`);
+        break;
+      case 'INVALID_TOKEN':
+        Logger.error(`${contextStr}Token格式无效`);
+        break;
+      case 'INVALID_URL':
+        Logger.error(`${contextStr}URL格式无效`);
+        break;
+      case 'INVALID_NAME':
+        Logger.error(`${contextStr}供应商名称格式无效`);
+        break;
+      case 'FILE_PERMISSION':
+        Logger.error(`${contextStr}文件权限不足`);
+        break;
+      case 'NETWORK_ERROR':
+        Logger.error(`${contextStr}网络连接错误`);
+        break;
+      default:
+        Logger.error(`${contextStr}${error.message || '未知错误'}`);
+        break;
+    }
+  }
+
+  static createError(type, message, originalError = null) {
+    const error = new Error(message);
+    error.type = type;
+    error.originalError = originalError;
+    return error;
+  }
+
+  static async withErrorHandling(fn, context = '') {
+    try {
+      return await fn();
+    } catch (error) {
+      this.handle(error, context);
+      throw error;
+    }
+  }
+}
+
+module.exports = { ErrorHandler };

package/src/utils/inquirer-setup.js

@@ -0,0 +1,89 @@
+const inquirer = require('inquirer');
+const CheckboxPrompt = require('inquirer/lib/prompts/checkbox');
+const chalk = require('chalk');
+const figures = require('figures');
+
+class LocalizedCheckboxPrompt extends CheckboxPrompt {
+  render(error) {
+    let message = this.getQuestion();
+    let bottomContent = '';
+
+    if (!this.dontShowHints) {
+      message += chalk.gray(' （空格切换选中，a 全选，i 反选，回车继续）');
+    }
+
+    if (this.status === 'answered') {
+      message += chalk.cyan(this.selection.join(', '));
+    } else {
+      const choicesStr = renderChoices(this.opt.choices, this.pointer);
+      const indexPosition = this.opt.choices.indexOf(
+        this.opt.choices.getChoice(this.pointer)
+      );
+      const realIndexPosition =
+        this.opt.choices.reduce((acc, value, i) => {
+          if (i > indexPosition) {
+            return acc;
+          }
+
+          if (value.type === 'separator') {
+            return acc + 1;
+          }
+
+          let line = value.name;
+          if (typeof line !== 'string') {
+            return acc + 1;
+          }
+
+          line = line.split('\n');
+          return acc + line.length;
+        }, 0) - 1;
+
+      message +=
+        '\n' + this.paginator.paginate(choicesStr, realIndexPosition, this.opt.pageSize);
+    }
+
+    if (error) {
+      bottomContent = chalk.red('>> ') + error;
+    }
+
+    this.screen.render(message, bottomContent);
+  }
+}
+
+function renderChoices(choices, pointer) {
+  let output = '';
+  let separatorOffset = 0;
+
+  choices.forEach((choice, index) => {
+    if (choice.type === 'separator') {
+      separatorOffset++;
+      output += ' ' + choice + '\n';
+      return;
+    }
+
+    if (choice.disabled) {
+      separatorOffset++;
+      output += ' - ' + choice.name;
+      output += ` (${typeof choice.disabled === 'string' ? choice.disabled : '禁用'})`;
+    } else {
+      const line = getCheckbox(choice.checked) + ' ' + choice.name;
+      if (index - separatorOffset === pointer) {
+        output += chalk.cyan(figures.pointer + line);
+      } else {
+        output += ' ' + line;
+      }
+    }
+
+    output += '\n';
+  });
+
+  return output.replace(/\n$/, '');
+}
+
+function getCheckbox(checked) {
+  return checked ? chalk.green(figures.radioOn) : figures.radioOff;
+}
+
+inquirer.registerPrompt('checkbox', LocalizedCheckboxPrompt);
+
+module.exports = {};

package/src/utils/logger.js

@@ -0,0 +1,41 @@
+const chalk = require('chalk');
+const { formatMessage } = require('./terminal-format');
+
+class Logger {
+  static info(message) {
+    console.log(formatMessage(message, 'info'));
+  }
+
+  static success(message) {
+    console.log(formatMessage(message, 'success'));
+  }
+
+  static warning(message) {
+    console.log(formatMessage(message, 'warning'));
+  }
+
+  static error(message) {
+    console.error(formatMessage(message, 'error'));
+  }
+
+  static debug(message) {
+    if (process.env.DEBUG) {
+      console.log(formatMessage(`[DEBUG] ${message}`, 'info'));
+    }
+  }
+
+  static step(message) {
+    console.log(formatMessage(`🔄 ${message}`, 'info'));
+  }
+
+  static complete(message) {
+    console.log(formatMessage(`✅ ${message}`, 'success'));
+  }
+
+  static fatal(message) {
+    console.error(formatMessage(`💀 ${message}`, 'error'));
+    process.exit(1);
+  }
+}
+
+module.exports = { Logger };

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

@@ -0,0 +1,210 @@
+const { Anthropic, APIConnectionTimeoutError, APIConnectionError, APIError } = require('@anthropic-ai/sdk');
+
+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';
+  }
+
+  async check(provider) {
+    if (!provider) {
+      return this._result('unknown', '未找到配置', null);
+    }
+
+    if (provider.authMode === 'oauth_token') {
+      return this._result('unknown', '暂不支持 OAuth 令牌检测', null);
+    }
+
+    if (!provider.baseUrl) {
+      return this._result('unknown', '未配置基础地址', null);
+    }
+
+    if (!provider.authToken) {
+      return this._result('unknown', '未配置认证信息', null);
+    }
+
+    const model = this._resolveModel(provider);
+    try {
+      const client = this._createClient(provider);
+      if (!client) {
+        return this._result('unknown', '认证模式不受支持', null);
+      }
+
+      const start = process.hrtime.bigint();
+      const response = await client.messages.create({
+        model,
+        max_tokens: this.maxTokens,
+        messages: [
+          {
+            role: 'user',
+            content: this.testMessage
+          }
+        ]
+      }, { timeout: this.timeout });
+      const latency = Number(process.hrtime.bigint() - start) / 1e6;
+
+      const text = this._extractText(response);
+      if (!text) {
+        return this._result('online', `可用 ${latency.toFixed(0)}ms (无文本响应)`, latency);
+      }
+
+      return this._result('online', `可用 ${latency.toFixed(0)}ms`, latency);
+    } catch (error) {
+      return this._handleError(error);
+    }
+  }
+
+  async checkAll(providers) {
+    const entries = await Promise.all(
+      providers.map(async provider => {
+        const status = await this.check(provider);
+        return [provider.name, status];
+      })
+    );
+    return Object.fromEntries(entries);
+  }
+
+  checkAllStreaming(providers, onUpdate) {
+    const results = {};
+    const tasks = providers.map(async provider => {
+      try {
+        const status = await this.check(provider);
+        results[provider.name] = status;
+        if (typeof onUpdate === 'function') {
+          onUpdate(provider.name, status, null);
+        }
+      } catch (error) {
+        const fallback = this._result('offline', `检测失败: ${error.message}`, null);
+        results[provider.name] = fallback;
+        if (typeof onUpdate === 'function') {
+          onUpdate(provider.name, fallback, error);
+        }
+      }
+    });
+
+    return Promise.all(tasks).then(() => results);
+  }
+
+  _createClient(provider) {
+    const clientOptions = { baseURL: provider.baseUrl };
+
+    if (provider.authMode === 'api_key') {
+      clientOptions.apiKey = provider.authToken;
+    } else if (provider.authMode === 'auth_token') {
+      clientOptions.authToken = provider.authToken;
+    } else {
+      return null;
+    }
+
+    return new Anthropic(clientOptions);
+  }
+
+  _resolveModel(provider) {
+    if (provider.models?.primary) {
+      return provider.models.primary;
+    }
+    if (provider.models?.smallFast) {
+      return provider.models.smallFast;
+    }
+    return this.defaultModel;
+  }
+
+  _extractText(response) {
+    if (!response) {
+      return '';
+    }
+
+    // 兼容部分供应商返回字符串内容
+    if (typeof response.content === 'string') {
+      return response.content.trim();
+    }
+
+    if (Array.isArray(response.content)) {
+      const textParts = [];
+      for (const block of response.content) {
+        if (!block) {
+          continue;
+        }
+        if (typeof block === 'string') {
+          textParts.push(block);
+          continue;
+        }
+        if (typeof block.text === 'string' && block.text.trim()) {
+          textParts.push(block.text);
+          continue;
+        }
+        if (typeof block.thinking === 'string' && block.thinking.trim()) {
+          textParts.push(block.thinking);
+          continue;
+        }
+        if (typeof block.output_text === 'string' && block.output_text.trim()) {
+          textParts.push(block.output_text);
+          continue;
+        }
+        if (typeof block.argument === 'string' && block.argument.trim()) {
+          textParts.push(block.argument);
+          continue;
+        }
+        if (typeof block.result === 'string' && block.result.trim()) {
+          textParts.push(block.result);
+          continue;
+        }
+      }
+      const combined = textParts
+        .map(part => part.replace(/\s+/g, ' ').trim())
+        .filter(Boolean)
+        .join('\n');
+      if (combined) {
+        return combined;
+      }
+    }
+
+    if (typeof response.output_text === 'string' && response.output_text.trim()) {
+      return response.output_text.trim();
+    }
+
+    if (typeof response.completion === 'string' && response.completion.trim()) {
+      return response.completion.trim();
+    }
+
+    return '';
+  }
+
+
+  _handleError(error) {
+    if (error instanceof APIConnectionTimeoutError) {
+      return this._result('offline', '请求超时', null);
+    }
+
+    if (error instanceof APIConnectionError) {
+      return this._result('offline', '网络连接失败', null);
+    }
+
+    if (error instanceof APIError) {
+      if (error.status >= 500) {
+        return this._result('degraded', `服务异常 (${error.status})`, null);
+      }
+      if (error.status === 401 || error.status === 403) {
+        return this._result('offline', `认证失败 (${error.status})`, null);
+      }
+      if (error.status === 404) {
+        return this._result('offline', '接口不存在 (404)', null);
+      }
+      return this._result('offline', `请求失败 (${error.status})`, null);
+    }
+
+    if (error?.name === 'AbortError') {
+      return this._result('offline', '请求超时', null);
+    }
+
+    return this._result('offline', `检测失败: ${error?.message || '未知错误'}`, null);
+  }
+
+  _result(state, label, latency) {
+    return { state, label, latency };
+  }
+}
+
+module.exports = { ProviderStatusChecker };

package/src/utils/storage.js

@@ -0,0 +1,55 @@
+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 };

package/src/utils/terminal-format.js

@@ -0,0 +1,41 @@
+const supportsColor = require('supports-color');
+const chalk = require('chalk');
+
+function detectTerminalCapabilities() {
+  return {
+    colors: supportsColor.stdout,
+    unicode: Boolean(process.env.WT_SESSION || process.env.TERM_PROGRAM === 'vscode'),
+    colorDepth: typeof process.stdout.getColorDepth === 'function' ? process.stdout.getColorDepth() : 1
+  };
+}
+
+function formatMessage(message, type = 'info') {
+  const capabilities = detectTerminalCapabilities();
+
+  if (!capabilities.colors) {
+    const symbols = {
+      success: '[OK]',
+      error: '[错误]',
+      warning: '[警告]',
+      info: '[信息]'
+    };
+    return `${symbols[type] || '[信息]'} ${message}`;
+  }
+
+  const colorMap = {
+    success: chalk.green,
+    error: chalk.red,
+    warning: chalk.yellow,
+    info: chalk.blue
+  };
+
+  const symbols = capabilities.unicode
+    ? { success: '✅', error: '❌', warning: '⚠️', info: 'ℹ️' }
+    : { success: '[OK]', error: '[ERROR]', warning: '[WARN]', info: '[INFO]' };
+
+  const formatter = colorMap[type] || colorMap.info;
+  const symbol = symbols[type] || symbols.info;
+  return formatter(`${symbol} ${message}`);
+}
+
+module.exports = { formatMessage };