claw-subagent-service 0.0.124 → 0.0.126

package/command/linux/stop.sh

@@ -224,9 +224,9 @@ stop_docker() {
             kill -15 "$p" 2>/dev/null || log_warn "kill -15 $p 失败"
         done
         
-        # 等待 3 秒让服务优雅退出
-        log_info "等待 3 秒让服务优雅退出..."
-        sleep 3
+        # 等待 5 秒让服务优雅退出
+        log_info "等待 5 秒让服务优雅退出..."
+        sleep 5
         
         # 检查是否已停止
         local pid_after_graceful
@@ -243,7 +243,20 @@ stop_docker() {
     
     # 强制停止模式（直接发送 SIGKILL）
     log_info "正在强制停止 OpenClaw 服务（SIGKILL）..."
-    for p in $all_pids; do
+    
+    # 获取最新的进程列表（因为优雅停止后可能有新进程）
+    local current_pids=""
+    if command -v pgrep &>/dev/null; then
+        current_pids=$(pgrep -f "openclaw" | tr '\n' ' ')
+    elif command -v pidof &>/dev/null; then
+        current_pids=$(pidof openclaw)
+    else
+        current_pids=$(ps aux | grep -v grep | grep "openclaw" | awk '{print $2}' | tr '\n' ' ')
+    fi
+    
+    log_info "当前 openclaw 进程: $current_pids"
+    
+    for p in $current_pids; do
         log_info "执行: kill -9 $p"
         kill -9 "$p" 2>/dev/null || log_warn "kill -9 $p 失败"
     done
@@ -253,12 +266,15 @@ stop_docker() {
     log_info "执行: killall -9 openclaw"
     killall -9 openclaw 2>/dev/null || log_warn "killall 失败"
     
+    # 等待 2 秒让进程退出
+    sleep 2
+    
     # 连续监控模式：每秒检查并杀死看门狗重启的进程
     # 这样即使看门狗立即重启，也会被再次杀死
-    log_info "进入连续监控模式（最多 15 秒），防止看门狗自动重启..."
+    log_info "进入连续监控模式（最多 20 秒），防止看门狗自动重启..."
     local elapsed=0
     local consecutive_empty=0
-    while [ $elapsed -lt 15 ]; do
+    while [ $elapsed -lt 20 ]; do
         sleep 1
         
         # 检查是否还有 openclaw 进程
@@ -291,6 +307,9 @@ stop_docker() {
             consecutive_empty=0
             if [ -n "$remaining_pids" ]; then
                 log_info "第 $elapsed 秒: 发现新进程 $remaining_pids，再次 kill..."
+                for rp in $remaining_pids; do
+                    kill -9 "$rp" 2>/dev/null || true
+                done
             fi
             if [ "$port_listening" = true ]; then
                 log_info "第 $elapsed 秒: 端口 $PORT 仍在监听，尝试 fuser 终止..."
@@ -305,6 +324,14 @@ stop_docker() {
         elapsed=$((elapsed + 1))
     done
     
+    # 最终验证前，再执行一次全面清理
+    log_info "执行最终清理..."
+    pkill -9 -f "openclaw" 2>/dev/null || true
+    killall -9 openclaw 2>/dev/null || true
+    
+    # 等待 2 秒
+    sleep 2
+    
     # 最终验证
     local remaining_pids=""
     if command -v pgrep &>/dev/null; then

package/package.json

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

package/service/modules/heartbeat-dashboard.js

@@ -20,13 +20,14 @@ class HeartbeatManager {
 
       try {
         const mac = getMacAddress();
+        // 真实检测 openclaw 状态（通过端口检查）
         const status = await getOpenClawStatus(this.config.openclawPort || 18789);
         const sent = await this.messageSender.sendProtocolMessage(
           RongyunMessageTypeEnum.HEARTBEAT,
           {
             mac_address: mac,
             nickname: this.config.nodeName,
-            open_claw_status: status,
+            open_claw_status: status,  // 1=运行中, 0=未运行（真实检测）
             client_status: 1,
           }
         );

package/service/modules/openclaw-control.js

@@ -136,101 +136,43 @@ async function verifyCommandResult(command, result, scriptOutput = '') {
   }
   
   if (command === OpenClawCommandEnum.STOP) {
-    // 停止命令验证：多次检查端口并重复执行停止，处理看门狗自动重启
+    // 停止命令验证：快速检查端口状态
     console.log(`[OpenClawControl] 开始验证停止结果...`);
 
-    let portStatus = 1;
-    let stopAttempts = 0;
-    const maxStopAttempts = 3; // 最多执行 3 次停止
+    // 等待 2 秒后检查
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    const portStatus = await getOpenClawStatus(18789);
+    console.log(`[OpenClawControl] 停止后端口状态: ${portStatus}`);
 
-    // 等待 3 秒，给看门狗一次重启机会，然后验证
-    await new Promise(resolve => setTimeout(resolve, 3000));
-
-    while (stopAttempts < maxStopAttempts) {
-      portStatus = await getOpenClawStatus(18789);
-      console.log(`[OpenClawControl] 停止后端口状态 (尝试 ${stopAttempts + 1}/${maxStopAttempts}): ${portStatus}`);
-
-      if (portStatus !== 1) {
-        console.log(`[OpenClawControl] 停止验证通过: 端口已关闭`);
-        break;
-      }
-
-      stopAttempts++;
-      if (stopAttempts < maxStopAttempts) {
-        console.log(`[OpenClawControl] 端口仍在监听，尝试第 ${stopAttempts + 1} 次停止...`);
-        const scriptResult = await executeWithScript(command);
-        const retryResult = scriptResult.result;
-        console.log(`[OpenClawControl] 第 ${stopAttempts} 次重试停止结果: ${retryResult.status} - ${retryResult.message}`);
-
-        // 等待看门狗重启后再检查
-        await new Promise(resolve => setTimeout(resolve, 3000));
-      }
-    }
-
-    if (portStatus === 1) {
-      console.error(`[OpenClawControl] 停止失败: 端口 18789 仍在监听。尝试强制停止...`);
-      
-      // 尝试强制停止
-      const forceScriptResult = await executeWithScript(command);
-      const forceResult = forceScriptResult.result;
-      console.log(`[OpenClawControl] 强制停止结果: ${forceResult.status} - ${forceResult.message}`);
-      
-      // 再次验证端口
-      await new Promise(resolve => setTimeout(resolve, 3000));
-      const finalPortStatus = await getOpenClawStatus(18789);
-      
-      if (finalPortStatus !== 1) {
-        console.log(`[OpenClawControl] 强制停止成功: 端口已关闭`);
-        return {
-          status: OpenClawServiceStatus.STOP_SUCCESS,
-          message: '服务已停止（强制停止）'
-        };
-      }
-      
-      console.error(`[OpenClawControl] 停止失败: 端口 18789 仍在监听。stop.sh 可能未能成功停止服务。`);
+    if (portStatus !== 1) {
+      console.log(`[OpenClawControl] 停止验证通过: 端口已关闭`);
+    } else {
+      console.error(`[OpenClawControl] 停止失败: 端口 18789 仍在监听。`);
       return {
         status: OpenClawServiceStatus.ERROR,
         message: '停止失败: 服务仍在运行'
       };
     }
-
-    console.log(`[OpenClawControl] 停止验证通过: 端口已关闭`);
   } else if (command === OpenClawCommandEnum.START || command === OpenClawCommandEnum.RESTART) {
-    // 等待服务启动
-    const maxWait = command === OpenClawCommandEnum.START ? 30 : 60;
+    // 等待服务启动（最多等待 30 秒）
+    const maxWait = 15; // 最多 15 次检查
     let attempts = 0;
     let portStatus = 0;
     
     while (attempts < maxWait) {
       await new Promise(resolve => setTimeout(resolve, 2000));
       portStatus = await getOpenClawStatus(18789);
-      if (portStatus === 1 || portStatus === 2) break; // 端口监听或进程存在都算成功
+      if (portStatus === 1) break; // 端口监听算成功
       attempts++;
     }
     
     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 + ' (进程已启动，端口检查可能不准确)'
-      };
     }
   }
   
@@ -276,12 +218,33 @@ async function executeCommand(command, window, sendResponse) {
   if (sendResponse) {
     let httpStatus = 'success';
     if (result.status === OpenClawServiceStatus.ERROR) httpStatus = 'error';
+    
+    // 获取操作后的真实状态
+    let realStatus = result.status;
+    if (command === OpenClawCommandEnum.STOP || command === OpenClawCommandEnum.START || command === OpenClawCommandEnum.RESTART) {
+      try {
+        const { getOpenClawStatus } = require('./port-checker');
+        const portStatus = await getOpenClawStatus(18789);
+        // 更新真实状态
+        if (command === OpenClawCommandEnum.STOP) {
+          realStatus = portStatus === 1 ? OpenClawServiceStatus.RUNNING : OpenClawServiceStatus.STOP_SUCCESS;
+        } else if (command === OpenClawCommandEnum.START) {
+          realStatus = portStatus === 1 ? OpenClawServiceStatus.START_SUCCESS : OpenClawServiceStatus.ERROR;
+        } else if (command === OpenClawCommandEnum.RESTART) {
+          realStatus = portStatus === 1 ? OpenClawServiceStatus.RESTART_SUCCESS : OpenClawServiceStatus.ERROR;
+        }
+        console.log(`[OpenClawControl] 操作后真实状态检测: portStatus=${portStatus}, realStatus=${realStatus}`);
+      } catch (e) {
+        console.error(`[OpenClawControl] 真实状态检测失败: ${e.message}`);
+      }
+    }
+    
     sendResponse({
       type: 'command_result',
       command,
       status: httpStatus,
       message: result.message,
-      service_status: result.status
+      service_status: realStatus
     });
   }
 

package/service/modules/openclaw-enum.js

@@ -40,9 +40,21 @@ function isValidCommand(command) {
   return Object.values(OpenClawCommandEnum).includes(command);
 }
 
+function getCommandName(command) {
+  const names = {
+    [OpenClawCommandEnum.START]: '启动',
+    [OpenClawCommandEnum.STOP]: '停止',
+    [OpenClawCommandEnum.RESTART]: '重启',
+    [OpenClawCommandEnum.STATUS]: '状态检查',
+    [OpenClawCommandEnum.CONFIG_FIX]: '配置修复'
+  };
+  return names[command] || '未知命令';
+}
+
 module.exports = {
   OpenClawCommandEnum,
   OpenClawServiceStatus,
   getServiceStatusMessage,
-  isValidCommand
+  isValidCommand,
+  getCommandName
 };

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

@@ -8,7 +8,7 @@
  * - DELETE_OPENCODE_SESSION: 删除会话
  */
 const { RongyunMessageTypeEnum } = require('./rongyun-message-types');
-const { OpenClawCommandEnum } = require('./openclaw-enum');
+const { OpenClawCommandEnum, getCommandName } = require('./openclaw-enum');
 const { executeCommand } = require('./openclaw-control');
 const { createOpencodeSession, deleteOpencodeSession, forwardChatMessage } = require('./opencode-service');
 const { ServiceManager } = require('./service-manager');
@@ -128,21 +128,39 @@ class RongyunMessageHandler {
     }
 
     this.commandLock = true;
-    // 设置 60 秒超时保护，防止命令永久卡住导致锁无法释放
+    // 设置 120 秒超时保护，防止命令永久卡住导致锁无法释放
+    // 启动命令可能需要较长时间（等待服务启动）
     this.commandLockTimer = setTimeout(() => {
-      this.logWarn('[RongyunMessageHandler] 命令锁超时（60秒），自动释放');
+      this.logWarn('[RongyunMessageHandler] 命令锁超时（120秒），自动释放');
       this.commandLock = false;
       this.commandLockTimer = null;
-    }, 60000);
+    }, 120000);
 
     try {
-      await executeCommand(command, null, async (response) => {
-        // 增加短暂延迟，避免融云 SDK 在收到消息后立刻回复时消息丢失
-        await new Promise(resolve => setTimeout(resolve, 500));
+      // 先发送响应，再执行命令（避免前端超时）
+      // 启动/停止/重启命令是异步的，前端只需要知道命令已接收
+      const isAsyncCommand = [OpenClawCommandEnum.START, OpenClawCommandEnum.STOP, OpenClawCommandEnum.RESTART].includes(command);
+      
+      if (isAsyncCommand) {
+        // 立即响应，告知前端命令已接收
         await this.sendResponse(RongyunMessageTypeEnum.COMMAND_RESULT, {
-          ...response,
-          command_id: commandId
+          command,
+          command_id: commandId,
+          status: 'success',
+          message: `${getCommandName(command)}命令已接收，正在执行...`
         }, requestId, sourceId);
+      }
+      
+      // 执行命令
+      await executeCommand(command, null, async (response) => {
+        if (!isAsyncCommand) {
+          // 同步命令立即响应
+          await this.sendResponse(RongyunMessageTypeEnum.COMMAND_RESULT, {
+            ...response,
+            command_id: commandId
+          }, requestId, sourceId);
+        }
+        // 异步命令不在这里响应，因为已经提前响应了
       });
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
@@ -337,10 +355,23 @@ class RongyunMessageHandler {
     this.logInfo(`[RongyunMessageHandler] 收到设备状态请求, from=${targetId}, requestId=${requestId}`);
 
     try {
-      // 获取 OpenClaw 运行状态（检查端口 18789）
+      // 获取 OpenClaw 真实运行状态（检查端口 18789）
       const openClawStatus = await getOpenClawStatus();
       
-      // 构建状态数据
+      // 获取真实的版本信息（如果可能）
+      let version = 'unknown';
+      try {
+        const { execSync } = require('child_process');
+        const versionOutput = execSync('openclaw --version', { encoding: 'utf8', timeout: 5000 }).trim();
+        const match = versionOutput.match(/(\d+\.\d+\.\d+)/);
+        if (match) {
+          version = match[1];
+        }
+      } catch (e) {
+        // 忽略版本获取失败
+      }
+      
+      // 构建真实状态数据
       // openClawStatus: 1=端口监听正常(服务可用), 0=未运行(端口未监听)
       const statusMessage = openClawStatus === 1 ? '运行中' : '未运行';
       
@@ -348,11 +379,11 @@ class RongyunMessageHandler {
         open_claw_status: openClawStatus,  // 1=运行中, 0=未运行
         status_message: statusMessage,
         mac_address: getMacAddress(),
-        version: '0.0.20',
+        version: version,
         timestamp: Date.now(),
       };
       
-      this.logInfo(`[RongyunMessageHandler] 设备状态: openClawStatus=${openClawStatus}`);
+      this.logInfo(`[RongyunMessageHandler] 设备真实状态: openClawStatus=${openClawStatus}, version=${version}`);
       await this.sendDeviceStatusReport(targetId, requestId, statusData);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);