claw-subagent-service 0.0.90 → 0.0.91

package/package.json

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

package/service/modules/openclaw-control.js

@@ -128,7 +128,7 @@ async function verifyCommandResult(command, result, scriptOutput = '') {
     // 等待 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) {
       // 端口仍在监听，但检查脚本是否报告已停止
@@ -144,6 +144,13 @@ async function verifyCommandResult(command, result, scriptOutput = '') {
         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) {
     // 等待服务启动
@@ -154,14 +161,14 @@ async function verifyCommandResult(command, result, scriptOutput = '') {
     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] 警告: 端口检查失败，但脚本报告成功。服务可能绑定到其他网络接口。`);
         // 信任脚本结果，但添加警告
@@ -174,6 +181,13 @@ async function verifyCommandResult(command, result, scriptOutput = '') {
         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 + ' (进程已启动，端口检查可能不准确)'
+      };
     }
   }
   

package/service/modules/port-checker.js

@@ -1,22 +1,32 @@
 const net = require('net');
 const os = require('os');
+const { execSync } = require('child_process');
 
 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, host);
   });
 }
@@ -51,9 +61,98 @@ async function checkPortOnAllInterfaces(port) {
   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) {
+  // 方法1: 通过 net.Socket 检查端口
   const isListening = await checkPortOnAllInterfaces(port);
-  return isListening ? 1 : 0;
+  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 = {

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(),