claw-subagent-service 0.0.89 → 0.0.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claw-subagent-service",
-  "version": "0.0.89",
+  "version": "0.0.91",
   "description": "虾说智能助手",
   "main": "cli.js",
   "bin": {

package/service/modules/openclaw-control.js

@@ -85,42 +85,72 @@ async function manageWithServiceManager(command) {
 
 /**
  * 使用 ScriptExecutor 执行脚本（Docker 模式）
+ * @returns {Object} { result, output }
  */
 async function executeWithScript(command) {
   const executor = getExecutor();
   const scriptName = getScriptName(command);
   
   try {
-    return await executor.executeWithStatus(command, scriptName);
+    const result = await executor.executeWithStatus(command, scriptName);
+    // ScriptExecutor 现在返回 { status, message, output }
+    return { 
+      result: { status: result.status, message: result.message },
+      output: result.output || ''
+    };
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     console.log(`[OpenClawControl] 脚本执行异常: ${msg}`);
     return {
-      status: OpenClawServiceStatus.ERROR,
-      message: `执行异常: ${msg}`
+      result: {
+        status: OpenClawServiceStatus.ERROR,
+        message: `执行异常: ${msg}`
+      },
+      output: ''
     };
   }
 }
 
 /**
  * 验证命令执行结果
+ * 
+ * 注意：在 Docker 环境中，端口检查可能不可靠（服务可能绑定到特定网络接口）
+ * 因此，如果脚本输出明确指示成功，但端口检查失败，会给出警告但保留脚本结果
  */
-async function verifyCommandResult(command, result) {
+async function verifyCommandResult(command, result, scriptOutput = '') {
   if (result.status === OpenClawServiceStatus.ERROR) {
     return result;
   }
   
+  const outputUpper = (scriptOutput || '').toUpperCase();
+  
   if (command === OpenClawCommandEnum.STOP) {
     // 等待 3 秒后验证端口
     await new Promise(resolve => setTimeout(resolve, 3000));
     const portStatus = await getOpenClawStatus(18789);
-    console.log(`[OpenClawControl] 停止后端口状态: ${portStatus === 1 ? '运行中' : '未运行'}`);
+    console.log(`[OpenClawControl] 停止后端口状态: ${portStatus}`);
     
     if (portStatus === 1) {
+      // 端口仍在监听，但检查脚本是否报告已停止
+      if (outputUpper.includes('SUCCESS') || outputUpper.includes('STOPPED')) {
+        console.warn(`[OpenClawControl] 警告: 端口仍在监听，但脚本报告成功。可能是僵尸进程或服务未正确停止。`);
+        // 仍然返回成功，但附带警告信息
+        return {
+          status: result.status,
+          message: result.message + ' (警告: 端口仍在监听)'
+        };
+      }
       return {
         status: OpenClawServiceStatus.ERROR,
         message: '停止失败: 服务仍在运行'
       };
+    } else if (portStatus === 2) {
+      // 进程存在但端口未监听，可能服务正在停止中
+      console.warn(`[OpenClawControl] 警告: openclaw 进程仍存在但端口已关闭。`);
+      return {
+        status: result.status,
+        message: result.message + ' (警告: 进程仍存在)'
+      };
     }
   } else if (command === OpenClawCommandEnum.START || command === OpenClawCommandEnum.RESTART) {
     // 等待服务启动
@@ -131,17 +161,33 @@ async function verifyCommandResult(command, result) {
     while (attempts < maxWait) {
       await new Promise(resolve => setTimeout(resolve, 2000));
       portStatus = await getOpenClawStatus(18789);
-      if (portStatus === 1) break;
+      if (portStatus === 1 || portStatus === 2) break; // 端口监听或进程存在都算成功
       attempts++;
     }
     
-    console.log(`[OpenClawControl] ${getCommandName(command)}后端口状态: ${portStatus === 1 ? '运行中' : '未运行'}`);
+    console.log(`[OpenClawControl] ${getCommandName(command)}后端口状态: ${portStatus}`);
     
     if (portStatus === 0) {
+      // 端口未监听且进程不存在，但检查脚本是否报告成功
+      if (outputUpper.includes('SUCCESS') || outputUpper.includes('ALREADY RUNNING')) {
+        console.warn(`[OpenClawControl] 警告: 端口检查失败，但脚本报告成功。服务可能绑定到其他网络接口。`);
+        // 信任脚本结果，但添加警告
+        return {
+          status: result.status,
+          message: result.message + ' (警告: 端口检查可能不准确)'
+        };
+      }
       return {
         status: OpenClawServiceStatus.ERROR,
         message: `${getCommandName(command)}失败: 服务未运行`
       };
+    } else if (portStatus === 2) {
+      // 进程存在但端口未监听，服务可能在启动中或绑定到其他地址
+      console.warn(`[OpenClawControl] 警告: openclaw 进程存在但端口 ${portStatus} 未监听。`);
+      return {
+        status: result.status === OpenClawServiceStatus.START_SUCCESS ? result.status : OpenClawServiceStatus.START_SUCCESS,
+        message: result.message + ' (进程已启动，端口检查可能不准确)'
+      };
     }
   }
   
@@ -160,12 +206,15 @@ async function executeCommand(command, window, sendResponse) {
   }
   
   // 如果 ServiceManager 失败或不是 Linux/macOS，使用脚本方式
+  let scriptOutput = '';
   if (!result) {
-    result = await executeWithScript(command);
+    const scriptResult = await executeWithScript(command);
+    result = scriptResult.result;
+    scriptOutput = scriptResult.output;
   }
   
-  // 验证结果
-  result = await verifyCommandResult(command, result);
+  // 验证结果（传递脚本输出用于后备检查）
+  result = await verifyCommandResult(command, result, scriptOutput);
 
   // 输出日志
   if (result.status === OpenClawServiceStatus.START_SUCCESS ||

package/service/modules/port-checker.js

@@ -1,31 +1,162 @@
 const net = require('net');
+const os = require('os');
+const { execSync } = require('child_process');
 
-function checkPortListening(port) {
+function checkPortListening(port, host = '127.0.0.1') {
   return new Promise((resolve) => {
     const sock = new net.Socket();
-    sock.setTimeout(3000);
+    sock.setTimeout(5000);
+    
+    console.log(`[PortChecker] 尝试连接 ${host}:${port}`);
+    
     sock.once('connect', () => {
+      console.log(`[PortChecker] 成功连接到 ${host}:${port}`);
       sock.destroy();
       resolve(true);
     });
-    sock.once('error', () => {
+    
+    sock.once('error', (err) => {
+      console.log(`[PortChecker] 连接 ${host}:${port} 失败: ${err.code} - ${err.message}`);
       sock.destroy();
       resolve(false);
     });
+    
     sock.once('timeout', () => {
+      console.log(`[PortChecker] 连接 ${host}:${port} 超时`);
       sock.destroy();
       resolve(false);
     });
-    sock.connect(port, '127.0.0.1');
+    
+    sock.connect(port, host);
   });
 }
 
+/**
+ * 检查端口是否在所有网络接口上监听
+ * Docker 环境中，服务可能绑定到 0.0.0.0 而不是 127.0.0.1
+ */
+async function checkPortOnAllInterfaces(port) {
+  // 先检查 localhost
+  const localhostListening = await checkPortListening(port, '127.0.0.1');
+  if (localhostListening) return true;
+
+  // 再检查 0.0.0.0（所有接口）
+  const allInterfacesListening = await checkPortListening(port, '0.0.0.0');
+  if (allInterfacesListening) return true;
+
+  // 获取所有网络接口并逐一检查
+  const interfaces = os.networkInterfaces();
+  for (const [name, addrs] of Object.entries(interfaces)) {
+    for (const addr of addrs) {
+      if (addr.family === 'IPv4' && !addr.internal) {
+        const listening = await checkPortListening(port, addr.address);
+        if (listening) {
+          console.log(`[PortChecker] 端口 ${port} 在 ${addr.address} (${name}) 上监听`);
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * 通过系统命令检查端口是否监听（备选方法）
+ * 当 net.Socket 连接失败时使用
+ */
+function checkPortViaSystemCommand(port) {
+  try {
+    // 按优先级尝试多种工具
+    const commands = [
+      `ss -tlnp 2>/dev/null | grep -q ":${port} " && echo "found"`,
+      `netstat -tlnp 2>/dev/null | grep -q ":${port} " && echo "found"`,
+      `lsof -i :${port} 2>/dev/null | grep -q LISTEN && echo "found"`,
+      `fuser ${port}/tcp 2>/dev/null | grep -q '[0-9]' && echo "found"`
+    ];
+    
+    for (const cmd of commands) {
+      try {
+        const result = execSync(cmd, { encoding: 'utf8', timeout: 5000 }).trim();
+        if (result === 'found') {
+          console.log(`[PortChecker] 系统命令检测到端口 ${port} 正在监听`);
+          return true;
+        }
+      } catch (e) {
+        // 命令失败，尝试下一个
+      }
+    }
+  } catch (e) {
+    console.error(`[PortChecker] 系统命令检查端口失败: ${e.message}`);
+  }
+  return false;
+}
+
+/**
+ * 检查 openclaw 进程是否存在
+ */
+function checkProcessExists() {
+  try {
+    // 尝试多种方法检查进程
+    const commands = [
+      'ps aux | grep -v grep | grep openclaw',
+      'pgrep -f openclaw',
+      'pidof openclaw'
+    ];
+    
+    for (const cmd of commands) {
+      try {
+        const output = execSync(cmd, { 
+          encoding: 'utf8', 
+          timeout: 5000 
+        }).trim();
+        
+        if (output) {
+          console.log(`[PortChecker] 检测到 openclaw 进程存在 (通过: ${cmd.split(' ')[0]})`);
+          console.log(`[PortChecker] 进程信息: ${output.split('\n')[0]}`);
+          return true;
+        }
+      } catch (e) {
+        // 命令失败，尝试下一个
+      }
+    }
+    
+    console.log(`[PortChecker] 未检测到 openclaw 进程`);
+  } catch (e) {
+    console.error(`[PortChecker] 进程检查失败: ${e.message}`);
+  }
+  return false;
+}
+
 async function getOpenClawStatus(port = 18789) {
-  const isListening = await checkPortListening(port);
-  return isListening ? 1 : 0;
+  // 方法1: 通过 net.Socket 检查端口
+  const isListening = await checkPortOnAllInterfaces(port);
+  if (isListening) {
+    console.log(`[PortChecker] 端口 ${port} 检测为运行中（net.Socket）`);
+    return 1;
+  }
+  
+  // 方法2: 通过系统命令检查端口
+  const isListeningViaCmd = checkPortViaSystemCommand(port);
+  if (isListeningViaCmd) {
+    console.log(`[PortChecker] 端口 ${port} 检测为运行中（系统命令）`);
+    return 1;
+  }
+  
+  // 方法3: 检查进程是否存在（备选）
+  const processExists = checkProcessExists();
+  if (processExists) {
+    console.warn(`[PortChecker] 警告: openclaw 进程存在，但端口 ${port} 未监听。可能绑定到其他端口或地址。`);
+    // 进程存在但端口未监听，返回特殊状态 2
+    return 2;
+  }
+  
+  console.log(`[PortChecker] 端口 ${port} 检测为未运行`);
+  return 0;
 }
 
 module.exports = {
   checkPortListening,
+  checkPortOnAllInterfaces,
   getOpenClawStatus,
 };

package/service/modules/rongyun-message-handler.js

@@ -326,9 +326,20 @@ class RongyunMessageHandler {
       // 获取 OpenClaw 运行状态（检查端口 18789）
       const openClawStatus = await getOpenClawStatus();
       
-      // 构建精简状态数据（避免超过融云 128KB 限制）
+      // 构建状态数据
+      // openClawStatus: 1=端口监听正常, 2=进程存在但端口未监听, 0=未运行
+      let statusMessage;
+      if (openClawStatus === 1) {
+        statusMessage = '运行中';
+      } else if (openClawStatus === 2) {
+        statusMessage = '运行中(端口异常)';
+      } else {
+        statusMessage = '未运行';
+      }
+      
       const statusData = {
-        open_claw_status: openClawStatus,  // 1=运行中, 0=未运行
+        open_claw_status: openClawStatus,  // 1=运行中, 2=进程存在但端口未监听, 0=未运行
+        status_message: statusMessage,
         mac_address: getMacAddress(),
         version: '0.0.20',
         timestamp: Date.now(),

package/service/modules/script-executor.js

@@ -103,11 +103,16 @@ class ScriptExecutor {
         console.log(`[ScriptExecutor] 停止脚本退出码非零(${exitCode})，返回错误`);
         return { 
           status: OpenClawServiceStatus.ERROR, 
-          message: `停止失败: 脚本退出码 ${exitCode}` 
+          message: `停止失败: 脚本退出码 ${exitCode}`,
+          output: fullOutput
         };
       }
       
-      return result;
+      // 返回结果时附带原始输出
+      return {
+        ...result,
+        output: fullOutput
+      };
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       return { status: OpenClawServiceStatus.ERROR, message: `执行异常: ${msg}` };