gpteam 0.1.9 → 0.1.12

package/README.md

@@ -6,11 +6,15 @@ Interactive GPTeam API client configurator.
 npx gpteam
 ```
 
-The CLI asks for an API key, validates it with `/v1/models`, detects available models, benchmarks all production ingress endpoints with real API requests, then backs up old files and writes the selected client configuration. The next steps are blocked until the key validation succeeds. Ingress endpoints are benchmarked in parallel, while rounds for the same endpoint remain sequential to keep real API request pressure bounded. Failed benchmark rows show their error reason in the result table.
+The CLI asks for an API key, validates it with `/v1/models`, checks whether the selected client command is installed, detects available models, benchmarks all production ingress endpoints with real API requests, then backs up old files and writes the selected client configuration. The next steps are blocked until the key validation succeeds. Client detection runs before model selection and benchmarking, so a missing local client does not waste API probes.
+
+When a selected client is missing, the interactive CLI shows the exact install command and asks before running it. `--install-client` skips that confirmation for scripted setup. Codex, Claude Code, OpenCode, and OpenClaw use npm-based install commands; OpenCode uses the current `opencode-ai` package. Windows is blocked for OpenClaw because GPTeam's OpenClaw config writer currently supports macOS and Linux only.
 
 Recommendation order is deterministic: success rate first, then an experience score. The score weighs first SSE event time, total completion time, p90 completion tail latency, and health-check time, so a node with one very slow probe is not recommended just because its median result looks good. The result table also marks the fastest full completion separately from the balanced recommendation, because deep or long-output model runs may care more about full completion time than first-token responsiveness. Model prompts use "configurable context" wording because the value is written to the client-side Codex `model_context_window`; it must not be confused with a public marketing total-window label.
 
-Codex config writing follows the same safety pattern as cc-switch: keep top-level fields separate from provider tables, preserve unrelated sections such as MCP servers, and stop before writing if the generated TOML would contain duplicate keys.
+Client config writing follows the same safety pattern as cc-switch: keep Codex top-level fields separate from provider tables, preserve unrelated sections such as MCP servers, merge OpenCode/OpenClaw providers additively, and stop before writing when an existing JSON/JSON5 config cannot be parsed. GPTeam keeps two proxy-specific extensions on top of that baseline: Codex explicitly disables WebSocket prewarm, and Claude Code writes the reasoning-effort header through `ANTHROPIC_CUSTOM_HEADERS`.
+
+Claude Code is written to `~/.claude/settings.json` under the `env` section, using the GPTeam `/anthropic` base URL. OpenClaw writes `models.providers.gpteam` and also selects `gpteam/<model>` under `agents.defaults.model`, so the chosen model is active without an extra manual step.
 
 Supported clients:
 
@@ -25,3 +29,5 @@ Useful non-interactive smoke checks:
 npx gpteam --help
 npx gpteam --version
 ```
+
+`--install-client` is for scripted setup after you also provide the usual non-interactive inputs such as `--api-key`, `--client`, `--model`, and `--node`.

package/lib/cli.js

@@ -1,6 +1,7 @@
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import { benchmarkNodes, formatMs } from './bench.js';
+import { ensureClientInstalled, formatInstallCommand } from './client-install.js';
 import { CLIENTS, writeClientConfig } from './config.js';
 import { getHelpText, PACKAGE_NAME, PACKAGE_VERSION } from './help.js';
 import { modelByID, validateApiKey } from './models.js';
@@ -30,6 +31,7 @@ export async function runCli(argv = []) {
 
     printStep(theme, 2, 5, '选择客户端和模型');
     const client = await choose(rl, '请选择客户端类型', CLIENTS, args.client, theme);
+    await ensureSelectedClientInstalled(client.id, args, rl, theme);
     const models = validation.models;
     const model = await chooseModel(rl, models, args.model, theme);
     const contextLength = await askContextLength(rl, model, args.context);
@@ -251,6 +253,34 @@ function printStatus(theme, label, detail) {
   console.log(`${theme.ok(`[${label}]`)} ${detail}`);
 }
 
+async function ensureSelectedClientInstalled(clientID, args, rl, theme) {
+  const result = await ensureClientInstalled(clientID, {
+    autoInstall: cliFlagEnabled(args.installClient) || cliFlagEnabled(args.yes) || cliFlagEnabled(args.y),
+    confirmInstall: shouldPromptForInstall() ? (spec) => confirmClientInstall(rl, spec, theme) : undefined
+  });
+  if (result.status === 'installed') {
+    printStatus(theme, '已检测', `${result.spec.label} 命令可用：${result.spec.command}`);
+  } else {
+    printStatus(theme, '已安装', `${result.spec.label} 安装完成。`);
+  }
+}
+
+async function confirmClientInstall(rl, spec, theme) {
+  printStatus(theme, '未检测到', `${spec.label} 命令 ${spec.command}`);
+  printHint(theme, `将执行安装命令：${formatInstallCommand(spec)}`);
+  printHint(theme, `安装后会继续配置，可用 ${spec.versionHint} 自检版本。`);
+  const answer = await rl.question('现在安装吗？输入 y 继续，其他输入停止：');
+  return ['y', 'yes'].includes(answer.trim().toLowerCase());
+}
+
+function shouldPromptForInstall() {
+  return Boolean(input.isTTY && output.isTTY);
+}
+
+function cliFlagEnabled(value) {
+  return value === true || ['1', 'true', 'yes', 'y'].includes(String(value || '').toLowerCase());
+}
+
 function toCamel(value) {
   return value.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
 }

package/lib/client-install.js

@@ -0,0 +1,105 @@
+import { spawn } from 'node:child_process';
+
+export const CLIENT_INSTALL_SPECS = {
+  codex: {
+    id: 'codex',
+    label: 'Codex',
+    command: 'codex',
+    installCommand: ['npm', ['i', '-g', '@openai/codex@latest']],
+    versionHint: 'codex --version'
+  },
+  opencode: {
+    id: 'opencode',
+    label: 'OpenCode',
+    command: 'opencode',
+    installCommand: ['npm', ['i', '-g', 'opencode-ai@latest']],
+    versionHint: 'opencode --version'
+  },
+  'claude-code': {
+    id: 'claude-code',
+    label: 'Claude Code',
+    command: 'claude',
+    installCommand: ['npm', ['i', '-g', '@anthropic-ai/claude-code@latest']],
+    versionHint: 'claude --version'
+  },
+  openclaw: {
+    id: 'openclaw',
+    label: 'OpenClaw',
+    command: 'openclaw',
+    installCommand: ['npm', ['i', '-g', 'openclaw@latest']],
+    versionHint: 'openclaw --version',
+    windowsUnsupported: true
+  }
+};
+
+export function resolveClientInstallSpec(clientID) {
+  const spec = CLIENT_INSTALL_SPECS[clientID];
+  if (!spec) throw new Error(`未知客户端：${clientID}`);
+  return spec;
+}
+
+export async function ensureClientInstalled(clientID, options = {}) {
+  const spec = resolveClientInstallSpec(clientID);
+  const platform = options.platform || process.platform;
+  if (spec.windowsUnsupported && platform === 'win32') {
+    throw new Error(`Windows 暂不支持自动安装或自动配置 ${spec.label}。请在 macOS / Linux 环境运行配置。`);
+  }
+
+  const commandExists = options.commandExists || defaultCommandExists;
+  if (await commandExists(spec.command)) return { status: 'installed', spec };
+
+  if (!await shouldInstallMissingClient(spec, options)) {
+    throw new Error(`未安装 ${spec.label}，已停止配置。安装后重新运行 npx gpteam。`);
+  }
+
+  await runInstallCommand(spec, options.runCommand || defaultRunCommand, platform);
+  if (!await commandExists(spec.command)) {
+    throw new Error(`安装完成但仍未检测到 ${spec.label} 命令 ${spec.command}。请检查 npm 全局 bin 是否在 PATH 中，然后运行 ${spec.versionHint}。`);
+  }
+  return { status: 'installed-after-run', spec };
+}
+
+export function formatInstallCommand(spec) {
+  return [spec.installCommand[0], ...spec.installCommand[1]].join(' ');
+}
+
+export async function defaultCommandExists(command) {
+  const checker = process.platform === 'win32' ? 'where' : 'sh';
+  const args = process.platform === 'win32' ? [command] : ['-c', `command -v ${shellQuote(command)}`];
+  const result = await defaultRunCommand(checker, args, { stdio: 'ignore' });
+  return result.status === 0;
+}
+
+async function shouldInstallMissingClient(spec, options) {
+  if (options.autoInstall) return true;
+  if (!options.confirmInstall) return false;
+  return options.confirmInstall(spec);
+}
+
+async function runInstallCommand(spec, runCommand, platform) {
+  const [command, args] = spec.installCommand;
+  const result = await runCommand(resolveSpawnCommand(command, platform), args, { stdio: 'inherit' });
+  if (result.status !== 0) {
+    throw new Error(`${spec.label} 安装失败，命令：${formatInstallCommand(spec)}`);
+  }
+}
+
+export function resolveSpawnCommand(command, platform = process.platform) {
+  if (platform === 'win32' && command === 'npm') return 'npm.cmd';
+  return command;
+}
+
+export function defaultRunCommand(command, args, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      stdio: options.stdio || 'ignore',
+      shell: options.shell || false
+    });
+    child.on('error', () => resolve({ status: 127 }));
+    child.on('close', (status) => resolve({ status: status ?? 1 }));
+  });
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}

package/lib/config.js

@@ -1,8 +1,11 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import JSON5 from 'json5';
 import { endpointRoot } from './nodes.js';
 
+const PROVIDER_ID = 'gpteam';
+
 export const CLIENTS = [
   { id: 'codex', label: 'Codex' },
   { id: 'opencode', label: 'OpenCode' },
@@ -13,13 +16,13 @@ export const CLIENTS = [
 export function writeClientConfig(clientID, settings) {
   if (clientID === 'codex') return writeCodexConfig(settings);
   if (clientID === 'opencode') return writeOpenCodeConfig(settings);
-  if (clientID === 'claude-code') return writeClaudeCodeEnv(settings);
+  if (clientID === 'claude-code') return writeClaudeCodeConfig(settings);
   if (clientID === 'openclaw') return writeOpenClawConfig(settings);
   throw new Error(`未知客户端：${clientID}`);
 }
 
 export function writeCodexConfig(settings) {
-  const dir = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  const dir = process.env.CODEX_HOME || path.join(homeDir(), '.codex');
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
   const configPath = path.join(dir, 'config.toml');
   const authPath = path.join(dir, 'auth.json');
@@ -56,17 +59,19 @@ export function writeCodexConfig(settings) {
 }
 
 export function writeOpenCodeConfig(settings) {
-  const dir = path.join(os.homedir(), '.config', 'opencode');
+  const dir = path.join(homeDir(), '.config', 'opencode');
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
   const filePath = path.join(dir, 'opencode.json');
   backupIfExists(filePath);
   const config = readJSON(filePath, { $schema: 'https://opencode.ai/config.json' });
   config.provider = config.provider && typeof config.provider === 'object' ? config.provider : {};
-  config.provider.gpteam = {
+  config.provider[PROVIDER_ID] = {
     npm: '@ai-sdk/openai',
+    name: 'GPTeam',
     options: {
       apiKey: settings.apiKey,
-      baseURL: settings.node.baseUrl
+      baseURL: settings.node.baseUrl,
+      setCacheKey: true
     },
     models: {
       [settings.model]: {
@@ -78,7 +83,7 @@ export function writeOpenCodeConfig(settings) {
         variants: {
           [settings.effort]: {
             reasoningEffort: settings.effort,
-            reasoningSummary: settings.effort === 'high' || settings.effort === 'xhigh' ? 'detailed' : 'auto',
+            reasoningSummary: 'auto',
             textVerbosity: 'medium'
           }
         }
@@ -89,30 +94,33 @@ export function writeOpenCodeConfig(settings) {
   return [filePath];
 }
 
-export function writeClaudeCodeEnv(settings) {
-  const dir = path.join(os.homedir(), '.gpteam');
+export function writeClaudeCodeConfig(settings) {
+  const dir = path.join(homeDir(), '.claude');
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-  const filePath = path.join(dir, 'claude-code.env');
+  const filePath = claudeSettingsPath(dir);
   backupIfExists(filePath);
-  const root = endpointRoot(settings.node.baseUrl);
-  const lines = [
-    '# GPTeam Claude Code environment.',
-    `export ANTHROPIC_AUTH_TOKEN=${shellQuote(settings.apiKey)}`,
-    `export ANTHROPIC_BASE_URL=${shellQuote(root)}`,
-    `export ANTHROPIC_MODEL=${shellQuote(settings.model)}`,
-    `export CODEX_REASONING_EFFORT=${shellQuote(settings.effort)}`,
-    '',
-    '# 使用方式：source ~/.gpteam/claude-code.env'
-  ];
-  writeTextAtomic(filePath, `${lines.join('\n')}\n`, 0o600);
+  const config = readJSON(filePath, {});
+  config.env = config.env && typeof config.env === 'object' ? config.env : {};
+  Object.assign(config.env, {
+    ANTHROPIC_AUTH_TOKEN: settings.apiKey,
+    ANTHROPIC_BASE_URL: claudeBaseUrl(settings.node.baseUrl),
+    ANTHROPIC_MODEL: settings.model,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: settings.model,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: settings.model,
+    ANTHROPIC_DEFAULT_OPUS_MODEL: settings.model,
+    ANTHROPIC_CUSTOM_HEADERS: `X-Codex-Reasoning-Effort: ${settings.effort}`
+  });
+  writeJSON(filePath, config);
   return [filePath];
 }
 
+export const writeClaudeCodeEnv = writeClaudeCodeConfig;
+
 export function writeOpenClawConfig(settings) {
   if (process.platform === 'win32') {
     throw new Error('OpenClaw 自动配置当前只支持 macOS / Linux');
   }
-  const dir = path.join(os.homedir(), '.openclaw');
+  const dir = path.join(homeDir(), '.openclaw');
   fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
   const filePath = path.join(dir, 'openclaw.json');
   backupIfExists(filePath);
@@ -122,7 +130,7 @@ export function writeOpenClawConfig(settings) {
   config.models.providers = config.models.providers && typeof config.models.providers === 'object'
     ? config.models.providers
     : {};
-  config.models.providers.gpteam = {
+  config.models.providers[PROVIDER_ID] = {
     baseUrl: settings.node.baseUrl,
     apiKey: settings.apiKey,
     api: 'openai-responses',
@@ -134,10 +142,43 @@ export function writeOpenClawConfig(settings) {
       maxTokens: Number(settings.maxOutputTokens)
     }]
   };
+  config.agents = config.agents && typeof config.agents === 'object' ? config.agents : {};
+  config.agents.defaults = config.agents.defaults && typeof config.agents.defaults === 'object'
+    ? config.agents.defaults
+    : {};
+  const qualifiedModel = `${PROVIDER_ID}/${settings.model}`;
+  config.agents.defaults.model = {
+    primary: qualifiedModel,
+    fallbacks: []
+  };
+  config.agents.defaults.models = config.agents.defaults.models && typeof config.agents.defaults.models === 'object'
+    ? config.agents.defaults.models
+    : {};
+  config.agents.defaults.models[qualifiedModel] = {
+    alias: settings.model
+  };
   writeJSON(filePath, config);
   return [filePath];
 }
 
+function homeDir() {
+  return process.env.GPTEAM_CONFIG_TEST_HOME || os.homedir();
+}
+
+function claudeSettingsPath(dir) {
+  const settings = path.join(dir, 'settings.json');
+  if (fs.existsSync(settings)) return settings;
+  const legacy = path.join(dir, 'claude.json');
+  if (fs.existsSync(legacy)) return legacy;
+  return settings;
+}
+
+function claudeBaseUrl(baseUrl) {
+  const root = endpointRoot(baseUrl);
+  if (/\/anthropic\/?$/.test(root)) return root.replace(/\/$/, '');
+  return `${root}/anthropic`;
+}
+
 function stripCodexManagedConfig(raw) {
   const rootLines = [];
   const rest = [];
@@ -236,9 +277,9 @@ function writeTextAtomic(filePath, text, mode) {
 function readJSON(filePath, fallback) {
   if (!fs.existsSync(filePath)) return fallback;
   try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    return fallback;
+    return JSON5.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (error) {
+    throw new Error(`无法解析配置文件 ${filePath}：${error.message}。为避免覆盖旧配置，已停止写入`);
   }
 }
 
@@ -249,7 +290,3 @@ function writeJSON(filePath, value) {
 function tomlString(value) {
   return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
 }
-
-function shellQuote(value) {
-  return `'${String(value).replace(/'/g, `'\\''`)}'`;
-}

package/lib/help.js

@@ -1,5 +1,5 @@
 export const PACKAGE_NAME = 'gpteam';
-export const PACKAGE_VERSION = '0.1.9';
+export const PACKAGE_VERSION = '0.1.12';
 
 export function getHelpText() {
   return [
@@ -18,9 +18,10 @@ export function getHelpText() {
     '  --node <id>              jp-direct / jp-split / hk-split / us-split',
     '  --rounds <n>             每个入口测速轮数，默认 3',
     '  --max-output-tokens <n>  测速输出上限，默认 648',
+    '  --install-client         客户端命令缺失时直接安装，不再二次确认',
     '  --help                  显示帮助',
     '  --version               显示版本',
     '',
-    '说明：输入 key 后会先请求 /v1/models 校验，通过后才继续。测速会请求 GET /api/health 和流式 POST /v1/responses。入口之间并行测速，写新配置前会先备份旧配置。'
+    '说明：输入 key 后会先请求 /v1/models 校验，通过后才继续。选好客户端后会检测本机命令是否可用，缺失时提示安装；Windows 暂不支持自动配置 OpenClaw。测速会请求 GET /api/health 和流式 POST /v1/responses。入口之间并行测速，写新配置前会先备份旧配置。'
   ].join('\n');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gpteam",
-  "version": "0.1.9",
+  "version": "0.1.12",
   "description": "GPTeam API interactive client configurator and ingress benchmark CLI.",
   "type": "module",
   "bin": {
@@ -14,6 +14,9 @@
   "scripts": {
     "test": "node --test test/*.test.mjs"
   },
+  "dependencies": {
+    "json5": "^2.2.3"
+  },
   "engines": {
     "node": ">=18.18.0"
   },