baozang-activator 1.0.0

package/README.md

@@ -0,0 +1,71 @@
+# baozang-activator
+
+API 激活工具 - 支持 Claude Code, Codex, Gemini CLI 的一键配置
+
+## 安装使用
+
+```bash
+# 直接使用 npx（推荐）
+npx baozang-activator
+
+# 或全局安装
+npm install -g baozang-activator
+baozang-activator
+```
+
+## 使用方式
+
+### 交互式配置
+```bash
+npx baozang-activator
+```
+
+### 直接传入 API Key（自动识别类型）
+```bash
+npx baozang-activator sk-ant-xxx    # 自动识别为 Claude Code
+npx baozang-activator sk-xxx        # 自动识别为 Codex
+npx baozang-activator AIzaXXX       # 自动识别为 Gemini CLI
+```
+
+### 指定工具类型
+```bash
+npx baozang-activator -t claude sk-ant-xxx
+npx baozang-activator -t codex sk-xxx
+npx baozang-activator -t gemini AIzaXXX
+```
+
+## API Key 自动识别规则
+
+| 前缀 | 工具类型 |
+|------|----------|
+| `sk-ant-*` | Claude Code |
+| `sk-*` | Codex (OpenAI) |
+| `AIza*` | Gemini CLI |
+
+## 配置内容
+
+工具会自动配置以下内容：
+
+### Claude Code
+- 环境变量: `ANTHROPIC_BASE_URL`, `ANTHROPIC_AUTH_TOKEN`
+- 配置文件: `~/.config/claude-code/config.json`
+
+### Codex
+- 环境变量: `OPENAI_BASE_URL`, `OPENAI_API_KEY`
+- 配置文件: `~/.config/codex/config.toml`
+- 认证文件: `~/.config/codex/auth.json`
+
+### Gemini CLI
+- 环境变量: `GOOGLE_GEMINI_BASE_URL`, `GEMINI_API_KEY`
+
+## 命令行选项
+
+```
+-t, --type <type>    指定工具类型 (claude/codex/gemini)
+-h, --help           显示帮助信息
+-v, --version        显示版本号
+```
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+
+/**
+ * baozang-activator CLI
+ * API 激活工具 - 支持 Claude Code, Codex, Gemini CLI
+ * 
+ * 使用方式:
+ *   npx baozang-activator
+ *   npx baozang-activator <api-key>
+ *   npx baozang-activator --type claude <api-key>
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const readline = require('readline');
+const { detectKeyType, getAllToolTypes, getToolConfig } = require('../lib/keyDetector');
+const { configure, isToolInstalled, getShellConfigPath } = require('../lib/configurator');
+
+const VERSION = '1.0.0';
+const BANNER = `
+${chalk.cyan('╔════════════════════════════════════════════╗')}
+${chalk.cyan('║')}  ${chalk.yellow.bold('baozang-activator')} ${chalk.gray(`v${VERSION}`)}                 ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.white('baozang.duckdns.org 激活工具')}              ${chalk.cyan('║')}
+${chalk.cyan('║')}  ${chalk.gray('支持 Claude Code / Codex / Gemini CLI')}     ${chalk.cyan('║')}
+${chalk.cyan('╚════════════════════════════════════════════╝')}
+`;
+
+/**
+ * 打印信息
+ */
+const log = {
+  info: (msg) => console.log(chalk.blue('[信息]'), msg),
+  success: (msg) => console.log(chalk.green('[成功]'), msg),
+  warning: (msg) => console.log(chalk.yellow('[警告]'), msg),
+  error: (msg) => console.log(chalk.red('[错误]'), msg)
+};
+
+/**
+ * 解析命令行参数
+ */
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const result = { apiKey: null, type: null, help: false, version: false, yes: false };
+  
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') {
+      result.help = true;
+    } else if (arg === '--version' || arg === '-v') {
+      result.version = true;
+    } else if (arg === '--type' || arg === '-t') {
+      result.type = args[++i];
+    } else if (arg === '--yes' || arg === '-y') {
+      result.yes = true;
+    } else if (!arg.startsWith('-')) {
+      result.apiKey = arg;
+    }
+  }
+  
+  return result;
+}
+
+/**
+ * 显示帮助信息
+ */
+function showHelp() {
+  console.log(`
+${chalk.yellow('使用方式:')}
+  npx baozang-activator                    交互式配置
+  npx baozang-activator <api-key>          自动识别并配置
+  npx baozang-activator -t <type> <key>    指定类型配置
+
+${chalk.yellow('选项:')}
+  -t, --type <type>    指定工具类型 (claude/codex/gemini)
+  -y, --yes            跳过确认，直接配置
+  -h, --help           显示帮助信息
+  -v, --version        显示版本号
+
+${chalk.yellow('API Key 自动识别规则:')}
+  ${chalk.cyan('sk-ant-*')}       → Claude Code
+  ${chalk.cyan('sk-*')}           → Codex (OpenAI)
+  ${chalk.cyan('AIza*')}          → Gemini CLI
+
+${chalk.yellow('示例:')}
+  npx baozang-activator sk-ant-xxx         配置 Claude Code
+  npx baozang-activator sk-xxx             配置 Codex
+  npx baozang-activator AIzaXXX            配置 Gemini CLI
+  npx baozang-activator -y sk-ant-xxx      跳过确认直接配置
+  npx baozang-activator -t codex sk-xxx    强制配置为 Codex
+`);
+}
+
+/**
+ * 检查是否为交互式终端
+ */
+function isInteractive() {
+  return process.stdin.isTTY;
+}
+
+/**
+ * 让用户选择工具类型
+ */
+async function selectToolType() {
+  const tools = getAllToolTypes();
+  const choices = Object.entries(tools).map(([key, config]) => ({
+    name: `${config.name} (${config.command})`,
+    value: key
+  }));
+  
+  const { type } = await inquirer.prompt([{
+    type: 'list',
+    name: 'type',
+    message: '请选择要配置的工具:',
+    choices
+  }]);
+  
+  return type;
+}
+
+/**
+ * 获取 API Key
+ */
+async function getApiKey() {
+  const { apiKey } = await inquirer.prompt([{
+    type: 'password',
+    name: 'apiKey',
+    message: '请输入您的 API Key:',
+    mask: '*',
+    validate: (input) => input.trim() ? true : 'API Key 不能为空'
+  }]);
+  
+  return apiKey.trim();
+}
+
+/**
+ * 确认配置
+ */
+async function confirmConfig(type, config, skipConfirm) {
+  console.log('');
+  log.info(`检测到工具类型: ${chalk.cyan(config.name)}`);
+  log.info(`Base URL: ${chalk.gray(config.baseUrl)}`);
+  
+  const installed = isToolInstalled(config.command);
+  if (installed) {
+    log.success(`${config.command} 已安装`);
+  } else {
+    log.warning(`${config.command} 未安装，配置后请先安装工具`);
+  }
+  
+  // 如果跳过确认或非交互式模式，直接返回 true
+  if (skipConfirm || !isInteractive()) {
+    return true;
+  }
+  
+  const { confirm } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'confirm',
+    message: '确认进行配置?',
+    default: true
+  }]);
+  
+  return confirm;
+}
+
+/**
+ * 执行配置
+ */
+async function doConfig(type, apiKey, config) {
+  try {
+    log.info('正在配置...');
+    const result = configure(type, apiKey, config);
+    
+    console.log('');
+    log.success(`${config.name} 配置完成！`);
+    console.log('');
+    console.log(chalk.yellow('已配置:'));
+    console.log(`  - 环境变量: ${chalk.gray(result.shellConfig)}`);
+    if (result.configFile) {
+      console.log(`  - 配置文件: ${chalk.gray(result.configFile)}`);
+    }
+    if (result.authFile) {
+      console.log(`  - 认证文件: ${chalk.gray(result.authFile)}`);
+    }
+    
+    console.log('');
+    console.log(chalk.yellow('请运行以下命令使配置生效:'));
+    console.log(chalk.cyan(`  source ${result.shellConfig}`));
+    console.log('');
+    console.log(chalk.yellow(`然后运行 '${config.command}' 启动工具`));
+    
+    return true;
+  } catch (err) {
+    log.error(`配置失败: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * 主函数
+ */
+async function main() {
+  console.log(BANNER);
+  
+  const args = parseArgs();
+  
+  if (args.help) {
+    showHelp();
+    return;
+  }
+  
+  if (args.version) {
+    console.log(`v${VERSION}`);
+    return;
+  }
+  
+  let apiKey = args.apiKey;
+  let type = args.type;
+  let config;
+  
+  // 如果没有提供 API Key
+  if (!apiKey) {
+    if (!isInteractive()) {
+      log.error('非交互式模式下必须提供 API Key');
+      log.info('用法: npx baozang-activator <api-key>');
+      process.exit(1);
+    }
+    apiKey = await getApiKey();
+  }
+  
+  // 如果没有指定类型，尝试自动检测
+  if (!type) {
+    const detected = detectKeyType(apiKey);
+    if (detected) {
+      type = detected.type;
+      config = detected.config;
+      log.info(`自动识别为: ${chalk.cyan(config.name)}`);
+    } else {
+      if (!isInteractive()) {
+        log.error('无法自动识别 API Key 类型，请使用 -t 参数指定');
+        log.info('支持的类型: claude, codex, gemini');
+        process.exit(1);
+      }
+      log.warning('无法自动识别 API Key 类型，请手动选择');
+      type = await selectToolType();
+      config = getToolConfig(type);
+    }
+  } else {
+    config = getToolConfig(type);
+    if (!config) {
+      log.error(`不支持的工具类型: ${type}`);
+      log.info('支持的类型: claude, codex, gemini');
+      process.exit(1);
+    }
+  }
+  
+  // 确认配置
+  const confirmed = await confirmConfig(type, config, args.yes);
+  if (!confirmed) {
+    log.info('已取消配置');
+    return;
+  }
+  
+  // 执行配置
+  await doConfig(type, apiKey, config);
+}
+
+// 运行
+main().catch(err => {
+  log.error(err.message);
+  process.exit(1);
+});

package/lib/configurator.js

@@ -0,0 +1,262 @@
+/**
+ * 配置器 - 负责写入配置文件和环境变量
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = os.homedir();
+
+/**
+ * 获取 shell 配置文件路径
+ * @returns {string} - shell 配置文件路径
+ */
+function getShellConfigPath() {
+  const shell = process.env.SHELL || '';
+  
+  if (shell.includes('zsh')) {
+    return path.join(HOME, '.zshrc');
+  } else if (shell.includes('bash')) {
+    const bashrc = path.join(HOME, '.bashrc');
+    if (fs.existsSync(bashrc)) {
+      return bashrc;
+    }
+    return path.join(HOME, '.bash_profile');
+  }
+  return path.join(HOME, '.profile');
+}
+
+/**
+ * 检查配置文件中是否存在某个环境变量
+ * @param {string} filePath - 配置文件路径
+ * @param {string} varName - 环境变量名
+ * @returns {boolean}
+ */
+function hasEnvVar(filePath, varName) {
+  if (!fs.existsSync(filePath)) {
+    return false;
+  }
+  const content = fs.readFileSync(filePath, 'utf-8');
+  return content.includes(`export ${varName}=`);
+}
+
+/**
+ * 添加环境变量到配置文件
+ * @param {string} filePath - 配置文件路径
+ * @param {string} varName - 环境变量名
+ * @param {string} varValue - 环境变量值
+ */
+function addEnvVar(filePath, varName, varValue) {
+  const line = `\n# baozang.duckdns.org 配置 - ${new Date().toISOString()}\nexport ${varName}="${varValue}"\n`;
+  fs.appendFileSync(filePath, line);
+}
+
+/**
+ * 更新环境变量（如果存在则更新，不存在则添加）
+ * @param {string} filePath - 配置文件路径
+ * @param {string} varName - 环境变量名
+ * @param {string} varValue - 环境变量值
+ */
+function updateEnvVar(filePath, varName, varValue) {
+  if (!fs.existsSync(filePath)) {
+    addEnvVar(filePath, varName, varValue);
+    return;
+  }
+
+  let content = fs.readFileSync(filePath, 'utf-8');
+  const regex = new RegExp(`export ${varName}=.*`, 'g');
+  
+  if (regex.test(content)) {
+    content = content.replace(regex, `export ${varName}="${varValue}"`);
+    fs.writeFileSync(filePath, content);
+  } else {
+    addEnvVar(filePath, varName, varValue);
+  }
+}
+
+/**
+ * 确保目录存在
+ * @param {string} dirPath - 目录路径
+ */
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+/**
+ * 更新 JSON 配置文件
+ * @param {string} filePath - 文件路径
+ * @param {object} updates - 要更新的键值对
+ */
+function updateJsonConfig(filePath, updates) {
+  let data = {};
+  
+  if (fs.existsSync(filePath)) {
+    try {
+      data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    } catch (e) {
+      data = {};
+    }
+  }
+  
+  Object.assign(data, updates);
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+
+/**
+ * 更新 TOML 配置文件
+ * @param {string} filePath - 文件路径
+ * @param {object} updates - 要更新的键值对
+ */
+function updateTomlConfig(filePath, updates) {
+  let lines = [];
+  
+  if (fs.existsSync(filePath)) {
+    lines = fs.readFileSync(filePath, 'utf-8').split('\n');
+  }
+  
+  for (const [key, value] of Object.entries(updates)) {
+    const regex = new RegExp(`^${key}\\s*=`);
+    const newLine = `${key} = "${value}"`;
+    const index = lines.findIndex(line => regex.test(line));
+    
+    if (index >= 0) {
+      lines[index] = newLine;
+    } else {
+      lines.push(newLine);
+    }
+  }
+  
+  fs.writeFileSync(filePath, lines.join('\n'));
+}
+
+/**
+ * 配置 Claude Code
+ * @param {string} apiKey - API Key
+ * @param {object} config - 工具配置
+ * @returns {object} - 配置结果
+ */
+function configureClaude(apiKey, config) {
+  const shellConfig = getShellConfigPath();
+  const configDir = path.join(HOME, config.configDir);
+  const configFile = path.join(configDir, config.configFile);
+  
+  // 更新环境变量
+  updateEnvVar(shellConfig, config.envVars.baseUrl, config.baseUrl);
+  updateEnvVar(shellConfig, config.envVars.apiKey, apiKey);
+  
+  // 更新配置文件
+  ensureDir(configDir);
+  updateJsonConfig(configFile, {
+    baseUrl: config.baseUrl,
+    apiKey: apiKey
+  });
+  
+  return {
+    shellConfig,
+    configFile,
+    envVars: [config.envVars.baseUrl, config.envVars.apiKey]
+  };
+}
+
+/**
+ * 配置 Codex
+ * @param {string} apiKey - API Key
+ * @param {object} config - 工具配置
+ * @returns {object} - 配置结果
+ */
+function configureCodex(apiKey, config) {
+  const shellConfig = getShellConfigPath();
+  const configDir = path.join(HOME, config.configDir);
+  const configFile = path.join(configDir, config.configFile);
+  const authFile = path.join(configDir, config.authFile);
+  
+  // 更新环境变量
+  updateEnvVar(shellConfig, config.envVars.baseUrl, config.baseUrl);
+  updateEnvVar(shellConfig, config.envVars.apiKey, apiKey);
+  
+  // 更新配置文件
+  ensureDir(configDir);
+  updateTomlConfig(configFile, {
+    base_url: config.baseUrl,
+    api_key: apiKey
+  });
+  
+  // 更新认证文件
+  updateJsonConfig(authFile, {
+    baseUrl: config.baseUrl,
+    apiKey: apiKey
+  });
+  
+  return {
+    shellConfig,
+    configFile,
+    authFile,
+    envVars: [config.envVars.baseUrl, config.envVars.apiKey]
+  };
+}
+
+/**
+ * 配置 Gemini CLI
+ * @param {string} apiKey - API Key
+ * @param {object} config - 工具配置
+ * @returns {object} - 配置结果
+ */
+function configureGemini(apiKey, config) {
+  const shellConfig = getShellConfigPath();
+  
+  // 更新环境变量
+  updateEnvVar(shellConfig, config.envVars.baseUrl, config.baseUrl);
+  updateEnvVar(shellConfig, config.envVars.apiKey, apiKey);
+  
+  return {
+    shellConfig,
+    envVars: [config.envVars.baseUrl, config.envVars.apiKey]
+  };
+}
+
+/**
+ * 根据类型配置工具
+ * @param {string} type - 工具类型
+ * @param {string} apiKey - API Key
+ * @param {object} config - 工具配置
+ * @returns {object} - 配置结果
+ */
+function configure(type, apiKey, config) {
+  switch (type) {
+    case 'claude':
+      return configureClaude(apiKey, config);
+    case 'codex':
+      return configureCodex(apiKey, config);
+    case 'gemini':
+      return configureGemini(apiKey, config);
+    default:
+      throw new Error(`不支持的工具类型: ${type}`);
+  }
+}
+
+/**
+ * 检查工具是否已安装
+ * @param {string} command - 命令名
+ * @returns {boolean}
+ */
+function isToolInstalled(command) {
+  const { execSync } = require('child_process');
+  try {
+    execSync(`which ${command}`, { stdio: 'ignore' });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+module.exports = {
+  getShellConfigPath,
+  configure,
+  isToolInstalled,
+  ensureDir,
+  updateJsonConfig,
+  updateTomlConfig
+};

package/lib/index.js

@@ -0,0 +1,17 @@
+/**
+ * yunyi-activator
+ * API 激活工具库
+ */
+
+const { detectKeyType, getAllToolTypes, getToolConfig, KEY_PATTERNS } = require('./keyDetector');
+const { configure, isToolInstalled, getShellConfigPath } = require('./configurator');
+
+module.exports = {
+  detectKeyType,
+  getAllToolTypes,
+  getToolConfig,
+  KEY_PATTERNS,
+  configure,
+  isToolInstalled,
+  getShellConfigPath
+};

package/lib/keyDetector.js

@@ -0,0 +1,139 @@
+/**
+ * API Key 类型检测器
+ * 根据 API Key 前缀自动识别工具类型
+ */
+
+// 环境配置
+const ENVIRONMENTS = {
+  test: {
+    name: 'Test (baozang.duckdns.org)',
+    baseUrl: 'https://baozang.duckdns.org/',
+    baseUrlV1: 'https://baozang.duckdns.org/v1'
+  },
+  prod: {
+    name: 'Production (baozangaizhongzhuan.net)',
+    baseUrl: 'https://www.baozangaizhongzhuan.net/',
+    baseUrlV1: 'https://www.baozangaizhongzhuan.net/v1'
+  }
+};
+
+// 默认环境由包名决定，这里设置为占位符，会在构建时替换
+let DEFAULT_ENV = 'prod';
+
+/**
+ * 获取当前环境配置
+ */
+function getEnvConfig() {
+  return ENVIRONMENTS[DEFAULT_ENV] || ENVIRONMENTS.test;
+}
+
+/**
+ * 设置环境
+ */
+function setEnvironment(env) {
+  if (ENVIRONMENTS[env]) {
+    DEFAULT_ENV = env;
+  }
+}
+
+const KEY_PATTERNS = {
+  claude: {
+    prefixes: ['sk-ant-', 'claude-', 'anthropic-'],
+    name: 'Claude Code',
+    command: 'claude',
+    envVars: {
+      baseUrl: 'ANTHROPIC_BASE_URL',
+      apiKey: 'ANTHROPIC_AUTH_TOKEN'
+    },
+    get baseUrl() { return getEnvConfig().baseUrl; },
+    configDir: '.config/claude-code',
+    configFile: 'config.json'
+  },
+  codex: {
+    prefixes: ['sk-', 'openai-', 'codex-'],
+    name: 'Codex',
+    command: 'codex',
+    envVars: {
+      baseUrl: 'OPENAI_BASE_URL',
+      apiKey: 'OPENAI_API_KEY'
+    },
+    get baseUrl() { return getEnvConfig().baseUrlV1; },
+    configDir: '.config/codex',
+    configFile: 'config.toml',
+    authFile: 'auth.json'
+  },
+  gemini: {
+    prefixes: ['AIza', 'gemini-', 'google-'],
+    name: 'Gemini CLI',
+    command: 'gemini',
+    envVars: {
+      baseUrl: 'GOOGLE_GEMINI_BASE_URL',
+      apiKey: 'GEMINI_API_KEY'
+    },
+    get baseUrl() { return getEnvConfig().baseUrl; },
+    configDir: '.config/gemini',
+    configFile: 'config.json'
+  }
+};
+
+/**
+ * 检测 API Key 类型
+ * @param {string} apiKey - API Key
+ * @returns {object|null} - 匹配的工具配置，或 null
+ */
+function detectKeyType(apiKey) {
+  if (!apiKey || typeof apiKey !== 'string') {
+    return null;
+  }
+
+  const key = apiKey.trim();
+
+  // 优先检查 Claude (sk-ant- 开头)
+  if (key.startsWith('sk-ant-')) {
+    return { type: 'claude', config: KEY_PATTERNS.claude };
+  }
+
+  // 检查 Gemini (AIza 开头)
+  if (key.startsWith('AIza')) {
+    return { type: 'gemini', config: KEY_PATTERNS.gemini };
+  }
+
+  // 检查其他前缀
+  for (const [type, config] of Object.entries(KEY_PATTERNS)) {
+    for (const prefix of config.prefixes) {
+      if (key.startsWith(prefix)) {
+        return { type, config };
+      }
+    }
+  }
+
+  // 默认返回 null，让用户手动选择
+  return null;
+}
+
+/**
+ * 获取所有支持的工具类型
+ * @returns {object} - 工具配置映射
+ */
+function getAllToolTypes() {
+  return KEY_PATTERNS;
+}
+
+/**
+ * 根据类型获取工具配置
+ * @param {string} type - 工具类型 (claude/codex/gemini)
+ * @returns {object|null} - 工具配置
+ */
+function getToolConfig(type) {
+  return KEY_PATTERNS[type] || null;
+}
+
+module.exports = {
+  detectKeyType,
+  getAllToolTypes,
+  getToolConfig,
+  getEnvConfig,
+  setEnvironment,
+  ENVIRONMENTS,
+  KEY_PATTERNS
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "baozang-activator",
+  "version": "1.0.0",
+  "description": "API 激活工具 (生产环境 - baozangaizhongzhuan.net)",
+  "main": "lib/index.js",
+  "bin": {
+    "baozang-activator": "./bin/cli.js"
+  },
+  "keywords": [
+    "claude",
+    "codex",
+    "gemini",
+    "api",
+    "activator",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "inquirer": "^8.2.6"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}