claw-subagent-service 0.0.123 → 0.0.125

package/command/linux/stop.sh

@@ -163,7 +163,9 @@ get_openclaw_pid() {
 }
 
 # Docker 模式：停止服务
+# 参数: $1 = force (1=强制停止, 空=优雅停止)
 stop_docker() {
+    local force="$1"
     log_info "=== OpenClaw Docker 停止模式 ==="
     log_info "检查 OpenClaw 服务状态..."
     
@@ -213,9 +215,48 @@ stop_docker() {
     
     log_info "发现 OpenClaw 进程: $all_pids"
     
-    # 直接发送 SIGKILL（强制停止），避免 SIGTERM 被忽略
+    # 如果不是强制模式，先尝试优雅停止
+    if [ -z "$force" ]; then
+        log_info "正在优雅停止 OpenClaw 服务..."
+        # 尝试发送 SIGTERM
+        for p in $all_pids; do
+            log_info "执行: kill -15 $p"
+            kill -15 "$p" 2>/dev/null || log_warn "kill -15 $p 失败"
+        done
+        
+        # 等待 5 秒让服务优雅退出
+        log_info "等待 5 秒让服务优雅退出..."
+        sleep 5
+        
+        # 检查是否已停止
+        local pid_after_graceful
+        pid_after_graceful=$(get_openclaw_pid)
+        if [ -z "$pid_after_graceful" ] && ! check_port "$PORT"; then
+            log_info "OpenClaw 服务已通过优雅停止退出。"
+            log_info "服务已成功停止。"
+            log_info "Success"
+            exit 0
+        fi
+        
+        log_warn "优雅停止失败，服务仍在运行，切换到强制停止..."
+    fi
+    
+    # 强制停止模式（直接发送 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
@@ -225,12 +266,15 @@ stop_docker() {
     log_info "执行: killall -9 openclaw"
     killall -9 openclaw 2>/dev/null || log_warn "killall 失败"
     
+    # 等待 2 秒让进程退出
+    sleep 2
+    
     # 连续监控模式：每秒检查并杀死看门狗重启的进程
     # 这样即使看门狗立即重启，也会被再次杀死
-    log_info "进入连续监控模式（最多 10 秒），防止看门狗自动重启..."
+    log_info "进入连续监控模式（最多 20 秒），防止看门狗自动重启..."
     local elapsed=0
     local consecutive_empty=0
-    while [ $elapsed -lt 10 ]; do
+    while [ $elapsed -lt 20 ]; do
         sleep 1
         
         # 检查是否还有 openclaw 进程
@@ -243,11 +287,17 @@ stop_docker() {
             remaining_pids=$(ps aux | grep -v grep | grep "openclaw" | awk '{print $2}' | tr '\n' ' ')
         fi
         
-        if [ -z "$remaining_pids" ]; then
+        # 同时检查端口是否仍在监听
+        local port_listening=false
+        if check_port "$PORT"; then
+            port_listening=true
+        fi
+        
+        if [ -z "$remaining_pids" ] && [ "$port_listening" = false ]; then
             consecutive_empty=$((consecutive_empty + 1))
-            log_info "第 $elapsed 秒: 无 openclaw 进程（连续 $consecutive_empty 次）"
-            # 连续 2 秒没有进程，认为已停止
-            if [ $consecutive_empty -ge 2 ]; then
+            log_info "第 $elapsed 秒: 无 openclaw 进程且端口未监听（连续 $consecutive_empty 次）"
+            # 连续 3 秒没有进程且端口未监听，认为已停止
+            if [ $consecutive_empty -ge 3 ]; then
                 log_info "OpenClaw 服务已停止。（看门狗已放弃重启）"
                 log_info "服务已成功停止。"
                 log_info "Success"
@@ -255,7 +305,18 @@ stop_docker() {
             fi
         else
             consecutive_empty=0
-            log_info "第 $elapsed 秒: 发现新进程 $remaining_pids，再次 kill..."
+            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 终止..."
+                if command -v fuser &>/dev/null; then
+                    fuser -k "${PORT}/tcp" 2>/dev/null || true
+                fi
+            fi
             pkill -9 -f "openclaw" 2>/dev/null || true
             killall -9 openclaw 2>/dev/null || true
         fi
@@ -263,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
@@ -282,19 +351,33 @@ stop_docker() {
         ss -tlnp 2>/dev/null | grep ":${PORT} " || log_info "端口 ${PORT} 未监听"
     fi
     
-    if [ -z "$remaining_pids" ]; then
+    # 最终验证：同时检查进程和端口
+    local port_listening_final=false
+    if check_port "$PORT"; then
+        port_listening_final=true
+    fi
+    
+    if [ -z "$remaining_pids" ] && [ "$port_listening_final" = false ]; then
         log_info "OpenClaw 服务已停止。"
         log_info "服务已成功停止。"
         log_info "Success"
         exit 0
     else
-        log_error "OpenClaw 服务停止失败！进程仍然存在: $remaining_pids"
+        if [ -n "$remaining_pids" ]; then
+            log_error "OpenClaw 服务停止失败！进程仍然存在: $remaining_pids"
+        fi
+        if [ "$port_listening_final" = true ]; then
+            log_error "OpenClaw 服务停止失败！端口 $PORT 仍在监听。"
+        fi
         exit 1
     fi
 }
 
 # Systemd 模式：停止服务
+# 参数: $1 = force (1=强制停止, 空=优雅停止)
 stop_systemd() {
+    local force="$1"
+    
     # 检查服务是否存在
     if ! systemctl --user list-unit-files "$SERVICE_NAME" &>/dev/null; then
         log_error "服务 $SERVICE_NAME 不存在。"
@@ -321,8 +404,33 @@ stop_systemd() {
         
         # 验证服务状态
         if systemctl --user is-active --quiet "$SERVICE_NAME"; then
-            log_warn "服务可能仍在运行，请检查进程。"
-            systemctl --user status "$SERVICE_NAME" --no-pager
+            if [ -n "$force" ]; then
+                log_warn "服务仍在运行，执行强制停止..."
+                # 获取进程 PID 并强制终止
+                local main_pid
+                main_pid=$(systemctl --user show "$SERVICE_NAME" --property=MainPID --value)
+                if [ -n "$main_pid" ] && [ "$main_pid" != "0" ]; then
+                    log_info "强制终止进程 PID: $main_pid"
+                    kill -9 "$main_pid" 2>/dev/null || true
+                fi
+                # 同时清理所有 openclaw 相关进程
+                pkill -9 -f "openclaw" 2>/dev/null || true
+                killall -9 openclaw 2>/dev/null || true
+                
+                sleep 2
+                
+                if ! systemctl --user is-active --quiet "$SERVICE_NAME"; then
+                    log_info "服务已成功强制停止。"
+                    log_info "Success"
+                    exit 0
+                else
+                    log_error "强制停止失败！服务仍在运行。"
+                    exit 1
+                fi
+            else
+                log_warn "服务可能仍在运行，请检查进程。"
+                systemctl --user status "$SERVICE_NAME" --no-pager
+            fi
         else
             log_info "服务已成功停止。"
             log_info "Success"
@@ -372,9 +480,9 @@ main() {
     done
     
     if is_docker; then
-        stop_docker
+        stop_docker "$force"
     else
-        stop_systemd
+        stop_systemd "$force"
     fi
 }
 

package/command/win/stop.bat

@@ -43,13 +43,33 @@ echo.
 REM Wait and verify stopped
 timeout /t 3 /nobreak >nul
 
+REM Check if port is still listening
 netstat -an | findstr ":18789 " | findstr "LISTENING" >nul
 if errorlevel 1 (
     echo [OK] Service stopped successfully
     echo.
     echo Success
     exit /b 0
-) else (
-    echo [WARN] Service may still be running
+)
+
+REM Port still listening, try graceful stop again with force flag
+echo [WARN] Service may still be running, attempting force stop...
+echo.
+
+REM Kill openclaw processes
+taskkill /f /im openclaw.exe >nul 2>&1
+
+REM Wait for processes to terminate
+timeout /t 2 /nobreak >nul
+
+REM Final check
+netstat -an | findstr ":18789 " | findstr "LISTENING" >nul
+if errorlevel 1 (
+    echo [OK] Service stopped successfully after force stop
+    echo.
+    echo Success
     exit /b 0
+) else (
+    echo [ERROR] Service stop failed: port 18789 still listening after force stop
+    exit /b 1
 )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claw-subagent-service",
-  "version": "0.0.123",
+  "version": "0.0.125",
   "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

@@ -138,25 +138,82 @@ async function verifyCommandResult(command, result, scriptOutput = '') {
   if (command === OpenClawCommandEnum.STOP) {
     // 停止命令验证：多次检查端口并重复执行停止，处理看门狗自动重启
     console.log(`[OpenClawControl] 开始验证停止结果...`);
-    
+
     let portStatus = 1;
     let stopAttempts = 0;
     const maxStopAttempts = 3; // 最多执行 3 次停止
-    
+
     // 等待 3 秒，给看门狗一次重启机会，然后验证
     await new Promise(resolve => setTimeout(resolve, 3000));
-    
-    portStatus = await getOpenClawStatus(18789);
-    console.log(`[OpenClawControl] 停止后端口状态: ${portStatus}`);
-    
+
+    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 仍在监听。stop.sh 可能未能成功停止服务。`);
+      console.error(`[OpenClawControl] 停止失败: 端口 18789 仍在监听。尝试直接强制终止进程...`);
+      
+      // 直接执行强制终止命令（不通过脚本）
+      try {
+        const { execSync } = require('child_process');
+        
+        // 先尝试 pkill
+        try {
+          execSync('pkill -9 -f "openclaw"', { timeout: 5000 });
+          console.log('[OpenClawControl] pkill -9 -f openclaw 执行成功');
+        } catch (e) {
+          console.log('[OpenClawControl] pkill 执行失败或没有匹配进程');
+        }
+        
+        // 再尝试 killall
+        try {
+          execSync('killall -9 openclaw', { timeout: 5000 });
+          console.log('[OpenClawControl] killall -9 openclaw 执行成功');
+        } catch (e) {
+          console.log('[OpenClawControl] killall 执行失败或没有匹配进程');
+        }
+        
+        // 等待进程退出
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        
+        // 再次验证端口
+        const finalPortStatus = await getOpenClawStatus(18789);
+        
+        if (finalPortStatus !== 1) {
+          console.log(`[OpenClawControl] 强制停止成功: 端口已关闭`);
+          return {
+            status: OpenClawServiceStatus.STOP_SUCCESS,
+            message: '服务已停止（强制停止）'
+          };
+        }
+      } catch (err) {
+        console.error(`[OpenClawControl] 强制停止异常: ${err.message}`);
+      }
+      
+      console.error(`[OpenClawControl] 停止失败: 端口 18789 仍在监听。所有停止方法均已尝试。`);
       return {
         status: OpenClawServiceStatus.ERROR,
         message: '停止失败: 服务仍在运行'
       };
     }
-    
+
     console.log(`[OpenClawControl] 停止验证通过: 端口已关闭`);
   } else if (command === OpenClawCommandEnum.START || command === OpenClawCommandEnum.RESTART) {
     // 等待服务启动
@@ -239,12 +296,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/rongyun-message-handler.js

@@ -337,10 +337,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 +361,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);

package/service/modules/script-executor.js

@@ -446,6 +446,7 @@ class ScriptExecutor {
         upper.includes('服务停止成功') ||
         upper.includes('服务已成功停止') ||
         upper.includes('GATEWAY STOP SIGNAL SENT') ||
+        upper.includes('STOPPED SUCCESSFULLY AFTER FORCE STOP') ||
         (upper.includes('[INFO] STOPPING SERVICE') && upper.includes('STOP SIGNAL'))
       ) {
         if (