yingclaw 1.7.8 → 1.8.1

package/README.md

@@ -22,18 +22,43 @@ claw install-claude
 ```
 根据提示选择网络环境（有梯子走官方，没梯子走淘宝镜像）。
 
-**第二步：配置国产模型 API**
+**第二步：配置 API 连接**
 ```bash
-claw setup
+claw config
+```
+选择厂商 → 输入 API Key → 选择模型。这个步骤只保存 API 连接，不会修改终端环境变量，也不会修改 Claude 桌面应用配置。
+
+**第三步：选择接入目标**
+
+接入 Claude Code 终端：
+```bash
+claw code
 ```
-选择厂商 → 输入 API Key → 选择模型，自动写入环境变量，配置完成后自动启动 Claude。
+写入 Claude Code 所需的环境变量。配置完成后不会自动启动 Claude Code，需要时可在主菜单选择“启动 Claude Code”或直接运行 `claude`。
 
-**可选：配置 Claude 桌面应用**
+接入 Claude 桌面应用：
 ```bash
 claw desktop
 ```
-将当前模型配置写入 Claude Desktop 的第三方推理（Cowork on 3P）本地配置。配置后需要完全退出并重新打开 Claude 桌面应用。
-macOS 会询问是否自动重启 Claude 桌面应用；Windows 需要手动重新打开。
+将当前模型配置写入 Claude Desktop 的第三方推理（Cowork on 3P）本地配置。macOS 会询问是否立即打开 Claude 桌面应用；Windows 需要手动打开。如果配置未生效，请完全退出 Claude Desktop 后重新打开。
+
+恢复 Claude Code 终端默认配置：
+```bash
+claw code-reset
+```
+只清除 Claude Code 终端环境变量，不影响 API 连接和 Claude 桌面配置。
+
+恢复 Claude 桌面应用默认配置：
+```bash
+claw desktop-reset
+```
+只清除 Claude Desktop 第三方推理配置，不影响终端里的 API Key 和模型配置。
+
+兼容旧命令：
+```bash
+claw setup
+```
+等价于 `claw config` + `claw code`，用于一键配置 API 并接入 Claude Code 终端。
 
 选择“自定义 Anthropic 兼容接口”时，需要输入：
 
@@ -44,7 +69,7 @@ macOS 会询问是否自动重启 Claude 桌面应用；Windows 需要手动重
 
 注意：模型列表能获取不代表一定可用于 Claude Code 或 Claude 桌面应用。自定义接口还必须支持 Anthropic `/v1/messages`，否则请求会被网关拒绝。Claude 桌面应用的 Gateway Base URL 还必须使用 HTTPS。
 
-**第三步：以后直接用**
+**以后直接用**
 ```bash
 claude
 ```
@@ -64,10 +89,15 @@ claude
 ## 其他命令
 
 ```bash
-claw switch   # 快速切换模型（无需重新输入 Key）
-claw desktop  # 配置 Claude 桌面应用第三方推理
-claw status   # 查看当前配置，验证 Key 是否有效
-claw reset    # 清除配置和环境变量
+claw config        # 配置 API 连接，不修改终端或桌面
+claw code          # 接入 Claude Code 终端
+claw code-reset    # 恢复 Claude Code 终端默认配置
+claw switch        # 快速切换模型（只更新 API 连接）
+claw desktop       # 接入 Claude 桌面应用第三方推理
+claw desktop-reset # 恢复 Claude 桌面应用默认配置
+claw setup         # 兼容旧命令：config + code
+claw status        # 查看当前配置，验证 Key 是否有效
+claw reset         # 清除 API 连接、终端环境变量和桌面配置
 ```
 
 ## 卸载
@@ -78,7 +108,7 @@ npm uninstall -g yingclaw
 
 ## 原理
 
-各厂商均原生支持 Anthropic API 格式。本工具会自动写入 Claude Code 所需的环境变量。macOS / Linux / WSL 写入 shell 配置文件，Windows 写入用户级环境变量，包括：
+各厂商均原生支持 Anthropic API 格式。`claw config` 只保存 API 连接；`claw code` 才会写入 Claude Code 所需的环境变量。macOS / Linux / WSL 写入 shell 配置文件，Windows 写入用户级环境变量，包括：
 
 - `ANTHROPIC_BASE_URL`
 - `ANTHROPIC_AUTH_TOKEN`

package/bin/cli.js

@@ -6,6 +6,7 @@ const {
   loadConfig,
   saveConfig,
   writeEnvToZshrc,
+  clearClaudeCodeEnv,
   fetchModels,
   fetchModelsFromBaseUrl,
   resetConfig,
@@ -20,7 +21,7 @@ const { execSync, spawn, spawnSync } = require('child_process');
 const pkg = require('../package.json');
 const { buildMenuStatusLines, buildStatusView } = require('../lib/panel');
 const { buildClaudeInstallCommand } = require('../lib/install');
-const { clearClaudeDesktopConfig, restartClaudeDesktop, writeClaudeDesktopConfig } = require('../lib/desktop');
+const { clearClaudeDesktopConfig, openClaudeDesktop, writeClaudeDesktopConfig } = require('../lib/desktop');
 
 const program = new Command();
 
@@ -109,8 +110,12 @@ function getStorageHint(file) {
   return `⚠ API Key 以明文存储在 ${file} 和 ~/.clawai.json`;
 }
 
-function getDesktopRestartHint() {
-  return '请完全退出 Claude 桌面应用后重新打开，第三方模型配置才会生效';
+function getDesktopOpenHint() {
+  return '请打开 Claude 桌面应用；如配置未生效，请完全退出后重新打开';
+}
+
+function getSavedConfigHint() {
+  return '⚠ API Key 以明文存储在 ~/.clawai.json';
 }
 
 async function promptModelFromChoices({ chalk, choices, message, backLabel = '↩  返回上一步', allowManual = true }) {
@@ -201,13 +206,13 @@ async function showStatus() {
   const config = loadConfig();
 
   if (!config) {
-    console.log(chalk.red('\n未配置，请先运行: claw setup\n'));
+    console.log(chalk.red('\n未配置，请先运行: claw config\n'));
     return;
   }
   const configProblem = getConfigValidationMessage(config);
   if (configProblem) {
     console.log(chalk.red(`\n配置无效：${configProblem}`));
-    console.log(chalk.dim('请运行 claw setup 重新配置。\n'));
+    console.log(chalk.dim('请运行 claw config 重新配置。\n'));
     return;
   }
 
@@ -257,6 +262,113 @@ async function showStatus() {
   }));
 }
 
+async function runConfigFlow({ writeCodeEnv = false } = {}) {
+  const chalk = (await import('chalk')).default;
+  const ora = (await import('ora')).default;
+  const boxen = (await import('boxen')).default;
+
+  console.log(await getBanner());
+
+  const existing = loadConfig();
+  if (existing) {
+    const existingProvider = PROVIDERS[existing.provider];
+    console.log(boxen(
+      chalk.bold('当前 API 连接\n\n') +
+      chalk.dim('厂商  ') + chalk.white(existingProvider?.name || existing.provider) + '\n' +
+      chalk.dim('模型  ') + chalk.yellow(existing.model) + '\n' +
+      chalk.dim('Key   ') + chalk.dim(existing.apiKey ? '已保存' : '缺失'),
+      { padding: { top: 0, bottom: 0, left: 2, right: 2 }, borderStyle: 'round', borderColor: 'yellow', margin: { top: 1, bottom: 1 } }
+    ));
+    const overwrite = await confirm({ message: '覆盖现有 API 连接？', default: false });
+    if (!overwrite) return;
+  }
+
+  let providerKey, provider, apiKey, model, customConfig;
+  let step = 'provider';
+
+  while (true) {
+    if (step === 'provider') {
+      providerKey = await select({ loop: false,
+        message: chalk.cyan('选择 AI 厂商'),
+        choices: [
+          ...Object.entries(PROVIDERS).map(([value, p]) => ({ name: p.name, value })),
+          { name: chalk.dim('↩  返回主菜单'), value: '__BACK__' },
+        ],
+      });
+      if (providerKey === '__BACK__') return;
+      provider = PROVIDERS[providerKey];
+      if (provider.custom) {
+        customConfig = await configureCustomProvider({ chalk, ora });
+        if (!customConfig) { step = 'provider'; continue; }
+        break;
+      }
+      step = 'apikey';
+    } else if (step === 'apikey') {
+      const k = await input({
+        message: chalk.cyan(`${provider.name} API Key（输入 b 返回上一步）`),
+        transformer: (v) => v && v !== 'b' ? chalk.dim('•'.repeat(v.length)) : v,
+        validate: (v) => v.trim().length > 0 ? true : 'API Key 不能为空',
+      });
+      if (k.trim() === 'b') { step = 'provider'; continue; }
+      apiKey = k.trim();
+      step = 'model';
+    } else if (step === 'model') {
+      const fetchSpinner = ora('正在获取可用模型...').start();
+      const onlineModels = await fetchModels(providerKey, apiKey);
+      let modelChoices;
+      if (onlineModels && onlineModels.length > 0) {
+        fetchSpinner.succeed(chalk.green(`已获取 ${onlineModels.length} 个可用模型`));
+        modelChoices = onlineModels.map(id => ({ name: id, value: id }));
+      } else {
+        fetchSpinner.warn(chalk.yellow('无法获取在线列表，使用内置默认列表'));
+        modelChoices = provider.models;
+      }
+
+      const m = await select({ loop: false,
+        message: chalk.cyan('选择模型'),
+        choices: [
+          ...modelChoices,
+          { name: chalk.dim('↩  返回上一步（重新输入 Key）'), value: '__BACK__' },
+        ],
+      });
+      if (m === '__BACK__') { step = 'apikey'; continue; }
+      model = m;
+      break;
+    }
+  }
+
+  const spinner = ora(writeCodeEnv ? '保存 API 连接并接入 Claude Code 终端...' : '保存 API 连接...').start();
+  let file;
+  let cfg;
+  try {
+    const fastModel = customConfig?.fastModel || resolveFastModel(provider, model);
+    cfg = customConfig || { provider: providerKey, model, fastModel, apiKey, baseUrl: provider.baseUrl };
+    saveConfig(cfg);
+    if (writeCodeEnv) {
+      ({ file } = writeEnvToZshrc(cfg.baseUrl, cfg.apiKey, cfg.model, cfg.fastModel));
+    }
+    spinner.succeed(chalk.green(writeCodeEnv ? 'API 连接已保存，Claude Code 终端已接入' : 'API 连接已保存'));
+  } catch (e) {
+    spinner.fail(chalk.red(`写入失败: ${e.message}`));
+    return;
+  }
+
+  console.log(chalk.dim(writeCodeEnv ? getStorageHint(file) : getSavedConfigHint()));
+
+  const nextStep = writeCodeEnv
+    ? chalk.white('需要启动时，在主菜单选择“启动 Claude Code”，或直接输入 ') + chalk.cyan.bold('claude') + '\n' + chalk.dim(getActivationHint(file))
+    : chalk.white('下一步可选择“接入 Claude Code 终端”或“接入 Claude 桌面应用”。');
+
+  console.log(boxen(
+    chalk.bold(writeCodeEnv ? 'Claude Code 终端配置完成！\n\n' : 'API 连接配置完成！\n\n') +
+    chalk.dim('Base URL  ') + chalk.cyan(cfg.baseUrl) + '\n' +
+    chalk.dim('API Key   ') + chalk.cyan('已保存') + '\n' +
+    chalk.dim('模型      ') + chalk.yellow(cfg.model) + '\n\n' +
+    nextStep,
+    { padding: { top: 0, bottom: 0, left: 2, right: 2 }, borderStyle: 'round', borderColor: 'green', margin: { top: 1, bottom: 1 } }
+  ));
+}
+
 program
   .name('claw')
   .description('Claude Code × 国产大模型一键接入')
@@ -318,14 +430,25 @@ program
 
     console.log(boxen(
       chalk.bold('下一步\n\n') +
-      chalk.cyan('  claw setup') + chalk.dim('  配置国产模型 API Key'),
+      chalk.cyan('  claw config') + chalk.dim('  配置 API 连接\n') +
+      chalk.cyan('  claw code') + chalk.dim('    接入 Claude Code 终端'),
       { padding: { top: 0, bottom: 0, left: 2, right: 2 }, borderStyle: 'round', borderColor: 'cyan', margin: { top: 1, bottom: 1 } }
     ));
   });
 
+program
+  .command('config')
+  .description('配置 API 连接（不修改终端或桌面）')
+  .action(() => runConfigFlow({ writeCodeEnv: false }));
+
 program
   .command('setup')
-  .description('配置 API Key 和模型')
+  .description('配置 API 并接入 Claude Code 终端（兼容旧命令）')
+  .action(() => runConfigFlow({ writeCodeEnv: true }));
+
+program
+  .command('code')
+  .description('接入 Claude Code 终端')
   .action(async () => {
     const chalk = (await import('chalk')).default;
     const ora = (await import('ora')).default;
@@ -333,112 +456,81 @@ program
 
     console.log(await getBanner());
 
-    // 已有配置时先展示，再询问
-    const existing = loadConfig();
-    if (existing) {
-      const existingProvider = PROVIDERS[existing.provider];
-      console.log(boxen(
-        chalk.bold('当前配置\n\n') +
-        chalk.dim('厂商  ') + chalk.white(existingProvider?.name || existing.provider) + '\n' +
-        chalk.dim('模型  ') + chalk.yellow(existing.model) + '\n' +
-        chalk.dim('Key   ') + chalk.dim(existing.apiKey ? '已保存' : '缺失'),
-        { padding: { top: 0, bottom: 0, left: 2, right: 2 }, borderStyle: 'round', borderColor: 'yellow', margin: { top: 1, bottom: 1 } }
-      ));
-      const overwrite = await confirm({ message: '覆盖现有配置？', default: false });
-      if (!overwrite) return;
+    const config = loadConfig();
+    if (!config) {
+      console.log(chalk.red('\n未配置 API 连接，请先运行: claw config\n'));
+      return;
     }
-
-    let providerKey, provider, apiKey, model, customConfig;
-    let step = 'provider';
-
-    while (true) {
-      if (step === 'provider') {
-        providerKey = await select({ loop: false,
-          message: chalk.cyan('选择 AI 厂商'),
-          choices: [
-            ...Object.entries(PROVIDERS).map(([value, p]) => ({ name: p.name, value })),
-            { name: chalk.dim('↩  返回主菜单'), value: '__BACK__' },
-          ],
-        });
-        if (providerKey === '__BACK__') return;
-        provider = PROVIDERS[providerKey];
-        if (provider.custom) {
-          customConfig = await configureCustomProvider({ chalk, ora });
-          if (!customConfig) { step = 'provider'; continue; }
-          break;
-        }
-        step = 'apikey';
-      } else if (step === 'apikey') {
-        const k = await input({
-          message: chalk.cyan(`${provider.name} API Key（输入 b 返回上一步）`),
-          transformer: (v) => v && v !== 'b' ? chalk.dim('•'.repeat(v.length)) : v,
-          validate: (v) => v.trim().length > 0 ? true : 'API Key 不能为空',
-        });
-        if (k.trim() === 'b') { step = 'provider'; continue; }
-        apiKey = k.trim();
-        step = 'model';
-      } else if (step === 'model') {
-        const fetchSpinner = ora('正在获取可用模型...').start();
-        const onlineModels = await fetchModels(providerKey, apiKey);
-        let modelChoices;
-        if (onlineModels && onlineModels.length > 0) {
-          fetchSpinner.succeed(chalk.green(`已获取 ${onlineModels.length} 个可用模型`));
-          modelChoices = onlineModels.map(id => ({ name: id, value: id }));
-        } else {
-          fetchSpinner.warn(chalk.yellow('无法获取在线列表，使用内置默认列表'));
-          modelChoices = provider.models;
-        }
-
-        const m = await select({ loop: false,
-          message: chalk.cyan('选择模型'),
-          choices: [
-            ...modelChoices,
-            { name: chalk.dim('↩  返回上一步（重新输入 Key）'), value: '__BACK__' },
-          ],
-        });
-        if (m === '__BACK__') { step = 'apikey'; continue; }
-        model = m;
-        break;
-      }
+    const configProblem = getConfigValidationMessage(config);
+    if (configProblem) {
+      console.log(chalk.red(`\n配置无效：${configProblem}`));
+      console.log(chalk.dim('请运行 claw config 重新配置。\n'));
+      return;
     }
 
-    const spinner = ora('写入配置...').start();
-    let result, file;
+    const spinner = ora('写入 Claude Code 终端环境变量...').start();
+    let file;
     try {
-      const fastModel = customConfig?.fastModel || resolveFastModel(provider, model);
-      const cfg = customConfig || { provider: providerKey, model, fastModel, apiKey, baseUrl: provider.baseUrl };
-      saveConfig(cfg);
-      ({ result, file } = writeEnvToZshrc(cfg.baseUrl, cfg.apiKey, cfg.model, cfg.fastModel));
-      spinner.succeed(chalk.green(result === 'updated' ? `环境变量已更新 → ${file}` : `环境变量已写入 → ${file}`));
+      ({ file } = writeEnvToZshrc(config.baseUrl, config.apiKey, config.model, config.fastModel));
+      spinner.succeed(chalk.green(`Claude Code 终端已接入 → ${file}`));
     } catch (e) {
       spinner.fail(chalk.red(`写入失败: ${e.message}`));
       return;
     }
-    console.log(chalk.dim(getStorageHint(file)));
 
+    console.log(chalk.dim(getStorageHint(file)));
     console.log(boxen(
-      chalk.bold('配置完成！\n\n') +
-      chalk.dim('ANTHROPIC_BASE_URL  ') + chalk.cyan((customConfig || { baseUrl: provider.baseUrl }).baseUrl) + '\n' +
-      chalk.dim('ANTHROPIC_API_KEY   ') + chalk.cyan('已保存') + '\n\n' +
-      chalk.white('下次直接输入 ') + chalk.cyan.bold('claude') + chalk.white(' 即可使用'),
+      chalk.bold('Claude Code 终端已接入\n\n') +
+      chalk.dim('Base URL  ') + chalk.cyan(config.baseUrl) + '\n' +
+      chalk.dim('模型      ') + chalk.yellow(config.model) + '\n\n' +
+      chalk.white('需要启动时，在主菜单选择“启动 Claude Code”，或直接输入 ') + chalk.cyan.bold('claude') + '\n' +
+      chalk.dim(getActivationHint(file)),
       { padding: { top: 0, bottom: 0, left: 2, right: 2 }, borderStyle: 'round', borderColor: 'green', margin: { top: 1, bottom: 1 } }
     ));
+  });
 
-    const launchSpinner = ora('正在启动 Claude Code...').start();
-    await new Promise(r => setTimeout(r, 500));
-    launchSpinner.stop();
+program
+  .command('code-reset')
+  .description('恢复 Claude Code 终端默认配置')
+  .action(async () => {
+    const chalk = (await import('chalk')).default;
+    const ora = (await import('ora')).default;
+    const boxen = (await import('boxen')).default;
+
+    console.log(await getBanner());
 
-    spawn('claude', [], {
-      stdio: 'inherit',
-      env: { ...process.env, ...buildClaudeEnv(customConfig || { provider: providerKey, baseUrl: provider.baseUrl, apiKey, model, fastModel: resolveFastModel(provider, model) }) },
-    }).on('error', () => {
-      console.log(chalk.yellow('\nClaude Code 未找到，请先运行: claw install-claude'));
+    const yes = await confirm({
+      message: chalk.red('确定要恢复 Claude Code 终端默认配置吗？API 连接和桌面配置不会被清除'),
+      default: false,
     });
+    if (!yes) {
+      console.log(chalk.dim('已取消'));
+      return;
+    }
+
+    const spinner = ora('正在恢复 Claude Code 终端默认配置...').start();
+    const cleared = clearClaudeCodeEnv();
+    await new Promise(r => setTimeout(r, 300));
+
+    if (cleared.length === 0) {
+      spinner.warn(chalk.yellow('没有找到 Claude Code 终端环境变量，无需恢复'));
+    } else {
+      spinner.succeed(chalk.green('Claude Code 终端已恢复默认'));
+      const resetNote = cleared.includes('Windows 用户环境变量')
+        ? '注：当前终端的环境变量还在内存中，重新打开 PowerShell / CMD 后才彻底清除'
+        : '注：当前终端的环境变量还在内存中，重开终端或 unset 才彻底清除';
+      console.log(boxen(
+        chalk.bold('已清除以下位置中的 Claude Code 终端环境变量：\n\n') +
+        cleared.map(f => chalk.cyan('  • ' + f)).join('\n') +
+        '\n\n' + chalk.dim(resetNote),
+        { padding: { top: 0, bottom: 0, left: 2, right: 2 }, borderStyle: 'round', borderColor: 'green', margin: { top: 1, bottom: 1 } }
+      ));
+    }
   });
 
 program
   .command('switch')
-  .description('快速切换模型（无需重新输入 Key）')
+  .description('快速切换模型（只更新 API 连接）')
   .action(async () => {
     const chalk = (await import('chalk')).default;
     const ora = (await import('ora')).default;
@@ -447,13 +539,13 @@ program
 
     const config = loadConfig();
     if (!config) {
-      console.log(chalk.red('\n未配置，请先运行: claw setup\n'));
+      console.log(chalk.red('\n未配置，请先运行: claw config\n'));
       return;
     }
     const configProblem = getConfigValidationMessage(config);
     if (configProblem) {
       console.log(chalk.red(`\n配置无效：${configProblem}`));
-      console.log(chalk.dim('请运行 claw setup 重新配置。\n'));
+      console.log(chalk.dim('请运行 claw config 重新配置。\n'));
       return;
     }
 
@@ -473,10 +565,9 @@ program
 
       const spinner = ora('切换中...').start();
       saveConfig(customConfig);
-      const { file } = writeEnvToZshrc(customConfig.baseUrl, customConfig.apiKey, customConfig.model, customConfig.fastModel);
       await new Promise(r => setTimeout(r, 300));
-      spinner.succeed(chalk.green(`已切换至 ${customConfig.providerName} · ${customConfig.model}`));
-      console.log(chalk.dim(getActivationHint(file)));
+      spinner.succeed(chalk.green(`API 连接已切换至 ${customConfig.providerName} · ${customConfig.model}`));
+      console.log(chalk.dim('如需让外部 claude 命令使用新模型，请运行 claw code。'));
       return;
     }
 
@@ -519,10 +610,9 @@ program
     const fastModel = resolveFastModel(provider, model);
     const newConfig = { ...config, provider: providerKey, model, fastModel, baseUrl: provider.baseUrl, apiKey };
     saveConfig(newConfig);
-    const { file } = writeEnvToZshrc(provider.baseUrl, apiKey, model, fastModel);
     await new Promise(r => setTimeout(r, 300));
-    spinner.succeed(chalk.green(`已切换至 ${provider.name} · ${model}`));
-    console.log(chalk.dim(getActivationHint(file)));
+    spinner.succeed(chalk.green(`API 连接已切换至 ${provider.name} · ${model}`));
+    console.log(chalk.dim('如需让外部 claude 命令使用新模型，请运行 claw code。'));
   });
 
 program
@@ -532,7 +622,7 @@ program
 
 program
   .command('desktop')
-  .description('配置 Claude 桌面应用使用当前模型')
+  .description('接入 Claude 桌面应用使用当前模型')
   .action(async () => {
     const chalk = (await import('chalk')).default;
     const ora = (await import('ora')).default;
@@ -542,13 +632,13 @@ program
 
     const config = loadConfig();
     if (!config) {
-      console.log(chalk.red('\n未配置，请先运行: claw setup\n'));
+      console.log(chalk.red('\n未配置 API 连接，请先运行: claw config\n'));
       return;
     }
     const configProblem = getConfigValidationMessage(config);
     if (configProblem) {
       console.log(chalk.red(`\n配置无效：${configProblem}`));
-      console.log(chalk.dim('请运行 claw setup 重新配置。\n'));
+      console.log(chalk.dim('请运行 claw config 重新配置。\n'));
       return;
     }
 
@@ -576,31 +666,72 @@ program
       chalk.dim('Base URL  ') + chalk.cyan(config.baseUrl) + '\n' +
       chalk.dim('模型      ') + chalk.yellow(config.model) + '\n' +
       chalk.dim('认证方式  ') + chalk.cyan('bearer') + '\n\n' +
-      chalk.yellow(getDesktopRestartHint()) + '\n' +
+      chalk.yellow(getDesktopOpenHint()) + '\n' +
       chalk.dim('要求：网关必须支持 Anthropic POST /v1/messages，且 Base URL 必须是 HTTPS。'),
       { padding: { top: 0, bottom: 0, left: 2, right: 2 }, borderStyle: 'round', borderColor: 'cyan', margin: { top: 1, bottom: 1 } }
     ));
 
     if (process.platform === 'darwin') {
-      const shouldRestart = await confirm({ message: '是否自动重启 Claude 桌面应用？', default: false });
-      if (shouldRestart) {
-        const restartSpinner = ora('正在重启 Claude 桌面应用...').start();
+      const shouldOpen = await confirm({ message: '是否现在打开 Claude 桌面应用？', default: true });
+      if (shouldOpen) {
+        const openSpinner = ora('正在打开 Claude 桌面应用...').start();
         try {
-          await restartClaudeDesktop();
-          restartSpinner.succeed(chalk.green('Claude 桌面应用已重新打开'));
+          await openClaudeDesktop();
+          openSpinner.succeed(chalk.green('Claude 桌面应用已重新打开（旧实例已退出，新配置生效）'));
         } catch (e) {
-          restartSpinner.fail(chalk.red(`重启失败: ${e.message}`));
-          console.log(chalk.dim(getDesktopRestartHint()));
+          openSpinner.fail(chalk.red(`打开失败: ${e.message}`));
+          console.log(chalk.dim(getDesktopOpenHint()));
         }
       }
     } else {
-      console.log(chalk.dim(getDesktopRestartHint()));
+      console.log(chalk.dim(getDesktopOpenHint()));
+    }
+  });
+
+program
+  .command('desktop-reset')
+  .description('恢复 Claude 桌面应用默认配置')
+  .action(async () => {
+    const chalk = (await import('chalk')).default;
+    const ora = (await import('ora')).default;
+    const boxen = (await import('boxen')).default;
+
+    console.log(await getBanner());
+
+    if (process.platform !== 'darwin' && process.platform !== 'win32') {
+      console.log(chalk.yellow('\nClaude 桌面应用 3P 配置目前仅支持 macOS / Windows。\n'));
+      return;
+    }
+
+    const yes = await confirm({
+      message: chalk.red('确定要恢复 Claude 桌面应用默认配置吗？终端配置不会被清除'),
+      default: false,
+    });
+    if (!yes) {
+      console.log(chalk.dim('已取消'));
+      return;
+    }
+
+    const spinner = ora('正在恢复 Claude 桌面应用默认配置...').start();
+    const result = clearClaudeDesktopConfig();
+    await new Promise(r => setTimeout(r, 300));
+
+    if (result.result === 'updated') {
+      spinner.succeed(chalk.green('Claude 桌面应用已恢复默认'));
+      console.log(boxen(
+        chalk.bold('已清除 Claude 桌面应用第三方推理配置：\n\n') +
+        chalk.cyan('  • ' + result.file) +
+        '\n\n' + chalk.dim('如 Claude Desktop 已打开，请完全退出后重新打开。'),
+        { padding: { top: 0, bottom: 0, left: 2, right: 2 }, borderStyle: 'round', borderColor: 'green', margin: { top: 1, bottom: 1 } }
+      ));
+    } else {
+      spinner.warn(chalk.yellow('没有找到 Claude 桌面应用第三方推理配置，无需恢复'));
     }
   });
 
 program
   .command('reset')
-  .description('恢复默认（清除所有 clawai 配置）')
+  .description('清除 API 连接、终端环境变量和桌面配置')
   .action(async () => {
     const chalk = (await import('chalk')).default;
     const ora = (await import('ora')).default;
@@ -671,59 +802,113 @@ async function renderStatusBar(apiStatus) {
   return config ? `  ${cfgPart}` : `  ${claudeIcon} ${claudeText}    ${cfgPart}`;
 }
 
+// 缓存上次校验的 config 哈希和结果，避免每次回菜单都重检
+let lastCheckedHash = null;
+let lastCheckResult; // undefined / true / false / null
+
+function configHash(cfg) {
+  if (!cfg) return null;
+  return JSON.stringify({ p: cfg.provider, b: cfg.baseUrl, k: cfg.apiKey, m: cfg.model });
+}
+
+async function maybeCheckApi(config, forceRecheck) {
+  const hash = configHash(config);
+  if (!forceRecheck && hash === lastCheckedHash && lastCheckResult !== undefined) {
+    return lastCheckResult;
+  }
+  const result = await validateKey(config);
+  lastCheckedHash = hash;
+  lastCheckResult = result;
+  return result;
+}
+
+const ADVANCED_DISABLED_HINT = '需先配置 API 连接';
+
+async function runAdvancedMenu(chalk, hasConfig) {
+  const action = await select({ loop: false,
+    message: chalk.cyan('高级选项'),
+    choices: [
+      { name: '🔁 重新检测 API', value: 'recheck', disabled: !hasConfig && ADVANCED_DISABLED_HINT },
+      { name: '↩️  恢复 Claude Code 终端默认', value: 'code-reset' },
+      { name: '↩️  恢复 Claude 桌面默认', value: 'desktop-reset' },
+      { name: '🗑  清除所有 yingclaw 配置', value: 'reset' },
+      { name: chalk.dim('↩  返回主菜单'), value: '__BACK__' },
+    ],
+  });
+  return action;
+}
+
 async function runMenu() {
   const chalk = (await import('chalk')).default;
   const ora = (await import('ora')).default;
 
+  let forceRecheck = false;
+
   while (true) {
     console.clear();
     console.log(await getBanner());
 
     const config = loadConfig();
-    let apiStatus; // undefined = skipped, true/false/null = checked
     const configProblem = config ? getConfigValidationMessage(config) : null;
+    let apiStatus;
+
     if (config && !configProblem) {
-      const spinner = ora('正在检测 API 是否通畅...').start();
-      apiStatus = await validateKey(config);
-      if (apiStatus === true) spinner.succeed('API 连接正常');
-      else if (apiStatus === false) spinner.fail('API Key 无效或已过期');
-      else spinner.warn('网络异常，无法连接 API');
+      const hash = configHash(config);
+      if (forceRecheck || hash !== lastCheckedHash || lastCheckResult === undefined) {
+        const spinner = ora('正在检测 API...').start();
+        apiStatus = await maybeCheckApi(config, true);
+        if (apiStatus === true) spinner.succeed('API 连接正常');
+        else if (apiStatus === false) spinner.fail('API Key 无效或已过期');
+        else spinner.warn('网络异常，无法连接 API');
+      } else {
+        apiStatus = lastCheckResult;
+      }
+      forceRecheck = false;
     }
 
     if (configProblem) {
       console.log(chalk.red(`  ● 配置无效：${configProblem}`));
-      console.log(chalk.dim('  请先选择“首次配置 API Key 和模型”重新配置'));
+      console.log(chalk.dim('  请先选择"配置 API 连接"重新配置'));
     } else {
       console.log(await renderStatusBar(apiStatus));
     }
     console.log();
 
+    const disabledHint = (!config || configProblem) && '需先配置 API 连接';
+
     const action = await select({ loop: false,
       message: chalk.cyan('选择操作'),
       choices: [
-        { name: '🤖 启动 Claude Code', value: 'launch', disabled: (!config || configProblem) && '需先完成配置' },
+        { name: '🤖 启动 Claude Code', value: 'launch', disabled: disabledHint },
         { name: '📦 安装 Claude Code', value: 'install' },
-        { name: config ? '⚙️  重新配置（输入新的 API Key）' : '⚙️  首次配置 API Key 和模型', value: 'setup' },
-        { name: '🔄 切换厂商或模型', value: 'switch', disabled: (!config || configProblem) && '需先完成配置' },
-        { name: '🖥  配置 Claude 桌面应用', value: 'desktop', disabled: (!config || configProblem) && '需先完成配置' },
-        { name: '📊 查看当前配置', value: 'status', disabled: !config && '需先完成配置' },
-        { name: '🔁 重新检测 API', value: 'recheck', disabled: (!config || configProblem) && '需先完成配置' },
-        { name: '🗑  恢复默认（清除所有配置）', value: 'reset' },
+        { name: config ? '🔑 重新配置 API 连接' : '🔑 配置 API 连接', value: 'config' },
+        { name: '🔄 切换厂商或模型', value: 'switch', disabled: disabledHint },
+        { name: '💻 接入 Claude Code 终端', value: 'code', disabled: disabledHint },
+        { name: '🖥  接入 Claude 桌面应用', value: 'desktop', disabled: disabledHint },
+        { name: '📊 查看当前配置', value: 'status', disabled: !config && '需先配置 API 连接' },
+        { name: '🛠  高级 ›', value: 'advanced' },
         { name: '退出', value: 'exit' },
       ],
     });
 
     if (action === 'exit') return;
 
-    if (action === 'recheck') {
-      // 仅刷新菜单，下次循环会重新检测
+    let resolvedAction = action;
+    if (action === 'advanced') {
+      const adv = await runAdvancedMenu(chalk, !!config && !configProblem);
+      if (adv === '__BACK__') continue;
+      resolvedAction = adv;
+    }
+
+    if (resolvedAction === 'recheck') {
+      lastCheckResult = undefined;
+      forceRecheck = true;
       continue;
     }
 
-    if (action === 'launch') {
+    if (resolvedAction === 'launch') {
       const cfg = loadConfig();
       if (!cfg || getConfigValidationMessage(cfg)) continue;
-      // 启动 claude 后等它退出，然后回菜单
       await new Promise((resolve) => {
         const child = spawn('claude', [], {
           stdio: 'inherit',
@@ -740,21 +925,29 @@ async function runMenu() {
 
     const cmdMap = {
       install: 'install-claude',
-      setup: 'setup',
+      config: 'config',
+      code: 'code',
+      'code-reset': 'code-reset',
       switch: 'switch',
       desktop: 'desktop',
+      'desktop-reset': 'desktop-reset',
       status: 'status',
       reset: 'reset',
     };
 
-    // 执行子命令
+    // 执行子命令（用 spawn 隔离，避免 commander 对 program 的副作用）
     await new Promise((resolve) => {
-      const child = spawn(process.execPath, [__filename, cmdMap[action]], { stdio: 'inherit' });
+      const child = spawn(process.execPath, [__filename, cmdMap[resolvedAction]], { stdio: 'inherit' });
       child.on('exit', resolve);
       child.on('error', resolve);
     });
 
-    // 操作结束，提示返回菜单
+    // 改 config 的命令需要刷新缓存
+    if (['config', 'switch', 'reset', 'code-reset'].includes(resolvedAction)) {
+      lastCheckResult = undefined;
+      lastCheckedHash = null;
+    }
+
     console.log();
     const next = await select({ loop: false,
       message: chalk.cyan('下一步'),

package/lib/config.js

@@ -330,18 +330,10 @@ function writeEnvToZshrc(baseUrl, apiKey, model, fastModel, options = {}) {
   return { result: cleaned !== current ? 'updated' : 'added', file: rcFile };
 }
 
-// 清除所有 clawai 配置（配置文件 + shell 环境变量块）
-function resetConfig(options = {}) {
+function clearClaudeCodeEnv(options = {}) {
   const cleared = [];
-  const configFile = options.configFile || CONFIG_FILE;
   const platform = options.platform || process.platform;
 
-  // 删配置文件
-  if (fs.existsSync(configFile)) {
-    fs.unlinkSync(configFile);
-    cleared.push(configFile);
-  }
-
   if (platform === 'win32') {
     runWindowsEnvCommands(buildWindowsClearEnvCommands(), options.runner || spawnSync, { ignoreErrors: true });
     cleared.push(WINDOWS_ENV_LABEL);
@@ -369,12 +361,27 @@ function resetConfig(options = {}) {
   return cleared;
 }
 
+// 清除所有 clawai 配置（配置文件 + shell 环境变量块）
+function resetConfig(options = {}) {
+  const cleared = [];
+  const configFile = options.configFile || CONFIG_FILE;
+
+  // 删配置文件
+  if (fs.existsSync(configFile)) {
+    fs.unlinkSync(configFile);
+    cleared.push(configFile);
+  }
+
+  return [...cleared, ...clearClaudeCodeEnv(options)];
+}
+
 module.exports = {
   loadConfig,
   saveConfig,
   writeEnvToZshrc,
   buildWindowsSetEnvCommands,
   buildWindowsClearEnvCommands,
+  clearClaudeCodeEnv,
   fetchModels,
   resetConfig,
   validateConfig,

package/lib/desktop.js

@@ -119,43 +119,49 @@ function clearClaudeDesktopConfig(options = {}) {
   return { result: 'updated', file };
 }
 
-function buildClaudeDesktopRestartCommands(platform = process.platform) {
+function buildClaudeDesktopOpenCommands(platform = process.platform) {
   if (platform !== 'darwin') return null;
+  // 先 quit 再 open：避免已运行的实例缓存了旧配置
   return [
-    { command: 'osascript', args: ['-e', 'tell application "Claude" to quit'] },
+    { command: 'osascript', args: ['-e', 'tell application "Claude" to quit'], optional: true },
     { command: 'open', args: ['-a', 'Claude'] },
   ];
 }
 
-function delay(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
+async function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
 }
 
-async function restartClaudeDesktop(options = {}) {
+async function openClaudeDesktop(options = {}) {
   const platform = options.platform || process.platform;
-  const commands = buildClaudeDesktopRestartCommands(platform);
+  const commands = buildClaudeDesktopOpenCommands(platform);
   if (!commands) return { result: 'unsupported' };
 
   const runner = options.runner || spawnSync;
-  const delayMs = options.delayMs ?? 1500;
-  const [quitCommand, openCommand] = commands;
-
-  runner(quitCommand.command, quitCommand.args, { stdio: 'ignore', windowsHide: true });
-  await delay(delayMs);
-  const result = runner(openCommand.command, openCommand.args, { stdio: 'ignore', windowsHide: true });
-  if (result.status !== 0) {
-    throw new Error('Claude 桌面应用重新打开失败');
+  const waitMs = options.waitMs ?? 700;
+
+  for (let i = 0; i < commands.length; i++) {
+    const { command, args, optional } = commands[i];
+    const result = runner(command, args, { stdio: 'ignore', windowsHide: true });
+    // optional 命令失败（比如 Claude 没在运行）不报错
+    if (result.status !== 0 && !optional) {
+      throw new Error('Claude 桌面应用打开失败');
+    }
+    // quit 后等一下再 open，给系统清理资源的时间
+    if (i === 0 && commands.length > 1 && options.runner === undefined) {
+      await sleep(waitMs);
+    }
   }
 
-  return { result: 'restarted' };
+  return { result: 'reopened' };
 }
 
 module.exports = {
   buildClaudeDesktopEnterpriseConfig,
-  buildClaudeDesktopRestartCommands,
+  buildClaudeDesktopOpenCommands,
   clearClaudeDesktopConfig,
   getClaudeDesktopConfigPath,
-  restartClaudeDesktop,
+  openClaudeDesktop,
   writeClaudeDesktopConfig,
   CLAUDE_DESKTOP_LABEL,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yingclaw",
-  "version": "1.7.8",
+  "version": "1.8.1",
   "description": "Claude Code × 国产大模型一键接入：DeepSeek、Kimi、Qwen、MiniMax、GLM、MiMo",
   "main": "index.js",
   "bin": {