yymaxapi 1.0.48 → 1.0.49

package/bin/yymaxapi.js

@@ -1659,6 +1659,7 @@ function ensureGatewaySettings(config) {
   if (isLocal && gateway.remote.token !== gateway.auth.token) {
     gateway.remote.token = gateway.auth.token;
   }
+
 }
 
 function isPortOpen(port, host = '127.0.0.1', timeoutMs = 800) {
@@ -2662,10 +2663,21 @@ async function autoActivate(paths, args = {}) {
 
   // 增量写入: 只添加/更新云翼 provider，保留其他已有配置
 
-  // Claude 侧
+  // Claude 侧 — 让用户选模型
   const claudeBaseUrl = buildFullUrl(selectedEndpoint.url, 'claude');
-  const claudeModelId = 'claude-sonnet-4-6';
-  const claudeModel = CLAUDE_MODELS.find(m => m.id === claudeModelId) || { id: claudeModelId, name: 'Claude Sonnet 4.6' };
+  let claudeModelId = (args['claude-model'] || '').toString().trim();
+  if (!claudeModelId && CLAUDE_MODELS.length > 1) {
+    const { picked } = await inquirer.prompt([{
+      type: 'list',
+      name: 'picked',
+      message: '选择 Claude 模型:',
+      choices: CLAUDE_MODELS.map(m => ({ name: m.name, value: m.id })),
+      default: CLAUDE_MODELS[0].id
+    }]);
+    claudeModelId = picked;
+  }
+  if (!claudeModelId) claudeModelId = CLAUDE_MODELS[0]?.id || 'claude-sonnet-4-6';
+  const claudeModel = CLAUDE_MODELS.find(m => m.id === claudeModelId) || { id: claudeModelId, name: claudeModelId };
   const claudeModelKey = `${claudeProviderName}/${claudeModelId}`;
 
   config.models.providers[claudeProviderName] = {
@@ -2685,10 +2697,21 @@ async function autoActivate(paths, args = {}) {
   config.auth.profiles[`${claudeProviderName}:default`] = { provider: claudeProviderName, mode: 'api_key' };
   config.agents.defaults.models[claudeModelKey] = { alias: claudeProviderName };
 
-  // Codex 侧
+  // Codex 侧 — 让用户选模型
   const codexBaseUrl = buildFullUrl(selectedEndpoint.url, 'codex');
-  const codexModelId = 'gpt-5.3-codex';
-  const codexModel = CODEX_MODELS.find(m => m.id === codexModelId) || { id: codexModelId, name: 'GPT 5.3 Codex' };
+  let codexModelId = (args['codex-model'] || '').toString().trim();
+  if (!codexModelId && CODEX_MODELS.length > 1) {
+    const { pickedCodex } = await inquirer.prompt([{
+      type: 'list',
+      name: 'pickedCodex',
+      message: '选择 Codex 模型:',
+      choices: CODEX_MODELS.map(m => ({ name: m.name, value: m.id })),
+      default: CODEX_MODELS[0].id
+    }]);
+    codexModelId = pickedCodex;
+  }
+  if (!codexModelId) codexModelId = CODEX_MODELS[0]?.id || 'gpt-5.3-codex';
+  const codexModel = CODEX_MODELS.find(m => m.id === codexModelId) || { id: codexModelId, name: codexModelId };
   const codexModelKey = `${codexProviderName}/${codexModelId}`;
 
   config.models.providers[codexProviderName] = {
@@ -3155,6 +3178,7 @@ async function main() {
         { name: '  配置 Opencode', value: 'activate_opencode' },
         new inquirer.Separator('  -- 工具 --'),
         { name: '  切换模型', value: 'switch_model' },
+        { name: `  权限管理${getToolsProfileTag(paths)}`, value: 'tools_profile' },
         { name: '  测试连接', value: 'test_connection' },
         { name: '  查看配置', value: 'view_config' },
         { name: '  恢复默认', value: 'restore' },
@@ -3183,6 +3207,9 @@ async function main() {
         case 'switch_model':
           await switchModel(paths);
           break;
+        case 'tools_profile':
+          await manageToolsProfile(paths);
+          break;
         case 'view_config':
           await viewConfig(paths);
           break;
@@ -3334,15 +3361,18 @@ async function selectNode(paths, type) {
     }]
   };
 
-  // 注册模型
+  // 注册模型并设为主模型
   const modelKey = `${apiConfig.providerName}/${modelConfig.id}`;
   config.agents.defaults.models[modelKey] = { alias: apiConfig.providerName };
+  config.agents.defaults.model.primary = modelKey;
+  config.agents.defaults.model.fallbacks = (config.agents.defaults.model.fallbacks || []).filter(k => k !== modelKey);
 
+  ensureGatewaySettings(config);
   writeConfigWithSync(paths, config);
 
   console.log(chalk.green(`\n✅ ${typeLabel} 节点配置完成！`));
   console.log(chalk.cyan(`   节点: ${selectedEndpoint.name} (${selectedEndpoint.url})`));
-  console.log(chalk.gray(`   模型: ${modelConfig.name}`));
+  console.log(chalk.gray(`   模型: ${modelConfig.name} (主模型)`));
   console.log(chalk.gray(`   API Key: ${oldApiKey ? '已设置' : '未设置'}`));
 }
 
@@ -3475,15 +3505,39 @@ async function switchModel(paths) {
   }
 
   const selectedProvider = selected.split('/')[0];
+  const selectedModelId = selected.split('/')[1];
   config.agents.defaults.model.primary = selected;
   if (!config.agents.defaults.models[selected]) {
     config.agents.defaults.models[selected] = { alias: selectedProvider };
   }
+
+  // 同步更新 provider.models，确保 primary 指向的模型在列表中
+  const providerConfig = providers[selectedProvider];
+  if (providerConfig && selectedModelId) {
+    const existingModel = (providerConfig.models || []).find(m => m.id === selectedModelId);
+    if (!existingModel) {
+      const allModels = [...CLAUDE_MODELS, ...CODEX_MODELS];
+      const knownModel = allModels.find(m => m.id === selectedModelId);
+      const apiType = providerConfig.api || '';
+      const isAnthropic = apiType.startsWith('anthropic');
+      const defaultCtx = isAnthropic ? (API_CONFIG.claude?.contextWindow || 200000) : (API_CONFIG.codex?.contextWindow || 200000);
+      const defaultMax = isAnthropic ? (API_CONFIG.claude?.maxTokens || 8192) : (API_CONFIG.codex?.maxTokens || 8192);
+      providerConfig.models = [{
+        id: selectedModelId,
+        name: knownModel ? knownModel.name : selectedModelId,
+        contextWindow: defaultCtx,
+        maxTokens: defaultMax
+      }];
+    } else {
+      providerConfig.models = [existingModel];
+    }
+  }
+
   config.agents.defaults.model.fallbacks = (config.agents.defaults.model.fallbacks || []).filter(k => k !== selected);
-  // 把旧的 primary 加入 fallbacks (如果存在且不同)
   if (primary && primary !== selected && !config.agents.defaults.model.fallbacks.includes(primary)) {
     config.agents.defaults.model.fallbacks.push(primary);
   }
+  ensureGatewaySettings(config);
   writeConfigWithSync(paths, config);
 
   const selectedProviderConfig = providers[selectedProvider];
@@ -3493,15 +3547,96 @@ async function switchModel(paths) {
   if (selectedProviderConfig) {
     console.log(chalk.gray(`   节点: ${selectedProviderConfig.baseUrl}`));
   }
-  console.log(chalk.yellow('\n💡 切换后建议重启 Gateway: openclaw gateway restart'));
 
   const gwPort = config.gateway?.port || 18789;
   const gwToken = config.gateway?.auth?.token;
+
+  // 自动重启 Gateway 使切换立即生效
+  if (await isPortOpen(gwPort)) {
+    const gwSpinner = ora({ text: '重启 Gateway 使模型切换生效...', spinner: 'dots' }).start();
+    const ok = await restartGateway({ silent: true });
+    if (ok) {
+      gwSpinner.succeed('Gateway 已重启，模型切换已生效');
+    } else {
+      gwSpinner.fail('Gateway 重启失败，请手动重启: openclaw gateway restart');
+    }
+  } else {
+    console.log(chalk.yellow('\n⚠️ Gateway 未运行，模型切换将在下次启动 Gateway 时生效'));
+    console.log(chalk.gray('   启动 Gateway: openclaw gateway'));
+  }
+
   if (gwToken) {
     console.log(chalk.green(`\n🌐 Web Dashboard:`));
     console.log(chalk.cyan(`   http://localhost:${gwPort}/?token=${gwToken}`));
   }
 }
+// ============ 权限管理 (tools.profile) ============
+const TOOLS_PROFILES = [
+  { id: 'full', name: '完整模式', desc: '编码 + 系统工具 + 文件操作（Claude Code / Codex 必需）' },
+  { id: 'messaging', name: '聊天模式', desc: '仅对话，无文件/系统工具（安全但功能受限）' },
+];
+
+function getToolsProfileTag(paths) {
+  try {
+    const config = readConfig(paths.openclawConfig);
+    const profile = config?.tools?.profile || 'messaging';
+    if (profile === 'full') return chalk.green(' [完整]');
+    return chalk.yellow(' [仅聊天]');
+  } catch {
+    return '';
+  }
+}
+
+async function manageToolsProfile(paths) {
+  console.log(chalk.cyan('🔐 权限管理\n'));
+  console.log(chalk.gray('OpenClaw 3.2+ 新增 tools.profile 控制：'));
+  console.log(chalk.gray('  full     = 完整编码能力（读写文件、执行命令、系统操作）'));
+  console.log(chalk.gray('  messaging = 仅聊天（无法操作文件和系统，适合纯对话场景）'));
+  console.log(chalk.yellow('\n⚠️  使用 Claude Code / Codex 编码，必须选择「完整模式」\n'));
+
+  const config = readConfig(paths.openclawConfig) || {};
+  const current = config?.tools?.profile || 'messaging';
+  const currentLabel = current === 'full' ? '完整模式' : current === 'messaging' ? '聊天模式' : current;
+  console.log(chalk.gray(`当前: ${currentLabel}\n`));
+
+  const { selected } = await inquirer.prompt([{
+    type: 'list',
+    name: 'selected',
+    message: '选择权限模式:',
+    choices: TOOLS_PROFILES.map(p => ({
+      name: p.id === current ? `${p.name} — ${p.desc} (当前)` : `${p.name} — ${p.desc}`,
+      value: p.id,
+    })),
+    default: current,
+  }]);
+
+  if (selected === current) {
+    console.log(chalk.gray('\n权限模式未变更'));
+    return;
+  }
+
+  if (!config.tools) config.tools = {};
+  config.tools.profile = selected;
+  ensureGatewaySettings(config);
+  writeConfigWithSync(paths, config);
+
+  const label = TOOLS_PROFILES.find(p => p.id === selected)?.name || selected;
+  console.log(chalk.green(`\n✅ 已切换到: ${label}`));
+
+  const gwPort = config.gateway?.port || 18789;
+  if (await isPortOpen(gwPort)) {
+    const gwSpinner = ora({ text: '重启 Gateway 使权限变更生效...', spinner: 'dots' }).start();
+    const ok = await restartGateway({ silent: true });
+    if (ok) {
+      gwSpinner.succeed('Gateway 已重启，权限变更已生效');
+    } else {
+      gwSpinner.fail('Gateway 重启失败，请手动重启: openclaw gateway restart');
+    }
+  } else {
+    console.log(chalk.gray('   Gateway 未运行，变更将在下次启动时生效'));
+  }
+}
+
 // ============ 测试连接 ============
 async function testConnection(paths, args = {}) {
   console.log(chalk.cyan('🧪 测试 OpenClaw Gateway 连接\n'));
@@ -3584,11 +3719,8 @@ async function testConnection(paths, args = {}) {
   cleanupAgentProcesses();
 
   // 步骤1: 先重启 Gateway 使配置生效
-  console.log(chalk.cyan('步骤 1/2: 重启 Gateway 使配置生效...'));
-  const restartOk = await restartGateway();
-
-  // 等待 Gateway 启动
-  const gwSpinner = ora({ text: '等待 Gateway 启动...', spinner: 'dots' }).start();
+  const gwSpinner = ora({ text: '步骤 1/2: 重启 Gateway 使配置生效...', spinner: 'dots' }).start();
+  const restartOk = await restartGateway({ silent: true });
 
   let gatewayRunning = false;
 
@@ -3748,342 +3880,288 @@ async function testConnection(paths, args = {}) {
 }
 
 // ============ 重启 Gateway ============
-async function restartGateway() {
-  console.log(chalk.cyan('\n正在重启 OpenClaw Gateway...'));
+async function restartGateway({ silent = false } = {}) {
+  if (!silent) console.log(chalk.cyan('\n正在重启 OpenClaw Gateway...'));
 
   const gwEnv = detectGatewayEnv();
+  const configPaths = getConfigPath();
+  const gwConfig = readConfig(configPaths.openclawConfig);
+  const gatewayPort = gwConfig?.gateway?.port || 18789;
 
-  // 如果 Gateway 在 Docker 容器里，通过 docker exec 重启
+  // Docker 容器内重启
   if (gwEnv === 'docker') {
-    const container = await selectDockerContainer();
-    if (!container) {
-      console.log(chalk.red('❌ 未找到可用的 Docker 容器'));
-      return restartGatewayNative();
-    }
-    console.log(chalk.gray(`   [检测] Gateway 运行在 Docker 容器: ${container.name} (${container.image})`));
-
-    const dockerCmds = [];
-    if (container.cli === 'node') {
-      dockerCmds.push(`node ${container.cliPath} gateway restart`);
-    } else {
-      if (container.cliPath) dockerCmds.push(`${container.cliPath} gateway restart`);
-      dockerCmds.push(`${container.cli} gateway restart`);
-    }
-    for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
-      dockerCmds.push(`${name} gateway restart`);
-    }
-
-    // 每个命令尝试多种 shell（sh -c / bash -lc / bash -c）
-    const shellVariants = ['sh -c', 'bash -lc', 'bash -c'];
-
-    return new Promise((resolve) => {
-      // 展开为 [cmd1+sh, cmd1+bash-lc, cmd1+bash-c, cmd2+sh, ...]
-      const allAttempts = [];
-      for (const cmd of [...new Set(dockerCmds)].filter(Boolean)) {
-        for (const shell of shellVariants) {
-          allAttempts.push(dockerCmd(`exec ${container.id} ${shell} "${cmd}"`));
-        }
-      }
-      let tried = 0;
-      const tryNext = () => {
-        if (tried >= allAttempts.length) {
-          console.log(chalk.yellow('Docker 容器内 Gateway 重启失败，尝试本地重启...'));
-          restartGatewayNative().then(resolve);
-          return;
-        }
-        const fullCmd = allAttempts[tried++];
-        exec(fullCmd, { timeout: 30000 }, (error) => {
-          if (error) {
-            tryNext();
-          } else {
-            console.log(chalk.green(`✅ Gateway 已重启 (Docker: ${container.name})`));
-            resolve(true);
-          }
-        });
-      };
-      tryNext();
-    });
+    const result = await restartGatewayDocker(gatewayPort, silent);
+    if (result) return true;
+    if (!silent) console.log(chalk.yellow('Docker 容器内重启失败，尝试本地重启...'));
   }
 
-  // 如果 Gateway 在 WSL 里，优先用 wsl -- 重启
+  // WSL 内重启
   if (gwEnv === 'wsl') {
-    console.log(chalk.gray('   [检测] Gateway 运行在 WSL 中'));
-    const wslCli = getWslCliBinary();
-    return new Promise((resolve) => {
-      const wslCmds = wslCli
-        ? [`wsl -- bash -lc "${wslCli} gateway restart"`]
-        : [
-          'wsl -- bash -lc "openclaw gateway restart"',
-          'wsl -- bash -lc "clawdbot gateway restart"',
-          'wsl -- bash -lc "moltbot gateway restart"',
-        ];
-      let tried = 0;
-      const tryNext = () => {
-        if (tried >= wslCmds.length) {
-          console.log(chalk.yellow('WSL 内 Gateway 重启失败，尝试 Windows 原生重启...'));
-          restartGatewayNative().then(resolve);
-          return;
-        }
-        const cmd = wslCmds[tried++];
-        exec(cmd, { timeout: 30000 }, (error, stdout, stderr) => {
-          const errStr = (stderr || '').toLowerCase();
-          const wslGarbled = errStr.includes('wsl:') && errStr.includes('localhost') && errStr.includes('nat');
-
-          if (error || errStr.includes('/usr/bin/env:') || wslGarbled) {
-            tryNext();
-          } else {
-            console.log(chalk.green('Gateway 已重启 (WSL)'));
-            resolve(true);
-          }
-        });
-      };
-      tryNext();
-    });
+    const result = await restartGatewayWsl(gatewayPort, silent);
+    if (result) return true;
+    if (!silent) console.log(chalk.yellow('WSL 内重启失败，尝试 Windows 原生重启...'));
   }
 
-  return restartGatewayNative();
+  return restartGatewayNative(silent);
 }
 
-// 强制重启 Gateway：杀掉旧进程，再用已找到的 CLI 路径启动新 Gateway
-async function forceRestartGateway(resolved, nodeInfo, useNode, env, gatewayPort = 18789) {
-  console.log(chalk.yellow('\n🔄 尝试强制重启 Gateway（杀旧进程 → 启动新进程）...'));
-
-  // Docker 容器内强制重启
-  if (detectGatewayEnv() === 'docker' && _selectedDockerContainer) {
-    const cid = _selectedDockerContainer.id;
-    const cName = _selectedDockerContainer.name;
-    console.log(chalk.gray(`   [Docker] 在容器 ${cName} 内强制重启...`));
+function buildDockerInnerCmds(container, verb) {
+  const cmds = [];
+  if (container.cli === 'node') {
+    cmds.push(`node ${container.cliPath} ${verb}`);
+  } else {
+    if (container.cliPath) cmds.push(`${container.cliPath} ${verb}`);
+    cmds.push(`${container.cli} ${verb}`);
+  }
+  for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+    cmds.push(`${name} ${verb}`);
+  }
+  return [...new Set(cmds)].filter(Boolean);
+}
 
-    // 1. 杀掉容器内旧 Gateway 进程
-    try {
-      for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
-        safeExec(dockerCmd(`exec ${cid} sh -c "pkill -f '${name}.*gateway' 2>/dev/null || true"`), { timeout: 5000 });
-      }
-      safeExec(dockerCmd(`exec ${cid} sh -c "lsof -ti :${gatewayPort} 2>/dev/null | xargs -r kill -9 2>/dev/null || true"`), { timeout: 5000 });
-      console.log(chalk.gray('   已尝试清理容器内旧 Gateway 进程'));
-    } catch { /* ignore */ }
+async function restartGatewayDocker(gatewayPort, silent = false) {
+  const container = await selectDockerContainer();
+  if (!container) return false;
+  if (!silent) console.log(chalk.gray(`   [检测] Gateway 运行在 Docker 容器: ${container.name} (${container.image})`));
 
-    await new Promise(resolve => setTimeout(resolve, 2000));
+  const cid = container.id;
+  const shellVariants = ['sh -c', 'bash -lc', 'bash -c'];
 
-    // 2. 启动新 Gateway
-    const dockerCmds = [];
-    if (_selectedDockerContainer.cli === 'node') {
-      dockerCmds.push(`node ${_selectedDockerContainer.cliPath} gateway`);
-    } else {
-      if (_selectedDockerContainer.cliPath) dockerCmds.push(`${_selectedDockerContainer.cliPath} gateway`);
-      dockerCmds.push(`${_selectedDockerContainer.cli} gateway`);
+  // 策略 A：exec restart 命令（短超时），然后端口探测
+  for (const cmd of buildDockerInnerCmds(container, 'gateway restart')) {
+    for (const shell of shellVariants) {
+      safeExec(dockerCmd(`exec ${cid} ${shell} "${cmd}"`), { timeout: 8000 });
+      if (await waitForGateway(gatewayPort, '127.0.0.1', 5000)) {
+        if (!silent) console.log(chalk.green(`✅ Gateway 已重启 (Docker: ${container.name})`));
+        return true;
+      }
     }
+  }
+
+  // 策略 B：杀容器内旧进程 → spawn 启动新 Gateway → 端口探测
+  if (!silent) console.log(chalk.gray('   Docker 内常规重启未生效，尝试杀进程后重新启动...'));
+  try {
     for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
-      dockerCmds.push(`${name} gateway`);
+      safeExec(dockerCmd(`exec ${cid} sh -c "pkill -f '${name}.*gateway' 2>/dev/null || true"`), { timeout: 5000 });
     }
+    safeExec(dockerCmd(`exec ${cid} sh -c "lsof -ti :${gatewayPort} 2>/dev/null | xargs -r kill -9 2>/dev/null || true"`), { timeout: 5000 });
+  } catch { /* ignore */ }
+  await new Promise(resolve => setTimeout(resolve, 2000));
 
-    for (const cmd of [...new Set(dockerCmds)].filter(Boolean)) {
-      console.log(chalk.gray(`   尝试在容器内启动: ${cmd}`));
-      for (const shell of ['sh -c', 'bash -lc', 'bash -c']) {
-        if (spawnDetachedInDocker(cid, cmd, shell)) {
-          if (await waitForGateway(gatewayPort, '127.0.0.1', 12000)) {
-            console.log(chalk.green(`✅ Gateway 已在 Docker 容器 ${cName} 内强制重启成功`));
-            return true;
-          }
+  for (const cmd of buildDockerInnerCmds(container, 'gateway')) {
+    for (const shell of shellVariants) {
+      if (spawnDetachedInDocker(cid, cmd, shell)) {
+        if (await waitForGateway(gatewayPort, '127.0.0.1', 12000)) {
+          if (!silent) console.log(chalk.green(`✅ Gateway 已重启 (Docker: ${container.name})`));
+          return true;
         }
       }
     }
+  }
 
-    console.log(chalk.red('❌ Docker 容器内强制重启也失败了'));
-    console.log(chalk.gray(`   请手动进入容器重启: docker exec -it ${cid} bash`));
-    console.log(chalk.gray(`   然后执行: openclaw gateway / clawdbot gateway / moltbot gateway`));
-    return false;
+  return false;
+}
+
+async function restartGatewayWsl(gatewayPort, silent = false) {
+  if (!silent) console.log(chalk.gray('   [检测] Gateway 运行在 WSL 中'));
+  const wslCli = getWslCliBinary();
+  const names = ['openclaw', 'clawdbot', 'moltbot'];
+
+  // 构建 WSL 重启命令
+  const wslRestartCmds = [];
+  if (wslCli) wslRestartCmds.push(`wsl -- bash -lc "${wslCli} gateway restart"`);
+  for (const name of names) wslRestartCmds.push(`wsl -- bash -lc "${name} gateway restart"`);
+
+  // 策略 A：exec restart（短超时）+ 端口探测
+  for (const cmd of wslRestartCmds) {
+    safeExec(cmd, { timeout: 8000 });
+    if (await waitForGateway(gatewayPort, '127.0.0.1', 5000)) {
+      if (!silent) console.log(chalk.green('✅ Gateway 已重启 (WSL)'));
+      return true;
+    }
   }
 
-  // 1. 杀掉旧 Gateway 进程
+  // 策略 B：杀 WSL 内旧进程 → spawn 启动 → 端口探测
+  if (!silent) console.log(chalk.gray('   WSL 内常规重启未生效，尝试杀进程后重新启动...'));
   try {
-    if (process.platform === 'win32') {
-      // Windows: 通过 taskkill 杀掉占用端口的 node 进程
-      const findPid = safeExec(`netstat -ano | findstr ":${gatewayPort}"`, { timeout: 5000 });
-      if (findPid.ok && findPid.output) {
-        const lines = findPid.output.split('\n').filter(l => l.includes('LISTENING'));
-        for (const line of lines) {
-          const pid = line.trim().split(/\s+/).pop();
-          if (pid && /^\d+$/.test(pid)) {
-            safeExec(`taskkill /F /PID ${pid}`, { timeout: 5000 });
-          }
-        }
-      }
-      // Windows + WSL: 也清理 WSL 内的 gateway 进程
-      if (isWslAvailable()) {
-        for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
-          safeExec(`wsl -- bash -c "pkill -f '${name}.*gateway' 2>/dev/null || true"`, { timeout: 5000 });
-        }
-        safeExec(`wsl -- bash -c "lsof -ti :${gatewayPort} 2>/dev/null | xargs -r kill -9 2>/dev/null || true"`, { timeout: 5000 });
-      }
-    } else {
-      // Linux/macOS: pkill gateway 相关进程
-      for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
-        safeExec(`pkill -f '${name}.*gateway' 2>/dev/null || true`);
-      }
-      // 备用：通过端口找进程并杀掉
-      const lsof = safeExec(`lsof -ti :${gatewayPort} 2>/dev/null`);
-      if (lsof.ok && lsof.output) {
-        for (const pid of lsof.output.trim().split('\n').filter(Boolean)) {
-          if (/^\d+$/.test(pid.trim())) {
-            safeExec(`kill -9 ${pid.trim()} 2>/dev/null || true`);
-          }
-        }
-      }
+    for (const name of names) {
+      safeExec(`wsl -- bash -c "pkill -f '${name}.*gateway' 2>/dev/null || true"`, { timeout: 5000 });
     }
-    console.log(chalk.gray('   已尝试清理旧 Gateway 进程'));
+    safeExec(`wsl -- bash -c "lsof -ti :${gatewayPort} 2>/dev/null | xargs -r kill -9 2>/dev/null || true"`, { timeout: 5000 });
   } catch { /* ignore */ }
-
-  // 2. 等待端口释放
   await new Promise(resolve => setTimeout(resolve, 2000));
 
-  // 3. 用已找到的 CLI 路径启动新 Gateway
-  const startCmds = [];
+  const wslStartCmds = [];
+  if (wslCli) wslStartCmds.push(`wsl -- bash -lc "${wslCli} gateway"`);
+  for (const name of names) wslStartCmds.push(`wsl -- bash -lc "${name} gateway"`);
 
-  // 优先用已解析的完整路径
-  if (resolved) {
-    if (useNode && nodeInfo) {
-      startCmds.push(`"${nodeInfo.path}" "${resolved}" gateway`);
-    } else {
-      startCmds.push(`"${resolved}" gateway`);
+  for (const cmd of wslStartCmds) {
+    if (spawnDetached(cmd, process.env)) {
+      if (await waitForGateway(gatewayPort, '127.0.0.1', 12000)) {
+        if (!silent) console.log(chalk.green('✅ Gateway 已重启 (WSL)'));
+        return true;
+      }
     }
   }
 
-  // Fallback: login shell 方式（加载 nvm 等 PATH）
-  if (process.platform !== 'win32') {
-    for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
-      startCmds.push(`bash -lc '${name} gateway'`);
-    }
-  } else {
-    // Windows: 先尝试原生命令
-    startCmds.push('openclaw gateway', 'clawdbot gateway', 'moltbot gateway');
-    // Windows + WSL: 也尝试通过 WSL 启动 gateway
-    if (isWslAvailable()) {
-      const wslCli = getWslCliBinary();
-      if (wslCli) {
-        startCmds.push(`wsl -- bash -lc "${wslCli} gateway"`);
-      }
-      for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
-        startCmds.push(`wsl -- bash -lc "${name} gateway"`);
-      }
+  return false;
+}
+
+async function restartGatewayNative(silent = false) {
+  const { cliBinary: resolved, nodeMajor } = getCliMeta();
+  const nodeInfo = findCompatibleNode(nodeMajor);
+  const env = { ...process.env, PATH: extendPathEnv(nodeInfo ? nodeInfo.path : null) };
+  const useNode = resolved && nodeInfo && isNodeShebang(resolved);
+
+  const configPaths = getConfigPath();
+  const gwConfig = readConfig(configPaths.openclawConfig);
+  const gatewayPort = gwConfig?.gateway?.port || 18789;
+
+  // 策略 A：先尝试 exec "gateway restart"（给 8s 超时——足够杀旧进程）
+  // 注意：该命令通常会启动前台 daemon 不退出，超时是正常的
+  const restartCmds = buildGatewayCommands(resolved, nodeInfo, useNode, 'restart');
+
+  let execAttempted = false;
+  for (const cmd of restartCmds) {
+    execAttempted = true;
+    const result = safeExec(cmd, { timeout: 8000, env });
+    // 不管是否 "成功"（通常会超时），检查端口是否可达
+    if (await waitForGateway(gatewayPort, '127.0.0.1', 5000)) {
+      if (!silent) console.log(chalk.green(`✅ Gateway 已重启`));
+      return true;
     }
   }
 
-  for (const cmd of [...new Set(startCmds)].filter(Boolean)) {
-    console.log(chalk.gray(`   尝试启动: ${cmd}`));
+  // 策略 B：杀旧进程 → spawn 后台启动新 Gateway → 端口探测
+  if (!silent) console.log(chalk.gray('   常规重启未生效，尝试杀进程后重新启动...'));
+  await killGatewayProcesses(gatewayPort);
+  await new Promise(resolve => setTimeout(resolve, 1500));
+
+  const startCmds = buildGatewayCommands(resolved, nodeInfo, useNode, 'start');
+  for (const cmd of startCmds) {
     if (spawnDetached(cmd, env)) {
-      // 等待新 Gateway 启动
       if (await waitForGateway(gatewayPort, '127.0.0.1', 12000)) {
-        console.log(chalk.green('✅ Gateway 已强制重启成功'));
-        console.log(chalk.gray('   现在可以在 Web/Telegram/Discord 等渠道测试对话了'));
+        if (!silent) console.log(chalk.green('✅ Gateway 已重启'));
         return true;
       }
     }
   }
 
-  console.log(chalk.red('❌ 强制重启也失败了'));
-  console.log(chalk.gray('   请手动重启 Gateway:'));
-  console.log(chalk.gray('   1. 关闭旧进程: pkill -f "gateway" 或 taskkill'));
-  console.log(chalk.gray('   2. 启动新进程: openclaw gateway / clawdbot gateway / moltbot gateway'));
+  // 策略 C：用 login shell 启动（加载 nvm/fnm 等 PATH）
+  if (process.platform !== 'win32') {
+    if (!silent) console.log(chalk.gray('   尝试通过 login shell 启动...'));
+    for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+      for (const sh of ['/bin/zsh', '/bin/bash']) {
+        if (!fs.existsSync(sh)) continue;
+        if (spawnDetached(`${sh} -lc '${name} gateway'`, env)) {
+          if (await waitForGateway(gatewayPort, '127.0.0.1', 12000)) {
+            if (!silent) console.log(chalk.green('✅ Gateway 已重启 (login shell)'));
+            return true;
+          }
+        }
+      }
+    }
+  }
+
+  // 全部失败，输出诊断
+  if (!silent) {
+    console.log(chalk.red(`❌ 重启失败: 找不到 openclaw/clawdbot/moltbot 命令`));
+    console.log(chalk.gray(`   请手动运行: openclaw gateway restart`));
+    console.log(chalk.gray(`   或: clawdbot gateway restart`));
+    console.log(chalk.gray(`   或: moltbot gateway restart`));
+    printGatewayDiagnostics(resolved);
+  }
   return false;
 }
 
-async function restartGatewayNative() {
-  const { cliBinary: resolved, nodeMajor } = getCliMeta();
-  const nodeInfo = findCompatibleNode(nodeMajor);
-  const env = { ...process.env, PATH: extendPathEnv(nodeInfo ? nodeInfo.path : null) };
-  const useNode = resolved && nodeInfo && isNodeShebang(resolved);
-
-  // 尝试多种命令
-  const commands = resolved
-    ? [
-      useNode ? `"${nodeInfo.path}" "${resolved}" gateway restart` : `"${resolved}" gateway restart`
-    ]
-    : [
-      'openclaw gateway restart',
-      'clawdbot gateway restart',
-      'moltbot gateway restart',
-      'npx openclaw gateway restart',
-      'npx clawdbot gateway restart',
-      'npx moltbot gateway restart'
-    ];
+function buildGatewayCommands(resolved, nodeInfo, useNode, action) {
+  const verb = action === 'start' ? 'gateway' : 'gateway restart';
+  const commands = [];
 
-  // Windows + WSL: 追加 WSL 命令作为额外回退
-  if (process.platform === 'win32' && isWslAvailable()) {
-    const wslCli = getWslCliBinary();
-    if (wslCli) {
-      commands.push(`wsl -- bash -lc "${wslCli} gateway restart"`);
+  if (resolved) {
+    if (useNode && nodeInfo) {
+      commands.push(`"${nodeInfo.path}" "${resolved}" ${verb}`);
+    } else {
+      commands.push(`"${resolved}" ${verb}`);
     }
-    for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
-      commands.push(`wsl -- bash -lc "${name} gateway restart"`);
+  }
+
+  const names = ['openclaw', 'clawdbot', 'moltbot'];
+  if (process.platform === 'win32') {
+    for (const name of names) commands.push(`${name} ${verb}`);
+    if (isWslAvailable()) {
+      const wslCli = getWslCliBinary();
+      if (wslCli) commands.push(`wsl -- bash -lc "${wslCli} ${verb}"`);
+      for (const name of names) commands.push(`wsl -- bash -lc "${name} ${verb}"`);
     }
+  } else {
+    for (const name of names) commands.push(`${name} ${verb}`);
   }
 
-  // Docker: 追加 Docker 容器命令作为额外回退
   if (isDockerAvailable()) {
-    const dockerContainers = findOpenclawDockerContainers();
-    for (const c of dockerContainers) {
+    const containers = findOpenclawDockerContainers();
+    for (const c of containers) {
       if (c.cli === 'node') {
-        commands.push(dockerCmd(`exec ${c.id} bash -lc "node ${c.cliPath} gateway restart"`));
+        commands.push(dockerCmd(`exec ${c.id} bash -lc "node ${c.cliPath} ${verb}"`));
       } else if (c.cli !== 'unknown') {
-        commands.push(dockerCmd(`exec ${c.id} bash -lc "${c.cli} gateway restart"`));
+        commands.push(dockerCmd(`exec ${c.id} bash -lc "${c.cli} ${verb}"`));
       }
-      for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
-        commands.push(dockerCmd(`exec ${c.id} bash -lc "${name} gateway restart"`));
+      for (const name of names) {
+        commands.push(dockerCmd(`exec ${c.id} bash -lc "${name} ${verb}"`));
       }
     }
   }
 
-  return new Promise((resolve) => {
-    let tried = 0;
-
-    const tryNext = () => {
-      if (tried >= commands.length) {
-        console.log(chalk.red(`❌ 重启失败: 找不到 openclaw/clawdbot/moltbot 命令`));
-        console.log(chalk.gray(`   请手动运行: openclaw gateway restart`));
-        console.log(chalk.gray(`   或: clawdbot gateway restart`));
-        console.log(chalk.gray(`   或: moltbot gateway restart`));
-        // 诊断信息
-        console.log(chalk.gray(`\n   [诊断] resolveCliBinary = ${resolved || 'null'}`));
-        const npmPrefix = safeExec('npm prefix -g');
-        if (npmPrefix.ok) console.log(chalk.gray(`   [诊断] npm prefix -g = ${npmPrefix.output}`));
-        for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
-          const which = safeExec(process.platform === 'win32' ? `where ${name} 2>nul` : `/bin/zsh -lc "command -v ${name}" 2>/dev/null || /bin/bash -lc "command -v ${name}" 2>/dev/null`);
-          if (which.ok && which.output) console.log(chalk.gray(`   [诊断] ${name} -> ${which.output.split('\n')[0].trim()}`));
+  return [...new Set(commands)].filter(Boolean);
+}
+
+async function killGatewayProcesses(gatewayPort = 18789) {
+  try {
+    if (process.platform === 'win32') {
+      const findPid = safeExec(`netstat -ano | findstr ":${gatewayPort}"`, { timeout: 5000 });
+      if (findPid.ok && findPid.output) {
+        for (const line of findPid.output.split('\n').filter(l => l.includes('LISTENING'))) {
+          const pid = line.trim().split(/\s+/).pop();
+          if (pid && /^\d+$/.test(pid)) safeExec(`taskkill /F /PID ${pid}`, { timeout: 5000 });
         }
-        // Docker 诊断
-        if (isDockerAvailable()) {
-          const dContainers = findOpenclawDockerContainers();
-          if (dContainers.length > 0) {
-            console.log(chalk.gray(`   [诊断] Docker 容器 (含 openclaw/clawdbot/moltbot):`));
-            for (const c of dContainers) {
-              console.log(chalk.gray(`     - ${c.name} (${c.image}) [${c.cli}: ${c.cliPath}]`));
-            }
-          } else {
-            console.log(chalk.gray(`   [诊断] Docker 可用，但未找到含 openclaw/clawdbot/moltbot 的容器`));
-          }
+      }
+      if (isWslAvailable()) {
+        for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+          safeExec(`wsl -- bash -c "pkill -f '${name}.*gateway' 2>/dev/null || true"`, { timeout: 5000 });
         }
-        // 尝试强制重启
-        forceRestartGateway(resolved, nodeInfo, useNode, env).then(resolve);
-        return;
+        safeExec(`wsl -- bash -c "lsof -ti :${gatewayPort} 2>/dev/null | xargs -r kill -9 2>/dev/null || true"`, { timeout: 5000 });
       }
-
-      const cmd = commands[tried];
-      tried++;
-
-      exec(cmd, { timeout: 30000, env }, (error) => {
-        if (error) {
-          tryNext();
-        } else {
-          console.log(chalk.green(`✅ Gateway 已重启`));
-          console.log(chalk.gray(`   现在可以在 Web/Telegram/Discord 等渠道测试对话了`));
-          resolve(true);
+    } else {
+      for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+        safeExec(`pkill -f '${name}.*gateway' 2>/dev/null || true`);
+      }
+      const lsof = safeExec(`lsof -ti :${gatewayPort} 2>/dev/null`);
+      if (lsof.ok && lsof.output) {
+        for (const pid of lsof.output.trim().split('\n').filter(Boolean)) {
+          if (/^\d+$/.test(pid.trim())) safeExec(`kill -9 ${pid.trim()} 2>/dev/null || true`);
         }
-      });
-    };
+      }
+    }
+  } catch { /* ignore */ }
+}
 
-    tryNext();
-  });
+function printGatewayDiagnostics(resolved) {
+  console.log(chalk.gray(`\n   [诊断] resolveCliBinary = ${resolved || 'null'}`));
+  const npmPrefix = safeExec('npm prefix -g');
+  if (npmPrefix.ok) console.log(chalk.gray(`   [诊断] npm prefix -g = ${npmPrefix.output}`));
+  for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+    const which = safeExec(process.platform === 'win32' ? `where ${name} 2>nul` : `/bin/zsh -lc "command -v ${name}" 2>/dev/null || /bin/bash -lc "command -v ${name}" 2>/dev/null`);
+    if (which.ok && which.output) console.log(chalk.gray(`   [诊断] ${name} -> ${which.output.split('\n')[0].trim()}`));
+  }
+  if (isDockerAvailable()) {
+    const dContainers = findOpenclawDockerContainers();
+    if (dContainers.length > 0) {
+      console.log(chalk.gray(`   [诊断] Docker 容器 (含 openclaw/clawdbot/moltbot):`));
+      for (const c of dContainers) {
+        console.log(chalk.gray(`     - ${c.name} (${c.image}) [${c.cli}: ${c.cliPath}]`));
+      }
+    }
+  }
 }
 
 // Gateway API 测试 - 通过本地 Gateway 端口测试

package/install.ps1

@@ -2,7 +2,7 @@
 # maxapi 一键环境安装脚本（Windows PowerShell）
 # 用法（Node.js 不存在时，先装 Node.js 再 npx）:
 #   .\install.ps1
-#   $env:PACKAGE='llmaxapi'; .\install.ps1
+#   $env:PACKAGE='maxai'; .\install.ps1
 # ============================================================
 
 $ErrorActionPreference = "Stop"

package/install.sh

@@ -3,7 +3,6 @@
 # maxapi 一键环境安装脚本（macOS / Linux / WSL）
 # 用法（Node.js 不存在时，先装 Node.js 再 npx）:
 #   bash install.sh
-#   bash install.sh llmaxapi
 #   bash install.sh --no-run
 # ============================================================
 set -euo pipefail
@@ -16,7 +15,7 @@ MIN_NODE_MAJOR=18
 for arg in "$@"; do
   case "$arg" in
     --no-run) NO_RUN=true ;;
-    yymaxapi|llmaxapi) PACKAGE="$arg" ;;
+    yymaxapi) PACKAGE="$arg" ;;
   esac
 done
 

package/package.json

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