yymaxapi 1.0.25 → 1.0.27

package/bin/yymaxapi.js

@@ -708,11 +708,146 @@ function writeConfigWithSync(paths, config) {
   if (gwEnv === 'wsl') {
     syncConfigToWsl(paths.openclawConfig);
   }
+  // 如果 Gateway 在 Docker 容器内，自动同步配置过去
+  if (gwEnv === 'docker' && _selectedDockerContainer) {
+    syncConfigToDocker(paths.openclawConfig, _selectedDockerContainer.id);
+  }
+}
+
+// ============ Docker 容器发现与操作 ============
+let _dockerAvailCache = null;
+let _dockerContainerCache = null;
+let _selectedDockerContainer = null;
+
+function isDockerAvailable() {
+  if (_dockerAvailCache !== null) return _dockerAvailCache;
+  const r = safeExec('docker info', { timeout: 5000 });
+  _dockerAvailCache = r.ok;
+  return _dockerAvailCache;
+}
+
+// 查找包含 openclaw/clawdbot/moltbot 的运行中容器
+function findOpenclawDockerContainers() {
+  if (_dockerContainerCache !== null) return _dockerContainerCache;
+  if (!isDockerAvailable()) { _dockerContainerCache = []; return []; }
+
+  const ps = safeExec('docker ps --format "{{.ID}}\\t{{.Names}}\\t{{.Image}}\\t{{.Status}}"', { timeout: 10000 });
+  if (!ps.ok || !ps.output) { _dockerContainerCache = []; return []; }
+
+  const containers = [];
+  const lines = ps.output.split('\n').filter(Boolean);
+
+  for (const line of lines) {
+    const [id, name, image, ...statusParts] = line.split('\t');
+    const status = statusParts.join('\t');
+    if (!id) continue;
+
+    // 检查容器内是否有 openclaw/clawdbot/moltbot
+    for (const cli of ['openclaw', 'clawdbot', 'moltbot']) {
+      const check = safeExec(`docker exec ${id} which ${cli} 2>/dev/null`, { timeout: 5000 });
+      if (check.ok && check.output) {
+        containers.push({ id, name, image, status, cli, cliPath: check.output.trim() });
+        break; // 一个容器只记录一次
+      }
+    }
+
+    // 也检查 /opt/moltbot 等常见路径
+    if (!containers.find(c => c.id === id)) {
+      for (const p of ['/opt/moltbot/moltbot.mjs', '/opt/moltbot/bin/moltbot.mjs']) {
+        const check = safeExec(`docker exec ${id} test -f ${p} && echo found`, { timeout: 5000 });
+        if (check.ok && check.output && check.output.includes('found')) {
+          containers.push({ id, name, image, status, cli: 'node', cliPath: p });
+          break;
+        }
+      }
+    }
+  }
+
+  _dockerContainerCache = containers;
+  return containers;
+}
+
+// 交互式选择 Docker 容器
+async function selectDockerContainer() {
+  if (_selectedDockerContainer) return _selectedDockerContainer;
+
+  const containers = findOpenclawDockerContainers();
+  if (containers.length === 0) return null;
+
+  if (containers.length === 1) {
+    _selectedDockerContainer = containers[0];
+    console.log(chalk.green(`✅ 自动选择 Docker 容器: ${containers[0].name} (${containers[0].image})`));
+    return _selectedDockerContainer;
+  }
+
+  // 多个容器，让用户选择
+  console.log(chalk.cyan('\n检测到多个包含 OpenClaw/Clawdbot/Moltbot 的 Docker 容器:'));
+  const { selected } = await inquirer.prompt([{
+    type: 'list',
+    name: 'selected',
+    message: '请选择要操作的容器:',
+    choices: containers.map((c, i) => ({
+      name: `${c.name} (${c.image}) [${c.cli}] - ${c.status}`,
+      value: i
+    }))
+  }]);
+
+  _selectedDockerContainer = containers[selected];
+  console.log(chalk.green(`✅ 已选择容器: ${_selectedDockerContainer.name}`));
+  return _selectedDockerContainer;
+}
+
+// 在 Docker 容器内执行命令
+function execInDocker(containerId, cmd, options = {}) {
+  const escaped = cmd.replace(/'/g, "'\\''");
+  return safeExec(`docker exec ${containerId} bash -lc '${escaped}'`, { timeout: 30000, ...options });
+}
+
+// 在 Docker 容器内异步执行命令（后台启动 gateway 等）
+function spawnDetachedInDocker(containerId, cmd, env = {}) {
+  try {
+    const child = spawn('docker', ['exec', '-d', containerId, 'bash', '-lc', cmd], {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...process.env, ...env }
+    });
+    child.unref();
+    return true;
+  } catch { return false; }
+}
+
+// 获取 Docker 容器内的 CLI 二进制路径
+function getDockerCliBinary(container) {
+  if (!container) return null;
+  return container.cliPath || null;
+}
+
+// 同步配置到 Docker 容器（将本地 openclaw.json 复制到容器内）
+function syncConfigToDocker(localConfigPath, containerId) {
+  try {
+    // 尝试多个目标路径
+    const targets = [
+      '/root/.openclaw/openclaw.json',
+      '/root/.clawdbot/openclaw.json',
+      '/root/.moltbot/moltbot.json',
+      '/home/.openclaw/openclaw.json',
+    ];
+    // 先确定容器内哪个配置目录存在
+    for (const target of targets) {
+      const dir = path.posix.dirname(target);
+      safeExec(`docker exec ${containerId} mkdir -p "${dir}"`, { timeout: 5000 });
+      const cp = safeExec(`docker cp "${localConfigPath}" ${containerId}:${target}`, { timeout: 10000 });
+      if (cp.ok) {
+        console.log(chalk.gray(`   已同步配置到 Docker 容器: ${target}`));
+        return;
+      }
+    }
+  } catch { /* best-effort */ }
 }
 
 // ============ Gateway 环境检测（集中化） ============
-// 所有 WSL 相关逻辑统一通过 detectGatewayEnv() 路由
-// 返回 'native' | 'wsl'，结果缓存，整个进程生命周期只检测一次
+// 所有 WSL/Docker 相关逻辑统一通过 detectGatewayEnv() 路由
+// 返回 'native' | 'wsl' | 'docker'，结果缓存，整个进程生命周期只检测一次
 
 let _gwEnvCache = null;
 let _wslAvailCache = null;
@@ -758,7 +893,20 @@ function getWslCliBinary() {
 
 function detectGatewayEnv(port = 18789) {
   if (_gwEnvCache !== null) return _gwEnvCache;
+
+  // 非 Windows 平台：先检查本地 CLI，找不到再检查 Docker
   if (process.platform !== 'win32' || !isWslAvailable()) {
+    const nativeCli = resolveCliBinary();
+    if (nativeCli) {
+      _gwEnvCache = 'native';
+      return 'native';
+    }
+    // 本地没有 CLI，检查 Docker 容器
+    const dockerContainers = findOpenclawDockerContainers();
+    if (dockerContainers.length > 0) {
+      _gwEnvCache = 'docker';
+      return 'docker';
+    }
     _gwEnvCache = 'native';
     return 'native';
   }
@@ -787,17 +935,26 @@ function detectGatewayEnv(port = 18789) {
       _gwEnvCache = 'wsl';
       return 'wsl';
     }
+    // Fallback: 检查 Docker 容器
+    const dockerContainers = findOpenclawDockerContainers();
+    if (dockerContainers.length > 0) {
+      _gwEnvCache = 'docker';
+      return 'docker';
+    }
   }
   _gwEnvCache = 'native';
   return 'native';
 }
 
-// 在 Gateway 环境中执行命令（WSL 自动包裹 wsl -- bash -lc）
+// 在 Gateway 环境中执行命令（WSL/Docker 自动包裹）
 function execInGatewayEnv(cmd, options = {}) {
   if (detectGatewayEnv() === 'wsl') {
     const escaped = cmd.replace(/'/g, "'\\''");
     return safeExec(`wsl -- bash -lc '${escaped}'`, options);
   }
+  if (detectGatewayEnv() === 'docker' && _selectedDockerContainer) {
+    return execInDocker(_selectedDockerContainer.id, cmd, options);
+  }
   return safeExec(cmd, options);
 }
 
@@ -807,6 +964,10 @@ function execAsyncInGatewayEnv(cmd, options = {}) {
     const escaped = cmd.replace(/'/g, "'\\''");
     return { cmd: `wsl -- bash -lc '${escaped}'`, options };
   }
+  if (detectGatewayEnv() === 'docker' && _selectedDockerContainer) {
+    const escaped = cmd.replace(/'/g, "'\\''");
+    return { cmd: `docker exec ${_selectedDockerContainer.id} bash -lc '${escaped}'`, options };
+  }
   return { cmd, options };
 }
 
@@ -848,6 +1009,14 @@ function cleanupAgentProcesses() {
         execSync(`pkill -f '${name}.*agent' 2>/dev/null || true`, { stdio: 'ignore' });
       }
     }
+    // Docker 容器内的 agent 也要清理
+    if (detectGatewayEnv() === 'docker' && _selectedDockerContainer) {
+      try {
+        for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+          safeExec(`docker exec ${_selectedDockerContainer.id} bash -c "pkill -f '${name}.*agent' 2>/dev/null || true"`, { timeout: 10000 });
+        }
+      } catch { /* ignore */ }
+    }
     console.log(chalk.gray('已清理残留 agent 进程'));
   } catch { /* ignore */ }
 }
@@ -1478,6 +1647,35 @@ function installMacGatewayDaemon() {
 async function tryAutoStartGateway(port, allowAutoDaemon) {
   const isRoot = typeof process.getuid === 'function' && process.getuid() === 0;
 
+  // Docker 容器内启动 Gateway
+  if (detectGatewayEnv() === 'docker') {
+    const container = await selectDockerContainer();
+    if (!container) return { started: false };
+
+    console.log(chalk.yellow(`⚠️ Gateway 未检测到运行，尝试在 Docker 容器 ${container.name} 内启动...`));
+
+    const dockerCmds = [];
+    if (container.cli === 'node') {
+      dockerCmds.push(`node ${container.cliPath} gateway`);
+    } else {
+      dockerCmds.push(`${container.cli} gateway`);
+    }
+    for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+      dockerCmds.push(`${name} gateway`);
+    }
+
+    for (const cmd of [...new Set(dockerCmds)].filter(Boolean)) {
+      console.log(chalk.yellow(`⚠️ 尝试在容器内启动 Gateway: ${cmd}`));
+      if (spawnDetachedInDocker(container.id, cmd)) {
+        if (await waitForGateway(port, '127.0.0.1', 15000)) {
+          console.log(chalk.green(`✅ Gateway 已在 Docker 容器 ${container.name} 内启动`));
+          return { started: true, method: 'docker', container: container.name };
+        }
+      }
+    }
+    return { started: false };
+  }
+
   if (process.platform === 'darwin' && allowAutoDaemon) {
     console.log(chalk.yellow('⚠️ Gateway 未检测到运行，尝试在 macOS 后台启动 (LaunchAgent)...'));
     const daemonResult = installMacGatewayDaemon();
@@ -1873,21 +2071,21 @@ async function presetClaude(paths, args = {}) {
 
     const sorted = speedResult.ranked || [];
     if (sorted.length > 0) {
+      const defaultEp = ENDPOINTS[0];
       const { selectedIndex } = await inquirer.prompt([{
         type: 'list',
         name: 'selectedIndex',
         message: '选择节点:',
         choices: [
-          { name: `* 使用推荐节点 (${sorted[0].name}, ${sorted[0].latency}ms, 评分:${sorted[0].score})`, value: -1 },
-          new inquirer.Separator('  ---- 或手动选择 ----'),
+          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
+          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
           ...sorted.map((e, i) => ({
             name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
             value: i
           }))
         ]
       }]);
-      const primaryIndex = selectedIndex === -1 ? 0 : selectedIndex;
-      selectedEndpoint = sorted[primaryIndex];
+      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
       if (speedResult.usedFallback) {
         console.log(chalk.yellow(`\n⚠ 当前使用备用节点\n`));
       }
@@ -2070,21 +2268,21 @@ async function presetCodex(paths, args = {}) {
 
     const sorted = speedResult.ranked || [];
     if (sorted.length > 0) {
+      const defaultEp = ENDPOINTS[0];
       const { selectedIndex } = await inquirer.prompt([{
         type: 'list',
         name: 'selectedIndex',
         message: '选择节点:',
         choices: [
-          { name: `* 使用推荐节点 (${sorted[0].name}, ${sorted[0].latency}ms, 评分:${sorted[0].score})`, value: -1 },
-          new inquirer.Separator('  ---- 或手动选择 ----'),
+          { name: `* 使用默认节点 (${defaultEp.name})`, value: -1 },
+          new inquirer.Separator('  ---- 或按测速结果选择 ----'),
           ...sorted.map((e, i) => ({
             name: `${e.name} - ${e.latency}ms (评分:${e.score})`,
             value: i
           }))
         ]
       }]);
-      const primaryIndex = selectedIndex === -1 ? 0 : selectedIndex;
-      selectedEndpoint = sorted[primaryIndex];
+      selectedEndpoint = selectedIndex === -1 ? defaultEp : sorted[selectedIndex];
       if (speedResult.usedFallback) {
         console.log(chalk.yellow(`\n⚠ 当前使用备用节点\n`));
       }
@@ -2630,6 +2828,16 @@ async function testConnection(paths, args = {}) {
 
   const allowAutoDaemon = !(args['no-daemon'] || args.noDaemon);
 
+  // 如果检测到 Docker 环境，先让用户选择容器
+  if (detectGatewayEnv() === 'docker') {
+    const container = await selectDockerContainer();
+    if (!container) {
+      console.log(chalk.red('❌ 未找到包含 OpenClaw/Clawdbot/Moltbot 的 Docker 容器'));
+      console.log(chalk.gray('   请确保容器正在运行且已安装 openclaw/clawdbot/moltbot'));
+      return;
+    }
+  }
+
   // 步骤0: 清理所有挂死的 agent 进程
   cleanupAgentProcesses();
 
@@ -2650,9 +2858,15 @@ async function testConnection(paths, args = {}) {
 
   if (!gatewayRunning) {
     gwSpinner.fail('Gateway 未运行');
-    console.log(chalk.gray('   请在新的终端执行: openclaw gateway'));
-    console.log(chalk.gray('   或: clawdbot gateway'));
-    console.log(chalk.gray('   或: moltbot gateway'));
+    if (detectGatewayEnv() === 'docker' && _selectedDockerContainer) {
+      console.log(chalk.gray(`   请在 Docker 容器内启动 Gateway:`));
+      console.log(chalk.gray(`   docker exec -it ${_selectedDockerContainer.id} bash`));
+      console.log(chalk.gray(`   然后执行: ${_selectedDockerContainer.cli === 'node' ? `node ${_selectedDockerContainer.cliPath}` : _selectedDockerContainer.cli} gateway`));
+    } else {
+      console.log(chalk.gray('   请在新的终端执行: openclaw gateway'));
+      console.log(chalk.gray('   或: clawdbot gateway'));
+      console.log(chalk.gray('   或: moltbot gateway'));
+    }
     return;
   }
 
@@ -2785,6 +2999,50 @@ async function restartGateway() {
 
   const gwEnv = detectGatewayEnv();
 
+  // 如果 Gateway 在 Docker 容器里，通过 docker exec 重启
+  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') {
+      // 脚本路径模式（如 /opt/moltbot/moltbot.mjs）
+      dockerCmds.push(`node ${container.cliPath} gateway restart`);
+    } else {
+      dockerCmds.push(`${container.cli} gateway restart`);
+    }
+    // 通用回退
+    for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+      dockerCmds.push(`${name} gateway restart`);
+    }
+
+    return new Promise((resolve) => {
+      let tried = 0;
+      const tryNext = () => {
+        if (tried >= dockerCmds.length) {
+          console.log(chalk.yellow('Docker 容器内 Gateway 重启失败，尝试本地重启...'));
+          restartGatewayNative().then(resolve);
+          return;
+        }
+        const cmd = dockerCmds[tried++];
+        const fullCmd = `docker exec ${container.id} bash -lc "${cmd}"`;
+        exec(fullCmd, { timeout: 30000 }, (error) => {
+          if (error) {
+            tryNext();
+          } else {
+            console.log(chalk.green(`✅ Gateway 已重启 (Docker: ${container.name})`));
+            resolve(true);
+          }
+        });
+      };
+      tryNext();
+    });
+  }
+
   // 如果 Gateway 在 WSL 里，优先用 wsl -- 重启
   if (gwEnv === 'wsl') {
     console.log(chalk.gray('   [检测] Gateway 运行在 WSL 中'));
@@ -2828,6 +3086,50 @@ async function restartGateway() {
 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} 内强制重启...`));
+
+    // 1. 杀掉容器内旧 Gateway 进程
+    try {
+      for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+        safeExec(`docker exec ${cid} bash -c "pkill -f '${name}.*gateway' 2>/dev/null || true"`, { timeout: 5000 });
+      }
+      safeExec(`docker exec ${cid} bash -c "lsof -ti :${gatewayPort} 2>/dev/null | xargs -r kill -9 2>/dev/null || true"`, { timeout: 5000 });
+      console.log(chalk.gray('   已尝试清理容器内旧 Gateway 进程'));
+    } catch { /* ignore */ }
+
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    // 2. 启动新 Gateway
+    const dockerCmds = [];
+    if (_selectedDockerContainer.cli === 'node') {
+      dockerCmds.push(`node ${_selectedDockerContainer.cliPath} gateway`);
+    } else {
+      dockerCmds.push(`${_selectedDockerContainer.cli} gateway`);
+    }
+    for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+      dockerCmds.push(`${name} gateway`);
+    }
+
+    for (const cmd of [...new Set(dockerCmds)].filter(Boolean)) {
+      console.log(chalk.gray(`   尝试在容器内启动: ${cmd}`));
+      if (spawnDetachedInDocker(cid, cmd)) {
+        if (await waitForGateway(gatewayPort, '127.0.0.1', 12000)) {
+          console.log(chalk.green(`✅ Gateway 已在 Docker 容器 ${cName} 内强制重启成功`));
+          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;
+  }
+
   // 1. 杀掉旧 Gateway 进程
   try {
     if (process.platform === 'win32') {
@@ -2952,6 +3254,21 @@ async function restartGatewayNative() {
     }
   }
 
+  // Docker: 追加 Docker 容器命令作为额外回退
+  if (isDockerAvailable()) {
+    const dockerContainers = findOpenclawDockerContainers();
+    for (const c of dockerContainers) {
+      if (c.cli === 'node') {
+        commands.push(`docker exec ${c.id} bash -lc "node ${c.cliPath} gateway restart"`);
+      } else {
+        commands.push(`docker exec ${c.id} bash -lc "${c.cli} gateway restart"`);
+      }
+      for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+        commands.push(`docker exec ${c.id} bash -lc "${name} gateway restart"`);
+      }
+    }
+  }
+
   return new Promise((resolve) => {
     let tried = 0;
 
@@ -2969,6 +3286,18 @@ async function restartGatewayNative() {
           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()}`));
         }
+        // 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 的容器`));
+          }
+        }
         // 尝试强制重启
         forceRestartGateway(resolved, nodeInfo, useNode, env).then(resolve);
         return;

package/package.json

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