claw-subagent-service 0.0.0

package/service/modules/service-manager.js

@@ -0,0 +1,319 @@
+/**
+ * 系统服务管理器
+ * 支持 Windows/Linux/macOS 系统服务注册
+ */
+const { spawn, exec } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+class ServiceManager {
+  constructor(serviceName, serviceDesc, scriptPath, log) {
+    this.serviceName = serviceName || 'claw-subagent-service';
+    this.serviceDesc = serviceDesc || 'OpenClaw Guard CLI Client';
+    this.scriptPath = scriptPath || process.argv[1];
+    this.log = log;
+    this.platform = process.platform;
+  }
+
+  /**
+   * 安装系统服务
+   */
+  async install() {
+    this.log?.info(`[ServiceManager] 安装系统服务: ${this.serviceName}`);
+    
+    try {
+      switch (this.platform) {
+        case 'win32':
+          return await this.installWindows();
+        case 'linux':
+          return await this.installLinux();
+        case 'darwin':
+          return await this.installMacOS();
+        default:
+          throw new Error(`不支持的平台: ${this.platform}`);
+      }
+    } catch (err) {
+      this.log?.error(`[ServiceManager] 安装服务失败: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 卸载系统服务
+   */
+  async uninstall() {
+    this.log?.info(`[ServiceManager] 卸载系统服务: ${this.serviceName}`);
+    
+    try {
+      switch (this.platform) {
+        case 'win32':
+          return await this.uninstallWindows();
+        case 'linux':
+          return await this.uninstallLinux();
+        case 'darwin':
+          return await this.uninstallMacOS();
+        default:
+          throw new Error(`不支持的平台: ${this.platform}`);
+      }
+    } catch (err) {
+      this.log?.error(`[ServiceManager] 卸载服务失败: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 启动服务
+   */
+  async start() {
+    this.log?.info(`[ServiceManager] 启动服务: ${this.serviceName}`);
+    
+    try {
+      switch (this.platform) {
+        case 'win32':
+          return await this.execCommand(`net start ${this.serviceName}`);
+        case 'linux':
+          return await this.execCommand(`systemctl start ${this.serviceName}`);
+        case 'darwin':
+          return await this.execCommand(`launchctl start ${this.serviceName}`);
+        default:
+          throw new Error(`不支持的平台: ${this.platform}`);
+      }
+    } catch (err) {
+      this.log?.error(`[ServiceManager] 启动服务失败: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 停止服务
+   */
+  async stop() {
+    this.log?.info(`[ServiceManager] 停止服务: ${this.serviceName}`);
+    
+    try {
+      switch (this.platform) {
+        case 'win32':
+          return await this.execCommand(`net stop ${this.serviceName}`);
+        case 'linux':
+          return await this.execCommand(`systemctl stop ${this.serviceName}`);
+        case 'darwin':
+          return await this.execCommand(`launchctl stop ${this.serviceName}`);
+        default:
+          throw new Error(`不支持的平台: ${this.platform}`);
+      }
+    } catch (err) {
+      this.log?.error(`[ServiceManager] 停止服务失败: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 重启服务
+   */
+  async restart() {
+    this.log?.info(`[ServiceManager] 重启服务: ${this.serviceName}`);
+    
+    try {
+      switch (this.platform) {
+        case 'win32':
+          await this.execCommand(`net stop ${this.serviceName}`);
+          return await this.execCommand(`net start ${this.serviceName}`);
+        case 'linux':
+          return await this.execCommand(`systemctl restart ${this.serviceName}`);
+        case 'darwin':
+          await this.execCommand(`launchctl stop ${this.serviceName}`);
+          return await this.execCommand(`launchctl start ${this.serviceName}`);
+        default:
+          throw new Error(`不支持的平台: ${this.platform}`);
+      }
+    } catch (err) {
+      this.log?.error(`[ServiceManager] 重启服务失败: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 查看服务状态
+   */
+  async status() {
+    this.log?.info(`[ServiceManager] 查看服务状态: ${this.serviceName}`);
+    
+    try {
+      switch (this.platform) {
+        case 'win32':
+          return await this.execCommand(`sc query ${this.serviceName}`);
+        case 'linux':
+          return await this.execCommand(`systemctl status ${this.serviceName}`);
+        case 'darwin':
+          return await this.execCommand(`launchctl list | grep ${this.serviceName}`);
+        default:
+          throw new Error(`不支持的平台: ${this.platform}`);
+      }
+    } catch (err) {
+      this.log?.error(`[ServiceManager] 查看状态失败: ${err.message}`);
+      return false;
+    }
+  }
+
+  // Windows 服务安装
+  async installWindows() {
+    // 使用 node-windows 或手动创建服务
+    const nodeWindowsPath = path.join(__dirname, '..', '..', 'node_modules', 'node-windows');
+    
+    if (!fs.existsSync(nodeWindowsPath)) {
+      this.log?.warn('[ServiceManager] node-windows 未安装，尝试安装...');
+      await this.execCommand('npm install node-windows --save');
+    }
+    
+    const Service = require('node-windows').Service;
+    const svc = new Service({
+      name: this.serviceName,
+      description: this.serviceDesc,
+      script: this.scriptPath,
+      nodeOptions: ['--harmony', '--max_old_space_size=4096']
+    });
+    
+    return new Promise((resolve, reject) => {
+      svc.on('install', () => {
+        this.log?.info('[ServiceManager] Windows 服务安装成功');
+        svc.start();
+        resolve(true);
+      });
+      
+      svc.on('error', (err) => {
+        this.log?.error(`[ServiceManager] Windows 服务安装失败: ${err.message}`);
+        reject(err);
+      });
+      
+      svc.install();
+    });
+  }
+
+  // Linux 服务安装 (systemd)
+  async installLinux() {
+    const serviceFile = `/etc/systemd/system/${this.serviceName}.service`;
+    const serviceContent = `[Unit]
+Description=${this.serviceDesc}
+After=network.target
+
+[Service]
+Type=simple
+User=root
+ExecStart=/usr/bin/node ${this.scriptPath}
+Restart=always
+RestartSec=10
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=multi-user.target
+`;
+    
+    fs.writeFileSync(serviceFile, serviceContent);
+    await this.execCommand('systemctl daemon-reload');
+    await this.execCommand(`systemctl enable ${this.serviceName}`);
+    await this.execCommand(`systemctl start ${this.serviceName}`);
+    
+    this.log?.info('[ServiceManager] Linux 服务安装成功');
+    return true;
+  }
+
+  // macOS 服务安装 (launchd)
+  async installMacOS() {
+    const plistFile = `/Library/LaunchDaemons/${this.serviceName}.plist`;
+    const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${this.serviceName}</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>/usr/local/bin/node</string>
+        <string>${this.scriptPath}</string>
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>/var/log/${this.serviceName}.log</string>
+    <key>StandardErrorPath</key>
+    <string>/var/log/${this.serviceName}.error.log</string>
+</dict>
+</plist>`;
+    
+    fs.writeFileSync(plistFile, plistContent);
+    await this.execCommand(`launchctl load ${plistFile}`);
+    await this.execCommand(`launchctl start ${this.serviceName}`);
+    
+    this.log?.info('[ServiceManager] macOS 服务安装成功');
+    return true;
+  }
+
+  // Windows 服务卸载
+  async uninstallWindows() {
+    const Service = require('node-windows').Service;
+    const svc = new Service({
+      name: this.serviceName,
+      script: this.scriptPath
+    });
+    
+    return new Promise((resolve, reject) => {
+      svc.on('uninstall', () => {
+        this.log?.info('[ServiceManager] Windows 服务卸载成功');
+        resolve(true);
+      });
+      
+      svc.on('error', (err) => {
+        this.log?.error(`[ServiceManager] Windows 服务卸载失败: ${err.message}`);
+        reject(err);
+      });
+      
+      svc.uninstall();
+    });
+  }
+
+  // Linux 服务卸载
+  async uninstallLinux() {
+    await this.execCommand(`systemctl stop ${this.serviceName}`);
+    await this.execCommand(`systemctl disable ${this.serviceName}`);
+    const serviceFile = `/etc/systemd/system/${this.serviceName}.service`;
+    if (fs.existsSync(serviceFile)) {
+      fs.unlinkSync(serviceFile);
+    }
+    await this.execCommand('systemctl daemon-reload');
+    
+    this.log?.info('[ServiceManager] Linux 服务卸载成功');
+    return true;
+  }
+
+  // macOS 服务卸载
+  async uninstallMacOS() {
+    const plistFile = `/Library/LaunchDaemons/${this.serviceName}.plist`;
+    await this.execCommand(`launchctl stop ${this.serviceName}`);
+    await this.execCommand(`launchctl unload ${plistFile}`);
+    if (fs.existsSync(plistFile)) {
+      fs.unlinkSync(plistFile);
+    }
+    
+    this.log?.info('[ServiceManager] macOS 服务卸载成功');
+    return true;
+  }
+
+  // 执行系统命令
+  execCommand(command) {
+    return new Promise((resolve, reject) => {
+      exec(command, (error, stdout, stderr) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(stdout || stderr);
+        }
+      });
+    });
+  }
+}
+
+module.exports = {
+  ServiceManager
+};

package/service/modules/structured-message-router.js

@@ -0,0 +1,118 @@
+/**
+ * 结构化消息路由器
+ * 
+ * 由于不能修改 rongcloud/ 文件夹的代码，此模块在 worker.js 中拦截消息，
+ * 在传给 MessageHandler 之前解析结构化消息并路由到正确的处理器。
+ * 
+ * 问题背景：
+ * - rongcloud-client.js 现在会传递所有消息（SYSTEM_MSG_TYPES 已清空）
+ * - 但 message-handler.js 的 getMessageType() 只检查 content 是否以 '/' 开头
+ * - 结构化消息（如 command）的 content 是 JSON 字符串，不以 '/' 开头
+ * - 导致所有结构化消息被当作 NORMAL 消息处理
+ * 
+ * 解决方案：
+ * - 在 worker.js 中包装 MessageHandler.handleMessage()
+ * - 在消息到达业务处理器之前，解析 JSON 并检查 msg_type
+ * - 根据 msg_type 路由到正确的处理器
+ */
+const { RongyunMessageTypeEnum } = require('./rongyun-message-types');
+
+class StructuredMessageRouter {
+  constructor(config, log) {
+    this.config = config;
+    this.log = log;
+    this.handlers = new Map();
+  }
+
+  /**
+   * 注册消息处理器
+   * @param {string} msgType - 消息类型（来自 RongyunMessageTypeEnum）
+   * @param {Function} handler - 处理函数 async (parsedMessage) => result
+   */
+  registerHandler(msgType, handler) {
+    this.handlers.set(msgType, handler);
+    this.log?.info(`[StructuredMessageRouter] 注册处理器: ${msgType}`);
+  }
+
+  /**
+   * 解析并路由消息
+   * @param {Object} msg - rongcloud-client.js 传来的消息对象
+   * @returns {Object|null} - 如果是结构化消息，返回解析后的对象；否则返回 null
+   */
+  async routeMessage(msg) {
+    if (!msg || !msg.content) {
+      return null;
+    }
+
+    // 尝试解析 JSON
+    let parsed = null;
+    try {
+      parsed = JSON.parse(msg.content);
+    } catch {
+      // 不是 JSON，可能是普通文本消息
+      return null;
+    }
+
+    // 检查是否是结构化协议消息
+    if (!parsed.msg_type) {
+      return null;
+    }
+
+    this.log?.info(`[StructuredMessageRouter] 收到结构化消息: type=${parsed.msg_type}, from=${parsed.source_im_id}`);
+
+    // 忽略自己发送的消息
+    if (parsed.source_im_id === this.config.accountId) {
+      this.log?.info(`[StructuredMessageRouter] 忽略自己发送的消息`);
+      return { handled: true };
+    }
+
+    // 查找处理器
+    const handler = this.handlers.get(parsed.msg_type);
+    if (handler) {
+      try {
+        // 解析 content 字段（它本身可能是 JSON 字符串）
+        let innerContent = parsed.content;
+        if (typeof innerContent === 'string') {
+          try {
+            innerContent = JSON.parse(innerContent);
+          } catch {
+            // 保持字符串
+          }
+        }
+
+        const messageData = {
+          ...parsed,
+          content: innerContent,
+          rawMessage: msg,
+        };
+
+        await handler(messageData);
+        return { handled: true };
+      } catch (err) {
+        this.log?.error(`[StructuredMessageRouter] 处理器异常: ${err.message}`);
+        return { handled: true, error: err.message };
+      }
+    }
+
+    // 没有注册处理器，返回 null 让上层处理
+    this.log?.warn(`[StructuredMessageRouter] 未找到处理器: ${parsed.msg_type}`);
+    return null;
+  }
+
+  /**
+   * 检查消息是否是结构化消息
+   */
+  isStructuredMessage(msg) {
+    if (!msg || !msg.content) return false;
+    try {
+      const parsed = JSON.parse(msg.content);
+      return !!parsed.msg_type;
+    } catch {
+      return false;
+    }
+  }
+}
+
+module.exports = {
+  StructuredMessageRouter
+};

package/service/rongcloud/env-polyfill.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * 环境模拟 (Polyfill)
+ * 让融云 Web SDK (@rongcloud/imlib-next) 能在 Node.js 环境中运行
+ */
+require("fake-indexeddb/auto");
+
+const { JSDOM } = require("jsdom");
+const WebSocket = require("ws");
+const { Blob, File } = require("node:buffer");
+const crypto = require("crypto");
+
+const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
+  url: 'http://localhost',
+  pretendToBeVisual: true,
+  resources: 'usable',
+  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+});
+
+const window = dom.window;
+const g = global;
+const win = window;
+
+function defineWinProp(key, value) {
+  try {
+    Object.defineProperty(win, key, {
+      value: value,
+      writable: true,
+      configurable: true,
+      enumerable: true
+    });
+  } catch {}
+}
+
+function defineGlobalProp(key, value) {
+  try {
+    Object.defineProperty(g, key, {
+      value: value,
+      writable: true,
+      configurable: true,
+      enumerable: true
+    });
+  } catch {}
+}
+
+if (g.indexedDB) {
+  defineWinProp('indexedDB', g.indexedDB);
+  defineWinProp('IDBKeyRange', g.IDBKeyRange);
+  defineWinProp('IDBRequest', g.IDBRequest);
+  defineWinProp('IDBDatabase', g.IDBDatabase);
+  defineWinProp('IDBTransaction', g.IDBTransaction);
+  defineWinProp('IDBCursor', g.IDBCursor);
+  defineWinProp('IDBIndex', g.IDBIndex);
+  defineWinProp('IDBFactory', g.IDBFactory);
+}
+
+const storageMock = {
+  getItem: (k) => null,
+  setItem: (k, v) => {},
+  removeItem: (k) => {},
+  clear: () => {},
+  length: 0,
+  key: (i) => null
+};
+defineWinProp('localStorage', storageMock);
+defineWinProp('sessionStorage', storageMock);
+defineGlobalProp('localStorage', storageMock);
+defineGlobalProp('sessionStorage', storageMock);
+
+if (!win.crypto) {
+  defineWinProp('crypto', crypto.webcrypto);
+}
+if (!g.crypto) {
+  defineGlobalProp('crypto', crypto.webcrypto);
+}
+
+defineWinProp('onLine', true);
+defineWinProp('language', 'zh-CN');
+defineGlobalProp('navigator', win.navigator);
+
+defineGlobalProp('WebSocket', WebSocket);
+defineGlobalProp('XMLHttpRequest', win.XMLHttpRequest);
+defineGlobalProp('window', win);
+defineGlobalProp('document', win.document);
+defineGlobalProp('location', win.location);
+
+if (!win.Blob) defineWinProp('Blob', Blob);
+if (!win.File) defineWinProp('File', File);
+if (!win.URL) defineWinProp('URL', { createObjectURL: () => '', revokeObjectURL: () => {} });
+
+if (!win.requestAnimationFrame) defineWinProp('requestAnimationFrame', (cb) => setTimeout(cb, 16));
+if (!win.cancelAnimationFrame) defineWinProp('cancelAnimationFrame', (id) => clearTimeout(id));
+if (!win.performance) defineWinProp('performance', { now: () => Date.now() });
+
+module.exports = { window };

package/service/rongcloud/index.js

@@ -0,0 +1,19 @@
+const { MessageType } = require('./types');
+const { MessageHandler } = require('./message-handler');
+const { OpenClawClient } = require('./openclaw-client');
+const { RongCloudClient, ConversationType } = require('./rongcloud-client');
+const { ensurePluginsAllow } = require('./openclaw-config');
+
+function createRongCloudModule(config, sendFn, log) {
+  return new MessageHandler(config, sendFn, log);
+}
+
+module.exports = {
+  MessageType,
+  MessageHandler,
+  OpenClawClient,
+  RongCloudClient,
+  ConversationType,
+  ensurePluginsAllow,
+  createRongCloudModule
+};

package/service/rongcloud/message-handler.js

@@ -0,0 +1,147 @@
+const { MessageType } = require('./types');
+const { OpenClawClient } = require('./openclaw-client');
+const { handleNormalMessage } = require('../modules/normal-message-handler');
+const MENTION_REGEX = /@(claw_[a-zA-Z0-9]+)/g;
+
+class MessageHandler {
+  constructor(config, sendFn, log, sendReadReceiptFn) {
+    this.config = config;
+    this.sendFn = sendFn;
+    this.log = log;
+    this.sendReadReceiptFn = sendReadReceiptFn;
+    this.openclawClient = new OpenClawClient(log);
+    this.nodeId = config.accountId || '';
+    this.handleNormalMessage = handleNormalMessage;
+  }
+
+  extractMentions(content) {
+    const mentions = [];
+    let match;
+    while ((match = MENTION_REGEX.exec(content)) !== null) {
+      mentions.push(match[1]);
+    }
+    MENTION_REGEX.lastIndex = 0;
+    return mentions;
+  }
+
+  shouldHandleMessage(msg) {
+    if (msg.isOffLineMessage) {
+      this.log?.info('[MessageHandler] 忽略离线消息');
+      return false;
+    }
+
+    const allowedTypes = ['RC:TxtMsg', 'claw'];
+    if (!allowedTypes.includes(msg.messageType)) {
+      this.log?.info(`[MessageHandler] 忽略非文本消息: ${msg.messageType}`);
+      return false;
+    }
+
+    if (msg.senderUserId === this.config.accountId) {
+      this.log?.info('[MessageHandler] 忽略自己发送的消息');
+      return false;
+    }
+
+    const mentions = this.extractMentions(msg.content);
+
+    if (mentions.length > 0) {
+      if (!mentions.includes(this.nodeId)) {
+        this.log?.info(`[MessageHandler] 消息 @${mentions.join(', ')}，非本节点(${this.nodeId})，忽略`);
+        return false;
+      }
+      this.log?.info(`[MessageHandler] 消息提及本节点(${this.nodeId})，处理`);
+    } else {
+      this.log?.info(`[MessageHandler] 消息未指定节点，本节点(${this.nodeId})处理`);
+    }
+
+    return true;
+  }
+
+  async handleMessage(msg) {
+    if (!this.shouldHandleMessage(msg)) {
+      return;
+    }
+
+    try {
+      const type = this.getMessageType(msg);
+      this.log?.info(`[MessageHandler] 收到消息 from=${msg.senderUserId}, type=${type}, content=${msg.content.substring(0, 50)}`);
+      if (msg.messageType === 'claw') {
+        this.log?.info(`收到龙虾消息，交由 OpenClawClient 处理`);
+        await this.handleClaw(msg);
+      } else {
+        await this.handleNormalMessage(msg);
+      }
+    } catch (err) {
+      this.log?.error(`[MessageHandler] 处理消息异常: ${err.message}`);
+      const targetId = msg.conversationType === 3 ? msg.targetId : msg.senderUserId;
+      await this.sendFn(targetId, `处理失败: ${err.message}`, msg.conversationType);
+    }
+  }
+
+  getMessageType(msg) {
+    if (msg.messageType === 'claw') {
+      return MessageType.CLAW;
+    }
+    if (msg.content && msg.content.startsWith('/')) {
+      return MessageType.COMMAND;
+    }
+    return MessageType.NORMAL;
+  }
+
+  getReplyTarget(msg) {
+    if (msg.conversationType === 3) {
+      return msg.targetId;
+    }
+    return msg.senderUserId;
+  }
+
+  async handleCommand(msg) {
+    const payload = this.parseCommand(msg.content, msg.senderUserId);
+    this.log?.info(`[MessageHandler] 指令消息: command=${payload.command}, args=${payload.args.join(', ')}`);
+
+    let reply;
+    if (this.config.onCommand) {
+      try {
+        reply = await this.config.onCommand(payload);
+      } catch (err) {
+        this.log?.error(`[MessageHandler] 指令处理回调异常: ${err.message}`);
+        reply = `指令执行异常: ${err.message}`;
+      }
+    } else {
+      reply = `指令 "${payload.command}" 暂未实现`;
+    }
+
+    const targetId = this.getReplyTarget(msg);
+    await this.sendFn(targetId, reply, msg.conversationType);
+  }
+
+  async handleClaw(msg) {
+    // 先发送已读回执（表示消息已被接收和处理）
+    if (this.sendReadReceiptFn) {
+      try {
+        await this.sendReadReceiptFn(msg);
+        this.log?.info(`[MessageHandler] 已读回执已发送`);
+      } catch (err) {
+        this.log?.error(`[MessageHandler] 发送已读回执失败: ${err.message}`);
+      }
+    }
+
+    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);
+  }
+
+  parseCommand(raw, senderId) {
+    const trimmed = raw.slice(1).trim();
+    const parts = trimmed.split(/\s+/);
+    return {
+      command: parts[0] || '',
+      args: parts.slice(1),
+      rawMessage: raw,
+      senderId
+    };
+  }
+}
+
+module.exports = { MessageHandler };