yymaxapi 1.0.26 → 1.0.28

package/bin/yymaxapi.js

@@ -708,11 +708,191 @@ 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;
+  // 优先用 docker ps（权限要求更低），fallback 到 docker info
+  const r = safeExec('docker ps --no-trunc -q', { timeout: 8000 });
+  if (r.ok) { _dockerAvailCache = true; return true; }
+  const r2 = safeExec('docker info', { timeout: 8000 });
+  if (r2.ok) { _dockerAvailCache = true; return true; }
+  // 可能需要 sudo
+  const r3 = safeExec('sudo -n docker ps -q', { timeout: 8000 });
+  _dockerAvailCache = r3.ok;
+  return _dockerAvailCache;
+}
+
+// 封装 docker 命令（自动处理 sudo）
+let _dockerNeedsSudo = null;
+function dockerCmd(cmd) {
+  if (_dockerNeedsSudo === null) {
+    const test = safeExec('docker ps -q', { timeout: 5000 });
+    _dockerNeedsSudo = !test.ok;
+  }
+  return _dockerNeedsSudo ? `sudo -n docker ${cmd}` : `docker ${cmd}`;
+}
+
+// 查找包含 openclaw/clawdbot/moltbot 的运行中容器
+function findOpenclawDockerContainers() {
+  if (_dockerContainerCache !== null) return _dockerContainerCache;
+  if (!isDockerAvailable()) { _dockerContainerCache = []; return []; }
+
+  const ps = safeExec(dockerCmd('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) {
+    // 兼容 tab 分隔和空格分隔
+    const parts = line.includes('\t') ? line.split('\t') : line.split(/\s{2,}/);
+    const [id, name, image, ...statusParts] = parts;
+    const status = statusParts.join(' ');
+    if (!id) continue;
+
+    // 检查容器内是否有 openclaw/clawdbot/moltbot（用 command -v 代替 which，兼容精简镜像）
+    for (const cli of ['openclaw', 'clawdbot', 'moltbot']) {
+      const check = safeExec(dockerCmd(`exec ${id} sh -c "command -v ${cli} 2>/dev/null || which ${cli} 2>/dev/null"`), { timeout: 8000 });
+      if (check.ok && check.output && check.output.trim()) {
+        containers.push({ id, name, image, status, cli, cliPath: check.output.trim() });
+        break;
+      }
+    }
+
+    // 也检查常见路径（不依赖 which/command -v）
+    if (!containers.find(c => c.id === id)) {
+      const knownPaths = [
+        '/opt/moltbot/moltbot.mjs',
+        '/opt/moltbot/bin/moltbot.mjs',
+        '/opt/moltbot/bin/moltbot.js',
+        '/opt/moltbot/src/moltbot.mjs',
+        '/usr/local/bin/openclaw',
+        '/usr/local/bin/clawdbot',
+        '/usr/local/bin/moltbot',
+      ];
+      for (const p of knownPaths) {
+        const check = safeExec(dockerCmd(`exec ${id} sh -c "test -f '${p}' && echo '${p}'"`), { timeout: 5000 });
+        if (check.ok && check.output && check.output.trim()) {
+          const isMjs = p.endsWith('.mjs') || p.endsWith('.js');
+          const cliName = isMjs ? 'node' : path.basename(p);
+          containers.push({ id, name, image, status, cli: cliName, cliPath: p });
+          break;
+        }
+      }
+    }
+
+    // 最后检查容器镜像名/容器名是否包含关键字（即使内部 CLI 路径未知）
+    if (!containers.find(c => c.id === id)) {
+      const combined = `${name} ${image}`.toLowerCase();
+      if (/openclaw|clawdbot|moltbot/.test(combined)) {
+        // 尝试在容器内找任何 node 进程带 gateway 关键字
+        const findProc = safeExec(dockerCmd(`exec ${id} sh -c "ps aux 2>/dev/null | grep -E 'openclaw|clawdbot|moltbot' | grep -v grep | head -1"`), { timeout: 5000 });
+        if (findProc.ok && findProc.output && findProc.output.trim()) {
+          containers.push({ id, name, image, status, cli: 'unknown', cliPath: '' });
+        }
+      }
+    }
+  }
+
+  _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(dockerCmd(`exec ${containerId} bash -lc '${escaped}'`), { timeout: 30000, ...options });
+}
+
+// 在 Docker 容器内异步执行命令（后台启动 gateway 等）
+function spawnDetachedInDocker(containerId, cmd, env = {}) {
+  try {
+    const prefix = _dockerNeedsSudo ? 'sudo' : 'docker';
+    const args = _dockerNeedsSudo
+      ? ['-n', 'docker', 'exec', '-d', containerId, 'bash', '-lc', cmd]
+      : ['exec', '-d', containerId, 'bash', '-lc', cmd];
+    const child = spawn(prefix, args, {
+      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(dockerCmd(`exec ${containerId} mkdir -p "${dir}"`), { timeout: 5000 });
+      const cp = safeExec(dockerCmd(`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 +938,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 +980,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 +1009,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: dockerCmd(`exec ${_selectedDockerContainer.id} bash -lc '${escaped}'`), options };
+  }
   return { cmd, options };
 }
 
@@ -848,6 +1054,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(dockerCmd(`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 +1692,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();
@@ -2630,6 +2873,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 +2903,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 +3044,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 = dockerCmd(`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 +3131,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(dockerCmd(`exec ${cid} bash -c "pkill -f '${name}.*gateway' 2>/dev/null || true"`), { timeout: 5000 });
+      }
+      safeExec(dockerCmd(`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 +3299,21 @@ async function restartGatewayNative() {
     }
   }
 
+  // Docker: 追加 Docker 容器命令作为额外回退
+  if (isDockerAvailable()) {
+    const dockerContainers = findOpenclawDockerContainers();
+    for (const c of dockerContainers) {
+      if (c.cli === 'node') {
+        commands.push(dockerCmd(`exec ${c.id} bash -lc "node ${c.cliPath} gateway restart"`));
+      } else if (c.cli !== 'unknown') {
+        commands.push(dockerCmd(`exec ${c.id} bash -lc "${c.cli} gateway restart"`));
+      }
+      for (const name of ['openclaw', 'clawdbot', 'moltbot']) {
+        commands.push(dockerCmd(`exec ${c.id} bash -lc "${name} gateway restart"`));
+      }
+    }
+  }
+
   return new Promise((resolve) => {
     let tried = 0;
 
@@ -2969,6 +3331,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.26",
+  "version": "1.0.28",
   "description": "跨平台 OpenClaw/Clawdbot 配置管理工具 - 管理中转地址、模型切换、API Keys、测速优化",
   "main": "bin/yymaxapi.js",
   "bin": {