claw-subagent-service 0.0.24 → 0.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claw-subagent-service",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "虾说静态服务",
   "main": "cli.js",
   "bin": {

package/service/rongcloud/message-handler.js

@@ -115,21 +115,26 @@ class MessageHandler {
   }
 
   async handleClaw(msg) {
-    // 先发送已读回执（表示消息已被接收和处理）
+    const targetId = this.getReplyTarget(msg);
+
+    // 发送已读回执（fire-and-forget，不阻塞）
     if (this.sendReadReceiptFn) {
-      try {
-        await this.sendReadReceiptFn(msg);
-        this.log?.info(`[MessageHandler] 已读回执已发送`);
-      } catch (err) {
-        this.log?.error(`[MessageHandler] 发送已读回执失败: ${err.message}`);
-      }
+      this.sendReadReceiptFn(msg).catch(() => {});
     }
 
-    const reply = await this.openclawClient.chat(msg.content, msg.senderUserId);
-    this.log?.info(`[MessageHandler] AI 回复: ${reply.substring(0, 50)}...`);
-
-    const targetId = this.getReplyTarget(msg);
-    await this.sendFn(targetId, reply, msg.conversationType);
+    // 先回复"正在处理"，让用户知道消息已被接收
+    this.sendFn(targetId, '🤖 正在思考中，请稍候...', msg.conversationType).catch(() => {});
+
+    // 后台执行 openclaw，不阻塞消息队列
+    this.openclawClient.chat(msg.content, msg.senderUserId)
+      .then(reply => {
+        this.log?.info(`[MessageHandler] AI 回复: ${reply.substring(0, 50)}...`);
+        this.sendFn(targetId, reply, msg.conversationType).catch(() => {});
+      })
+      .catch(err => {
+        this.log?.error(`[MessageHandler] OpenClaw 调用失败: ${err.message}`);
+        this.sendFn(targetId, `❌ 处理失败: ${err.message}`, msg.conversationType).catch(() => {});
+      });
   }
 
   parseCommand(raw, senderId) {

package/service/rongcloud/openclaw-client.js

@@ -1,7 +1,9 @@
-const { spawn } = require('child_process');
+const { spawn, execSync } = require('child_process');
+const net = require('net');
 const os = require('os');
 const fs = require('fs');
 const path = require('path');
+const axios = require('axios');
 
 /**
  * 获取实际用户主目录（SYSTEM 账户下 os.homedir() 返回 systemprofile）
@@ -31,17 +33,174 @@ function getRealHomeDir() {
   return homeDir;
 }
 
+/**
+ * 检测端口是否监听
+ */
+function checkPort(port) {
+  return new Promise((resolve) => {
+    const sock = new net.Socket();
+    sock.setTimeout(3000);
+    sock.once('connect', () => {
+      sock.destroy();
+      resolve(true);
+    });
+    sock.once('error', () => {
+      sock.destroy();
+      resolve(false);
+    });
+    sock.once('timeout', () => {
+      sock.destroy();
+      resolve(false);
+    });
+    sock.connect(port, '127.0.0.1');
+  });
+}
+
+/**
+ * 启动 OpenClaw gateway
+ */
+function startOpenClawGateway(log) {
+  return new Promise((resolve) => {
+    log?.info('[OpenClawClient] 正在启动 OpenClaw gateway...');
+
+    const child = spawn('openclaw', ['gateway'], {
+      shell: true,
+      windowsHide: true,
+      detached: true,
+      stdio: 'ignore',
+      env: {
+        ...process.env,
+        USERPROFILE: getRealHomeDir(),
+        HOME: getRealHomeDir(),
+      },
+    });
+
+    child.unref();
+
+    // 等待 gateway 启动（最多 15 秒）
+    let attempts = 0;
+    const maxAttempts = 15;
+    const interval = setInterval(async () => {
+      attempts++;
+      const isRunning = await checkPort(18789);
+      if (isRunning) {
+        clearInterval(interval);
+        log?.info('[OpenClawClient] OpenClaw gateway 启动成功');
+        resolve(true);
+      } else if (attempts >= maxAttempts) {
+        clearInterval(interval);
+        log?.warn('[OpenClawClient] OpenClaw gateway 启动超时');
+        resolve(false);
+      }
+    }, 1000);
+
+    child.on('error', (err) => {
+      log?.error(`[OpenClawClient] 启动 gateway 失败: ${err.message}`);
+      clearInterval(interval);
+      resolve(false);
+    });
+  });
+}
+
 class OpenClawClient {
   constructor(log) {
     this.log = log;
+    this.gatewayStarting = false;
+    this.gatewayStarted = false;
+  }
+
+  /**
+   * 确保 OpenClaw gateway 在运行
+   */
+  async ensureGatewayRunning() {
+    if (this.gatewayStarted) return true;
+
+    const isRunning = await checkPort(18789);
+    if (isRunning) {
+      this.log?.info('[OpenClawClient] OpenClaw gateway 已在运行');
+      this.gatewayStarted = true;
+      return true;
+    }
+
+    // 避免并发启动
+    if (this.gatewayStarting) {
+      this.log?.info('[OpenClawClient] gateway 正在启动中，等待...');
+      // 等待最多 20 秒
+      for (let i = 0; i < 20; i++) {
+        await new Promise(r => setTimeout(r, 1000));
+        if (await checkPort(18789)) {
+          this.gatewayStarted = true;
+          return true;
+        }
+      }
+      return false;
+    }
+
+    this.gatewayStarting = true;
+    try {
+      const started = await startOpenClawGateway(this.log);
+      this.gatewayStarted = started;
+      return started;
+    } finally {
+      this.gatewayStarting = false;
+    }
   }
 
   async chat(message, fromUser) {
     if (!message || !message.trim()) {
       return '消息内容为空';
     }
+
+    // 确保 OpenClaw gateway 已启动
+    const gatewayReady = await this.ensureGatewayRunning();
+    if (!gatewayReady) {
+      this.log?.error('[OpenClawClient] OpenClaw gateway 未运行且启动失败');
+      return 'OpenClaw gateway 启动失败，请检查 openclaw 是否正确安装';
+    }
+
     this.log?.info(`[OpenClawClient] 准备发送消息到 OpenClaw，from=${fromUser}, message=${message.substring(0, 50)}`);
 
+    const gatewayUrl = 'http://127.0.0.1:5678';
+
+    try {
+      const response = await axios.post(
+        `${gatewayUrl}/v1/chat/completions`,
+        {
+          model: 'claw-local',
+          messages: [
+            { role: 'user', content: message }
+          ],
+          stream: false
+        },
+        {
+          headers: { 'Content-Type': 'application/json' },
+          timeout: 120000
+        }
+      );
+
+      if (response.status === 200 && response.data) {
+        const result = response.data;
+        const aiMessage = result.choices?.[0]?.message;
+        const content = aiMessage?.content;
+        if (content) {
+          this.log?.info(`[OpenClawClient] AI 回复: ${content.substring(0, 50)}...`);
+          return content;
+        }
+        this.log?.warn('[OpenClawClient] OpenClaw 返回了空响应');
+        return 'OpenClaw 未返回有效响应';
+      } else {
+        this.log?.error(`[OpenClawClient] OpenClaw 返回错误: ${response.status}`);
+        return `OpenClaw 返回错误: ${response.status}`;
+      }
+    } catch (err) {
+      this.log?.error(`[OpenClawClient] HTTP 调用失败: ${err.message}`);
+      // fallback 到 CLI 调用
+      this.log?.info('[OpenClawClient] HTTP 失败，尝试 CLI fallback');
+      return this.chatViaCLI(message, fromUser);
+    }
+  }
+
+  async chatViaCLI(message, fromUser) {
     const sessionId = `clawmessenger-${fromUser}`;
     const escapedMessage = message
       .replace(/\\/g, '\\\\')
@@ -73,7 +232,6 @@ class OpenClawClient {
         },
       });
 
-      // 流式收集输出，无 maxBuffer 限制
       child.stdout.on('data', (chunk) => {
         stdout += chunk.toString();
       });
@@ -81,20 +239,19 @@ class OpenClawClient {
         stderr += chunk.toString();
       });
 
-      // 超时兜底（20 分钟）
       const timeout = setTimeout(() => {
         killed = true;
         child.kill('SIGTERM');
-        this.log?.error('[OpenClawClient] 执行超时，强制终止');
+        this.log?.error('[OpenClawClient] CLI 执行超时，强制终止');
       }, 1200000);
 
       child.on('error', (err) => {
         clearTimeout(timeout);
-        this.log?.error(`[OpenClawClient] 子进程错误: ${err.message}`);
+        this.log?.error(`[OpenClawClient] CLI 子进程错误: ${err.message}`);
         if (err.code === 'ENOENT') {
           resolve('找不到 openclaw 命令');
         } else {
-          resolve(`OpenClaw 调用失败: ${err.message}`);
+          resolve(`OpenClaw CLI 调用失败: ${err.message}`);
         }
       });
 
@@ -102,17 +259,17 @@ class OpenClawClient {
         clearTimeout(timeout);
 
         if (killed) {
-          resolve('OpenClaw 响应超时');
+          resolve('OpenClaw CLI 响应超时');
           return;
         }
 
-        this.log?.info(`[OpenClawClient] 进程退出 code=${code}`);
+        this.log?.info(`[OpenClawClient] CLI 进程退出 code=${code}`);
         this.log?.info(`[OpenClawClient] stdout 长度: ${stdout.length}, stderr 长度: ${stderr.length}`);
 
         if (code !== 0) {
           const errOutput = stderr || stdout || '';
-          this.log?.error(`[OpenClawClient] 错误输出: ${errOutput.substring(0, 500)}`);
-          resolve(`OpenClaw 调用失败: ${errOutput.substring(0, 200)}`);
+          this.log?.error(`[OpenClawClient] CLI 错误输出: ${errOutput.substring(0, 500)}`);
+          resolve(`OpenClaw CLI 调用失败: ${errOutput.substring(0, 200)}`);
           return;
         }
 

package/service/rongcloud/rongcloud-client.js

@@ -154,13 +154,12 @@ class RongCloudClient {
         sentTime: message.sentTime || Date.now()
       };
 
-      this.processingQueue = this.processingQueue.then(async () => {
-        if (this.handler) {
-          await this.handler.handleMessage(rongCloudMsg);
-        }
-      }).catch(err => {
-        this.log?.error(`[RongCloudClient] 消息处理异常: ${err.message}`);
-      });
+      // 并行处理消息，不等待上一条完成（避免 openclaw 长耗时调用阻塞后续消息）
+      if (this.handler) {
+        this.handler.handleMessage(rongCloudMsg).catch(err => {
+          this.log?.error(`[RongCloudClient] 消息处理异常: ${err.message}`);
+        });
+      }
     } catch (err) {
       this.log?.error(`[RongCloudClient] 解析消息失败: ${err.message}`);
     }