yymaxapi 1.0.104 → 1.0.108

package/README.md

@@ -8,8 +8,14 @@
 ```bash
 npx yymaxapi@latest
 ```
-按提示选择节点和模型即可。
-主菜单已简化为：激活 Claude / 激活 Codex / 测试连接 / 查看配置 / 恢复 / 退出。
+按提示选择模型并输入 Key 即可，默认会直接使用预设默认节点。
+主菜单已简化为：一键配置 / 配置外部工具 / 测速节点 / 测试连接 / 查看配置 / 恢复 / 退出。
+
+**需要手动测速时**
+```bash
+npx yymaxapi@latest speed-test
+```
+或在具体配置命令后追加 `--speed-test`，按测速结果手动选点。
 
 **方式二：一键配置 Claude**
 ```bash

package/bin/yymaxapi.js

@@ -607,6 +607,77 @@ async function testFallbackEndpoints() {
   return testAllEndpoints(FALLBACK_EPS, { label: '检测备用节点', autoFallback: false });
 }
 
+function shouldRunEndpointSpeedTest(args = {}) {
+  const raw = args['speed-test'] !== undefined ? args['speed-test'] : args.speedTest;
+  if (raw === undefined) return false;
+  if (typeof raw === 'string') {
+    return !['false', '0', 'no'].includes(raw.toLowerCase());
+  }
+  return !!raw;
+}
+
+async function resolveEndpointSelection(args = {}, options = {}) {
+  const defaultEndpoint = options.defaultEndpoint || ENDPOINTS[0];
+  if (!defaultEndpoint) return null;
+  if (!shouldRunEndpointSpeedTest(args)) return defaultEndpoint;
+
+  const speedIntro = options.speedIntro || '📡 开始测速节点...\n';
+  const proceedMessage = options.proceedMessage || '仍要写入默认节点配置吗？';
+  const chooseMessage = options.chooseMessage || '选择节点:';
+
+  console.log(chalk.cyan(`${speedIntro}`));
+  const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
+  const sorted = speedResult.ranked || [];
+
+  if (sorted.length > 0) {
+    const { selectedIndex } = await inquirer.prompt([{
+      type: 'list',
+      name: 'selectedIndex',
+      message: chooseMessage,
+      choices: [
+        { name: `* 使用默认节点 (${defaultEndpoint.name})`, value: -1 },
+        new inquirer.Separator('  ---- 或按测速结果选择 ----'),
+        ...sorted.map((endpoint, index) => ({
+          name: `${endpoint.name} - ${endpoint.latency}ms (评分:${endpoint.score})`,
+          value: index
+        }))
+      ]
+    }]);
+
+    const selectedEndpoint = selectedIndex === -1 ? defaultEndpoint : sorted[selectedIndex];
+    if (speedResult.usedFallback) {
+      console.log(chalk.yellow('\n⚠ 当前使用备用节点\n'));
+    }
+    return selectedEndpoint;
+  }
+
+  console.log(chalk.red('\n⚠️  所有节点（含备用）均不可达'));
+  const { proceed } = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'proceed',
+    message: proceedMessage,
+    default: false
+  }]);
+  if (!proceed) {
+    console.log(chalk.gray('已取消'));
+    return null;
+  }
+  return defaultEndpoint;
+}
+
+async function speedTestNodes() {
+  console.log(chalk.cyan.bold('\n📡 节点测速\n'));
+  const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
+  const defaultEndpoint = ENDPOINTS[0];
+
+  if (defaultEndpoint) {
+    console.log(chalk.gray(`\n默认配置当前直连: ${defaultEndpoint.name} (${defaultEndpoint.url})`));
+  }
+  if (speedResult.best && defaultEndpoint && speedResult.best.url !== defaultEndpoint.url) {
+    console.log(chalk.yellow('如需按测速结果选点，可在对应配置命令后追加 --speed-test'));
+  }
+}
+
 // ============ API Key 验证 ============
 function httpGetJson(url, headers = {}, timeout = 10000) {
   return new Promise((resolve, reject) => {
@@ -967,11 +1038,13 @@ function writeClaudeCodeSettings(baseUrl, apiKey, modelId = getDefaultClaudeMode
     if (fs.existsSync(settingsPath)) {
       try { settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch { settings = {}; }
     }
-    settings.apiBaseUrl = baseUrl.replace(/\/+$/, '');
+    const normalizedBaseUrl = baseUrl.replace(/\/+$/, '');
+    settings.apiBaseUrl = normalizedBaseUrl;
     if (!settings.env) settings.env = {};
-    settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+    settings.env.ANTHROPIC_API_KEY = apiKey;
+    settings.env.ANTHROPIC_BASE_URL = normalizedBaseUrl;
+    delete settings.env.ANTHROPIC_AUTH_TOKEN;
     delete settings.availableModels;
-    delete settings.env.ANTHROPIC_BASE_URL;
     delete settings.env.ANTHROPIC_MODEL;
     if (!fs.existsSync(claudeDir)) fs.mkdirSync(claudeDir, { recursive: true });
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
@@ -3795,6 +3868,32 @@ function readHermesYamlConfig(configPath = getHermesConfigPath()) {
   };
 }
 
+function readHermesCliConfig() {
+  const yamlConfig = readHermesYamlConfig();
+  const envPath = getHermesEnvPath();
+  const envEntries = parseEnvFile(readTextIfExists(envPath));
+  const modelConfig = yamlConfig.config?.model && typeof yamlConfig.config.model === 'object'
+    ? yamlConfig.config.model
+    : {};
+  const modelId = String(modelConfig.default || '').trim() || getDefaultClaudeModel().id;
+  const provider = String(modelConfig.provider || '').trim().toLowerCase();
+  const type = resolveHermesModelType(modelId, provider);
+  const apiKey = type === 'codex'
+    ? (envEntries.OPENAI_API_KEY || process.env.OPENAI_API_KEY || process.env.OPENAI_AUTH_TOKEN || '')
+    : (envEntries.ANTHROPIC_API_KEY || envEntries.ANTHROPIC_TOKEN || process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_TOKEN || process.env.CLAUDE_CODE_OAUTH_TOKEN || '');
+
+  return {
+    configPath: yamlConfig.configPath,
+    envPath,
+    configured: yamlConfig.configured || fs.existsSync(envPath),
+    modelId,
+    provider,
+    type,
+    baseUrl: String(modelConfig.base_url || '').trim(),
+    apiKey
+  };
+}
+
 function getOpencodeConfigPath() {
   const home = os.homedir();
   return process.platform === 'win32'
@@ -3813,11 +3912,20 @@ function getCodexCliPaths() {
 function readClaudeCodeCliConfig() {
   const settingsPath = getClaudeCodeSettingsPath();
   const settings = readJsonIfExists(settingsPath) || {};
+  const settingsEnv = settings.env && typeof settings.env === 'object' ? settings.env : {};
+  const settingsApiKey = String(settingsEnv.ANTHROPIC_API_KEY || '').trim();
+  const settingsLegacyAuthToken = String(settingsEnv.ANTHROPIC_AUTH_TOKEN || '').trim();
+  const settingsBaseUrl = String(settingsEnv.ANTHROPIC_BASE_URL || settings.apiBaseUrl || '').trim();
   return {
     settingsPath,
-    modelId: settings.model || settings.env?.ANTHROPIC_MODEL || process.env.ANTHROPIC_MODEL || getDefaultClaudeModel().id,
-    baseUrl: settings.env?.ANTHROPIC_BASE_URL || settings.apiBaseUrl || process.env.ANTHROPIC_BASE_URL || '',
-    apiKey: settings.env?.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_AUTH_TOKEN || '',
+    modelId: settings.model || settingsEnv.ANTHROPIC_MODEL || process.env.ANTHROPIC_MODEL || getDefaultClaudeModel().id,
+    baseUrl: settingsBaseUrl || process.env.ANTHROPIC_BASE_URL || '',
+    apiKey: settingsApiKey || settingsLegacyAuthToken || process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '',
+    settingsBaseUrl,
+    settingsApiKey,
+    settingsLegacyAuthToken,
+    hasLegacyAuthTokenInSettings: !!settingsLegacyAuthToken,
+    usesLegacyAuthTokenOnly: !settingsApiKey && !!settingsLegacyAuthToken,
     configured: fs.existsSync(settingsPath)
   };
 }
@@ -3872,6 +3980,23 @@ function summarizeCliTestOutput(text) {
   return lines[0].slice(0, 160);
 }
 
+function extractHermesCliReply(text) {
+  const lines = cleanCliTestOutput(text)
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean)
+    .filter(line => !/^session_id:/i.test(line))
+    .filter(line => !/^resume this session/i.test(line))
+    .filter(line => !/^session:/i.test(line))
+    .filter(line => !/^duration:/i.test(line))
+    .filter(line => !/^messages:/i.test(line))
+    .filter(line => !/^[╭╰│─]+/.test(line));
+
+  const okLine = lines.find(line => /^OK$/i.test(line));
+  if (okLine) return okLine;
+  return lines[0] || '';
+}
+
 function buildReadableAgentError(text, fallback = '') {
   const cleaned = cleanCliTestOutput(text);
   if (!cleaned) return fallback;
@@ -3887,6 +4012,11 @@ function looksLikeCliTestError(text) {
     'all models failed',
     'auth_permanent',
     'auth issue',
+    'authentication_error',
+    'failed to authenticate',
+    'invalid bearer token',
+    'invalid api key',
+    'fix external api key',
     'unauthorized',
     'forbidden',
     'missing environment variable',
@@ -3914,17 +4044,28 @@ function testClaudeCodeCliConnection() {
 
   const config = readClaudeCodeCliConfig();
   if (!config.configured) return { name: 'Claude Code CLI', status: 'skipped', detail: '未检测到 ~/.claude/settings.json' };
-  if (!config.baseUrl || !config.apiKey) return { name: 'Claude Code CLI', status: 'failed', detail: 'Claude Code 配置缺少 Base URL 或 API Key' };
+  if (config.usesLegacyAuthTokenOnly) {
+    return {
+      name: 'Claude Code CLI',
+      status: 'failed',
+      detail: '检测到旧版 Claude Code 配置字段 ANTHROPIC_AUTH_TOKEN，请重新运行 yymaxapi 以改写为 ANTHROPIC_API_KEY'
+    };
+  }
+  if (!config.settingsBaseUrl || !config.settingsApiKey) {
+    return { name: 'Claude Code CLI', status: 'failed', detail: 'Claude Code 配置缺少 settings.json 中的 Base URL 或 API Key' };
+  }
 
   const env = {
     ...process.env,
     PATH: extendPathEnv(null),
-    ANTHROPIC_BASE_URL: config.baseUrl,
-    ANTHROPIC_AUTH_TOKEN: config.apiKey,
-    ANTHROPIC_MODEL: config.modelId,
     NODE_TLS_REJECT_UNAUTHORIZED: '0',
     NODE_NO_WARNINGS: '1'
   };
+  delete env.ANTHROPIC_BASE_URL;
+  delete env.ANTHROPIC_API_KEY;
+  delete env.ANTHROPIC_AUTH_TOKEN;
+  delete env.ANTHROPIC_MODEL;
+  delete env.CLAUDE_API_KEY;
 
   return runCliTestCandidates('Claude Code CLI', [
     `${shellQuote(cliBinary)} -p --model ${shellQuote(config.modelId)} --output-format text ${shellQuote('请只回复 OK')}`,
@@ -3976,14 +4117,62 @@ function testCodexCliConnection() {
   ], env);
 }
 
+function testHermesCliConnection() {
+  const cliBinary = resolveCommandBinary('hermes');
+  if (!cliBinary) return { name: 'Hermes CLI', status: 'skipped', detail: '未安装 hermes 命令' };
+
+  const config = readHermesCliConfig();
+  if (!config.configured) return { name: 'Hermes CLI', status: 'skipped', detail: '未检测到 ~/.hermes/config.yaml 或 ~/.hermes/.env' };
+  if (!config.apiKey) return { name: 'Hermes CLI', status: 'failed', detail: 'Hermes 配置缺少 API Key' };
+
+  const env = {
+    ...process.env,
+    PATH: extendPathEnv(null),
+    NODE_TLS_REJECT_UNAUTHORIZED: '0',
+    NODE_NO_WARNINGS: '1'
+  };
+
+  if (config.type === 'codex') {
+    env.OPENAI_API_KEY = config.apiKey;
+    delete env.ANTHROPIC_API_KEY;
+    delete env.ANTHROPIC_TOKEN;
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
+  } else {
+    env.ANTHROPIC_API_KEY = config.apiKey;
+    if (config.baseUrl) env.ANTHROPIC_BASE_URL = config.baseUrl;
+    delete env.ANTHROPIC_TOKEN;
+    delete env.CLAUDE_CODE_OAUTH_TOKEN;
+  }
+
+  const providerArg = config.provider === 'anthropic' ? ' --provider anthropic' : '';
+  const result = safeExec(`${shellQuote(cliBinary)} chat -Q -q ${shellQuote('请只回复 OK')}${providerArg}`, {
+    timeout: 120000,
+    env,
+    maxBuffer: 1024 * 1024
+  });
+  const combined = cleanCliTestOutput(`${result.output || ''}\n${result.stdout || ''}\n${result.stderr || ''}`);
+  const reply = extractHermesCliReply(combined);
+
+  if (result.ok && /^OK$/i.test(reply) && !looksLikeCliTestError(combined)) {
+    return { name: 'Hermes CLI', status: 'success', detail: 'OK' };
+  }
+
+  return {
+    name: 'Hermes CLI',
+    status: 'failed',
+    detail: reply || summarizeCliTestOutput(combined) || result.error || '命令执行失败'
+  };
+}
+
 async function testAdditionalCliConnections(args = {}, options = {}) {
   if (args['no-app-test'] || args.noAppTest) return;
 
-  const requested = new Set((options.only || ['claude', 'opencode', 'codex']).map(item => String(item)));
+  const requested = new Set((options.only || ['claude', 'opencode', 'codex', 'hermes']).map(item => String(item)));
   const results = [];
   if (requested.has('claude')) results.push(testClaudeCodeCliConnection());
   if (requested.has('opencode')) results.push(testOpencodeCliConnection());
   if (requested.has('codex')) results.push(testCodexCliConnection());
+  if (requested.has('hermes')) results.push(testHermesCliConnection());
   if (results.length === 0) return;
 
   console.log(chalk.cyan('\n附加测试: 其他 CLI 连接...'));
@@ -4670,47 +4859,15 @@ async function quickSetup(paths, args = {}) {
 }
 
 async function presetClaude(paths, args = {}) {
-  console.log(chalk.cyan.bold('\n🚀 Claude 快速配置（自动测速推荐节点）\n'));
+  console.log(chalk.cyan.bold('\n🚀 Claude 快速配置（默认节点直连）\n'));
 
   const apiConfig = API_CONFIG.claude;
   const providerPrefix = (args['provider-prefix'] || args.prefix || apiConfig.providerName).toString().trim() || apiConfig.providerName;
-
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速 Claude 节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-      if (speedResult.usedFallback) {
-        console.log(chalk.yellow(`\n⚠ 当前使用备用节点\n`));
-      }
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点（含备用）均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要写入默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    speedIntro: '📡 开始测速 Claude 节点...\n',
+    proceedMessage: '仍要写入默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   const config = ensureConfigStructure(readConfig(paths.openclawConfig) || {});
   const repairResult = applyConfigRepairsWithSync(config, paths);
@@ -4722,6 +4879,8 @@ async function presetClaude(paths, args = {}) {
 
   const apiKeyEnvFallbacks = [
     'OPENCLAW_CLAUDE_KEY',
+    'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN',
     'CLAUDE_API_KEY',
     'OPENCLAW_API_KEY'
   ];
@@ -4853,48 +5012,16 @@ async function presetClaude(paths, args = {}) {
 }
 
 async function presetCodex(paths, args = {}) {
-  console.log(chalk.cyan.bold('\n🚀 Codex 快速配置（自动测速推荐节点）\n'));
+  console.log(chalk.cyan.bold('\n🚀 Codex 快速配置（默认节点直连）\n'));
 
   const apiConfig = API_CONFIG.codex;
   const providerPrefix = (args['provider-prefix'] || args.prefix || apiConfig.providerName).toString().trim() || apiConfig.providerName;
   const providerName = (args['provider-name'] || args.provider || providerPrefix).toString().trim() || apiConfig.providerName;
-
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速 Codex 节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-      if (speedResult.usedFallback) {
-        console.log(chalk.yellow(`\n⚠ 当前使用备用节点\n`));
-      }
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点（含备用）均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要写入默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    speedIntro: '📡 开始测速 Codex 节点...\n',
+    proceedMessage: '仍要写入默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   const config = ensureConfigStructure(readConfig(paths.openclawConfig) || {});
   const repairResult = applyConfigRepairsWithSync(config, paths);
@@ -5048,6 +5175,8 @@ async function autoActivate(paths, args = {}) {
   const apiKeyEnvFallbacks = [
     'OPENCLAW_CLAUDE_KEY',
     'OPENCLAW_CODEX_KEY',
+    'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN',
     'CLAUDE_API_KEY',
     'OPENAI_API_KEY',
     'OPENCLAW_API_KEY'
@@ -5258,40 +5387,10 @@ async function autoActivate(paths, args = {}) {
 async function activateClaudeCode(paths, args = {}) {
   console.log(chalk.cyan.bold('\n🔧 配置 Claude Code CLI\n'));
   const selectedModel = await promptClaudeModelSelection(args);
-
-  // ---- 测速选节点 ----
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要使用默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    proceedMessage: '仍要使用默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   // ---- API Key ----
   const directKey = (args['api-key'] || args.apiKey || args.key || '').toString().trim();
@@ -5299,7 +5398,7 @@ async function activateClaudeCode(paths, args = {}) {
   if (directKey) {
     apiKey = directKey;
   } else {
-    const envKey = process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '';
+    const envKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '';
     apiKey = await promptApiKey('请输入 API Key:', envKey);
   }
   if (!apiKey) { console.log(chalk.gray('已取消')); return; }
@@ -5327,7 +5426,7 @@ async function activateClaudeCode(paths, args = {}) {
   console.log(chalk.gray('   API Key: 已设置'));
   console.log(chalk.gray('\n   已写入:'));
   console.log(chalk.gray('   • ~/.claude/settings.json'));
-  console.log(chalk.gray('   • 最小字段: apiBaseUrl + env.ANTHROPIC_AUTH_TOKEN'));
+  console.log(chalk.gray('   • 最小字段: apiBaseUrl + env.ANTHROPIC_API_KEY + env.ANTHROPIC_BASE_URL'));
   console.log(chalk.yellow('\n   提示: 如果 Claude Code 已在运行，重新打开一个会话即可读取新配置'));
 
   if (await confirmImmediateTest(args, '是否立即测试 Claude Code CLI 连接？')) {
@@ -5339,40 +5438,10 @@ async function activateClaudeCode(paths, args = {}) {
 async function activateOpencode(paths, args = {}) {
   console.log(chalk.cyan.bold('\n🔧 配置 Opencode\n'));
   const defaultModel = await promptOpencodeDefaultModelSelection(args);
-
-  // ---- 测速选节点 ----
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要使用默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    proceedMessage: '仍要使用默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   // ---- API Key ----
   const directKey = (args['api-key'] || args.apiKey || args.key || '').toString().trim();
@@ -5380,7 +5449,7 @@ async function activateOpencode(paths, args = {}) {
   if (directKey) {
     apiKey = directKey;
   } else {
-    const envKey = process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '';
+    const envKey = process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_API_KEY || '';
     apiKey = await promptApiKey('请输入 API Key:', envKey);
   }
   if (!apiKey) { console.log(chalk.gray('已取消')); return; }
@@ -5436,39 +5505,10 @@ async function activateCodex(paths, args = {}) {
   }
   const modelConfig = CODEX_MODELS.find(m => m.id === modelId) || { id: modelId, name: modelId };
 
-  // ---- 测速选节点 ----
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要使用默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    proceedMessage: '仍要使用默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   // ---- API Key ----
   const directKey = (args['api-key'] || args.apiKey || args.key || '').toString().trim();
@@ -5518,39 +5558,10 @@ async function activateHermes(paths, args = {}) {
   const selection = await promptHermesModelSelection(args, '选择 Hermes 默认模型:');
   const selectedModel = selection.model;
   const selectedType = selection.type;
-
-  const shouldTest = !(args['no-test'] || args.noTest);
-  let selectedEndpoint = ENDPOINTS[0];
-
-  if (shouldTest) {
-    console.log(chalk.cyan('📡 开始测速节点...\n'));
-    const speedResult = await testAllEndpoints(ENDPOINTS, { autoFallback: true });
-    const sorted = speedResult.ranked || [];
-    if (sorted.length > 0) {
-      const defaultEp = ENDPOINTS[0];
-      const { selectedIndex } = await inquirer.prompt([{
-        type: 'list',
-        name: 'selectedIndex',
-        message: '选择节点:',
-        choices: [
-          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
-          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
-          ...sorted.map((e, i) => ({
-            name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
-            value: i
-          }))
-        ]
-      }]);
-      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
-    } else {
-      console.log(chalk.red('\n⚠️  所有节点均不可达'));
-      const { proceed } = await inquirer.prompt([{
-        type: 'confirm', name: 'proceed',
-        message: '仍要使用默认节点配置吗？', default: false
-      }]);
-      if (!proceed) { console.log(chalk.gray('已取消')); return; }
-    }
-  }
+  const selectedEndpoint = await resolveEndpointSelection(args, {
+    proceedMessage: '仍要使用默认节点配置吗？'
+  });
+  if (!selectedEndpoint) return;
 
   const directKey = (args['api-key'] || args.apiKey || args.key || '').toString().trim();
   let apiKey;
@@ -5592,8 +5603,12 @@ async function activateHermes(paths, args = {}) {
   if (hermesPaths.wslConfigPath && hermesPaths.wslEnvPath) {
     console.log(chalk.gray('   • 已额外同步到 WSL ~/.hermes'));
   }
-  console.log(chalk.yellow('\n   提示: Hermes Desktop 的“测试连接”按钮当前可能仍按 /v1/models 检测；按钮不绿，不代表 runtime 不能正常对话'));
-  console.log(chalk.yellow('   建议: 重启 Hermes Desktop，或手动执行 hermes server --port 8787 验证 Hermes runtime'));
+  console.log(chalk.yellow('\n   提示: Hermes doctor 当前会固定检查官方 Anthropic /v1/models，不会读取 model.base_url；第三方 Anthropic 中转可能被误报为 invalid API key'));
+  console.log(chalk.yellow('   建议: 以 yymaxapi 的 Hermes CLI 运行时测试，或 `hermes chat -Q -q "请只回复 OK"` 的结果为准'));
+
+  if (await confirmImmediateTest(args, '是否立即测试 Hermes CLI 连接？')) {
+    await testAdditionalCliConnections(args, { only: ['hermes'] });
+  }
 }
 
 // ============ 主程序 ============
@@ -5635,6 +5650,10 @@ async function main() {
     await testConnection(paths, args);
     return;
   }
+  if (args._.includes('speed-test') || args._.includes('speedtest')) {
+    await speedTestNodes();
+    return;
+  }
 
   while (true) {
     // 显示当前状态
@@ -5661,6 +5680,7 @@ async function main() {
         new inquirer.Separator('  -- 工具 --'),
         { name: '  切换 OpenClaw 模型', value: 'switch_model' },
         { name: `  权限管理${getToolsProfileTag(paths)}`, value: 'tools_profile' },
+        { name: '  测速节点', value: 'speed_test_nodes' },
         { name: '  测试连接', value: 'test_connection' },
         { name: '  查看配置', value: 'view_config' },
         { name: '  恢复默认', value: 'restore' },
@@ -5684,6 +5704,9 @@ async function main() {
         case 'test_connection':
           await testConnection(paths, {});
           break;
+        case 'speed_test_nodes':
+          await speedTestNodes();
+          break;
         case 'switch_model':
           await switchModel(paths);
           break;
@@ -6888,6 +6911,8 @@ function testGatewayViaAgent(model, agentId = '') {
       }
       const nodeInfo = findCompatibleNode(nodeMajor);
       const env = { ...process.env, PATH: extendPathEnv(nodeInfo ? nodeInfo.path : null), NODE_NO_WARNINGS: '1' };
+      delete env.ANTHROPIC_API_KEY;
+      delete env.ANTHROPIC_AUTH_TOKEN;
       delete env.CLAUDE_API_KEY;
       delete env.OPENCLAW_CLAUDE_KEY;
       delete env.OPENCLAW_API_KEY;

package/config/API/350/212/202/347/202/271/350/256/276/347/275/256.md

@@ -155,7 +155,8 @@ npx yymaxapi@latest
 {
   "apiBaseUrl": "https://yunyi.rdzhvip.com/claude",
   "env": {
-    "ANTHROPIC_AUTH_TOKEN": "<你的云翼 API Key>"
+    "ANTHROPIC_API_KEY": "<你的云翼 API Key>",
+    "ANTHROPIC_BASE_URL": "https://yunyi.rdzhvip.com/claude"
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yymaxapi",
-  "version": "1.0.104",
+  "version": "1.0.108",
   "description": "跨平台 OpenClaw/Clawdbot 配置管理工具 - 管理中转地址、模型切换、API Keys、测速优化",
   "main": "bin/yymaxapi.js",
   "bin": {