claw-subagent-service 0.0.0

package/service/rongcloud/message-types.js

@@ -0,0 +1,22 @@
+const RongyunMessageTypeEnum = {
+  CLIENT_CONNECTED: "client_connected",
+  CLIENT_DISCONNECTED: "client_disconnected",
+  HEARTBEAT: "heartbeat",
+  HEARTBEAT_ACK: "heartbeat_ack",
+  DASHBOARD_REPORT: "dashboard_report",
+  DASHBOARD_REPORT_ACK: "dashboard_report_ack",
+  DASHBOARD_SESSIONS: "dashboard_sessions",
+  DASHBOARD_JOBS: "dashboard_jobs",
+  DASHBOARD_PROJECTS: "dashboard_projects",
+  DASHBOARD_SUMMARIES: "dashboard_summaries",
+  DASHBOARD_SESSIONS_CONTEXTS: "dashboard_sessions_contexts",
+  DASHBOARD_USAGE_EVENTS: "dashboard_usage_events",
+  COMMAND: "command",
+  COMMAND_RESULT: "command_result",
+  CHAT_MESSAGE: "chat_message",
+  CREATE_OPENCODE_SESSION: "create_opencode_session",
+  OPENCODE_SESSION_CREATED: "opencode_session_created",
+  DELETE_OPENCODE_SESSION: "delete_opencode_session"
+};
+
+module.exports = { RongyunMessageTypeEnum };

package/service/rongcloud/openclaw-client.js

@@ -0,0 +1,98 @@
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+class OpenClawClient {
+  constructor(log) {
+    this.log = log;
+  }
+
+  async chat(message, fromUser) {
+    if (!message || !message.trim()) {
+      return '消息内容为空';
+    }
+    this.log?.info(`[OpenClawClient] 准备发送消息到 OpenClaw，from=${fromUser}, message=${message.substring(0, 50)}`);
+    // 固定 session-id 前缀，确保静默服务的会话与桌面客户端完全隔离
+    const sessionId = `clawmessenger-${fromUser}`;
+    // 转义消息中的特殊字符：双引号和换行符
+    const escapedMessage = message
+      .replace(/\\/g, '\\\\')
+      .replace(/"/g, '\\"')
+      .replace(/\r\n/g, ' ')
+      .replace(/\n/g, ' ')
+      .replace(/\r/g, ' ');
+    // 使用默认 agent (main) 处理消息，不指定 --agent 参数
+    const gatewayUrl = 'http://127.0.0.1:5678';
+    const cmd = `openclaw agent -m "${escapedMessage}" --session-id ${sessionId}`;
+
+    this.log?.info(`[OpenClawClient] 执行命令: ${cmd}`);
+    this.log?.info(`[OpenClawClient] Gateway URL: ${gatewayUrl}`);
+
+    try {
+      const { stdout, stderr } = await execAsync(cmd, {
+        timeout: 1200000,
+        maxBuffer: 1024 * 1024,
+        shell: true,
+        windowsHide: true,
+        env: {
+          ...process.env,
+          OPENCLAW_GATEWAY_URL: gatewayUrl,
+        },
+      });
+
+      this.log?.info(`[OpenClawClient] stdout: ${stdout?.substring(0, 200) || '(empty)'}`);
+      if (stderr) this.log?.error(`[OpenClawClient] stderr: ${stderr?.substring(0, 200) || '(empty)'}`);
+
+      const output = stdout || stderr || '';
+      return this.cleanOutput(output);
+    } catch (err) {
+      this.log?.error(`[OpenClawClient] 执行异常: ${err.message}`);
+      this.log?.error(`[OpenClawClient] 错误码: ${err.code}`);
+      if (err.killed) {
+        return 'OpenClaw 响应超时';
+      }
+      if (err.code === 'ENOENT') {
+        return '找不到 openclaw 命令';
+      }
+      return `OpenClaw 调用失败: ${err.message}`;
+    }
+  }
+
+  cleanOutput(output) {
+    const lines = output.split('\n');
+    const cleanLines = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+
+      // 移除 ANSI 颜色代码
+      const cleanLine = trimmed.replace(/\x1B\[[0-9;]*m/g, '');
+
+      // 跳过所有调试/配置日志行
+      if (cleanLine.startsWith('[ws]')) continue;
+      if (cleanLine.startsWith('[health-monitor]')) continue;
+      if (cleanLine.startsWith('[OpenClawConfig]')) continue;
+      if (cleanLine.startsWith('[plugins]')) continue;
+      if (cleanLine.includes('龙虾信使插件已注册')) continue;
+      if (cleanLine.includes('龙虾信使')) continue;
+      if (cleanLine.includes('已加载配置文件')) continue;
+      if (cleanLine.includes('plugins.allow')) continue;
+      if (cleanLine.includes('Config warnings')) continue;
+      if (cleanLine.includes('stale config')) continue;
+      if (cleanLine.includes('plugin not found')) continue;
+      if (cleanLine.includes('⇄ res')) continue;
+      if (cleanLine.includes('chat.history')) continue;
+      if (cleanLine.includes('models.list')) continue;
+      if (cleanLine.includes('node.list')) continue;
+      if (/^\d{2}:\d{2}:\d{2}/.test(cleanLine)) continue; // 时间戳开头的日志
+
+      cleanLines.push(cleanLine);
+    }
+
+    return cleanLines.join('\n').trim() || 'OpenClaw 未返回有效响应';
+  }
+}
+
+module.exports = { OpenClawClient };

package/service/rongcloud/openclaw-config.js

@@ -0,0 +1,108 @@
+const { homedir } = require('os');
+const { join } = require('path');
+const { mkdirSync, readFileSync, writeFileSync, existsSync, renameSync } = require('fs');
+
+const OPENCLAW_DIR = join(homedir(), '.openclaw');
+const SETTINGS_FILE = join(OPENCLAW_DIR, 'openclaw.json');
+
+// 静默服务不需要强制启用任何 openclaw 插件
+const DEFAULT_PLUGINS = [];
+const REMOVED_PLUGINS = ['openclaw-weixin', 'openclaw-wechat'];
+
+function isPluginDirExists(pluginName) {
+  const pluginDir = join(OPENCLAW_DIR, 'extensions', pluginName);
+  return existsSync(pluginDir);
+}
+
+function disableBrokenPlugin(pluginName, log) {
+  const pluginDir = join(OPENCLAW_DIR, 'extensions', pluginName);
+  const disabledDir = pluginDir + '.bak.disabled';
+  if (!existsSync(pluginDir)) return;
+  try {
+    if (existsSync(disabledDir)) {
+      const { rmSync } = require('fs');
+      rmSync(pluginDir, { recursive: true, force: true });
+    } else {
+      renameSync(pluginDir, disabledDir);
+    }
+    log?.warn(`[OpenClawConfig] ${pluginName} 已禁用（目录重命名为 .bak.disabled）`);
+  } catch (err) {
+    log?.error(`[OpenClawConfig] 禁用 ${pluginName} 失败: ${err.message}`);
+  }
+}
+
+function ensurePluginsAllow(log) {
+  try {
+    if (!existsSync(OPENCLAW_DIR)) {
+      mkdirSync(OPENCLAW_DIR, { recursive: true });
+    }
+  } catch {}
+
+  let settings = {};
+
+  try {
+    const content = readFileSync(SETTINGS_FILE, 'utf-8');
+    settings = JSON.parse(content);
+    log?.info('[OpenClawConfig] 已加载配置');
+  } catch {
+    log?.info('[OpenClawConfig] 创建新配置');
+    settings = {};
+  }
+
+  if (!settings.plugins) settings.plugins = {};
+
+  const existing = settings.plugins.allow || [];
+  const cleaned = existing.filter(p => !REMOVED_PLUGINS.includes(p));
+  const removedCount = existing.length - cleaned.length;
+
+  const brokenPlugins = [];
+  const healthyPlugins = cleaned.filter(p => {
+    if (!isPluginDirExists(p)) return false;
+    if (p === 'claw_messenger') {
+      const enginePath = join(OPENCLAW_DIR, 'extensions', 'claw_messenger', 'node_modules', '@rongcloud', 'engine');
+      if (!existsSync(enginePath)) {
+        log?.warn(`[OpenClawConfig] claw_messenger 缺少 @rongcloud/engine，自动移除`);
+        brokenPlugins.push(p);
+        return false;
+      }
+    }
+    return true;
+  });
+  const removedBroken = cleaned.length - healthyPlugins.length;
+
+  for (const p of brokenPlugins) {
+    disableBrokenPlugin(p, log);
+  }
+
+  if (settings.channels) {
+    for (const p of brokenPlugins) {
+      if (settings.channels[p] !== undefined) {
+        delete settings.channels[p];
+        log?.warn(`[OpenClawConfig] 已从 channels 移除 ${p}`);
+      }
+    }
+  }
+
+  if (removedCount === 0 && removedBroken === 0) {
+    log?.info('[OpenClawConfig] plugins.allow 已完整');
+    return true;
+  }
+
+  settings.plugins.allow = healthyPlugins;
+
+  try {
+    writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), 'utf-8');
+    if (removedCount > 0) {
+      log?.info(`[OpenClawConfig] 已清理无效插件: ${REMOVED_PLUGINS.join(', ')}`);
+    }
+    if (removedBroken > 0) {
+      log?.info(`[OpenClawConfig] 已清理损坏插件: ${removedBroken} 个`);
+    }
+    return true;
+  } catch (err) {
+    log?.error(`[OpenClawConfig] 写入失败: ${err.message}`);
+    return false;
+  }
+}
+
+module.exports = { ensurePluginsAllow };

package/service/rongcloud/rongcloud-client.js

@@ -0,0 +1,273 @@
+"use strict";
+require("./env-polyfill");
+
+const RongIMLibModule = require("@rongcloud/imlib-next");
+const RongIMLib = RongIMLibModule.default || RongIMLibModule;
+
+const ConversationType = {
+  PRIVATE: 1,
+  GROUP: 3
+};
+
+const SYSTEM_MSG_TYPES = new Set([
+
+]);
+
+class RongCloudClient {
+  constructor(config, log) {
+    this.config = config;
+    this.log = log;
+    this.isConnected = false;
+    this.handler = null;
+    this.processingQueue = Promise.resolve();
+  }
+
+  async connect(handler) {
+    this.handler = handler;
+    this.log?.info('[RongCloudClient] 开始连接融云...');
+
+    if (!RongIMLib || typeof RongIMLib.init !== 'function') {
+      this.log?.error('[RongCloudClient] SDK 未正确加载');
+      return false;
+    }
+
+    this.log?.info('[RongCloudClient] 初始化 SDK...');
+    RongIMLib.init({ appkey: this.config.appKey });
+
+    this.log?.info(`[RongCloudClient] SDK Events: ${JSON.stringify(Object.keys(RongIMLib.Events || {}))}`);
+    this.log?.info(`[RongCloudClient] has addEventListener: ${typeof RongIMLib.addEventListener === 'function'}`);
+    this.log?.info(`[RongCloudClient] has sendReadReceiptMessage: ${typeof RongIMLib.sendReadReceiptMessage === 'function'}`);
+    this.log?.info(`[RongCloudClient] has sendReadReceiptResponseV2: ${typeof RongIMLib.sendReadReceiptResponseV2 === 'function'}`);
+    this.log?.info(`[RongCloudClient] has sendReadReceiptResponseV5: ${typeof RongIMLib.sendReadReceiptResponseV5 === 'function'}`);
+
+    if (RongIMLib.addEventListener) {
+      this.log?.info('[RongCloudClient] 使用 addEventListener 模式');
+
+      RongIMLib.addEventListener(RongIMLib.Events?.MESSAGES || 'MESSAGES', (event) => {
+        // this.log?.info(`[RongCloudClient] 收到消息事件: ${JSON.stringify(event).substring(0, 200)}`);
+        event.messages?.forEach(msg => {
+          this.handleReceivedMessage(msg);
+        });
+      });
+
+      RongIMLib.addEventListener(RongIMLib.Events?.CONNECTED || 'CONNECTED', () => {
+        this.log?.info('[RongCloudClient] 连接成功事件');
+        this.isConnected = true;
+      });
+
+      RongIMLib.addEventListener(RongIMLib.Events?.DISCONNECT || 'DISCONNECT', (code) => {
+        this.log?.warn(`[RongCloudClient] 断开连接, code: ${code}`);
+        this.isConnected = false;
+      });
+    } else {
+      this.log?.info('[RongCloudClient] 使用 setOnReceiveMessageListener 模式');
+
+      RongIMLib.setConnectionStatusListener({
+        onChanged: (status) => {
+          this.log?.info(`[RongCloudClient] 连接状态变化: ${status}`);
+          this.isConnected = status === 3 || status === 'Connected';
+        }
+      });
+
+      RongIMLib.setOnReceiveMessageListener({
+        onReceived: (message) => {
+          this.log?.info(`[RongCloudClient] onReceived: messageType=${message.messageType}, senderUserId=${message.senderUserId}`);
+          this.handleReceivedMessage(message);
+        }
+      });
+    }
+
+    try {
+      this.log?.info('[RongCloudClient] 正在连接...');
+      const result = await RongIMLib.connect(this.config.token);
+      this.log?.info(`[RongCloudClient] connect 结果: code=${result.code}`);
+
+      if (result.code === 0 || result.code === 200) {
+        const userId = result.data?.userId || 'unknown';
+        this.log?.info(`[RongCloudClient] 登录成功, userId: ${userId}`);
+        this.isConnected = true;
+        return true;
+      } else {
+        this.log?.error(`[RongCloudClient] 登录失败, code: ${result.code}`);
+        return false;
+      }
+    } catch (err) {
+      this.log?.error(`[RongCloudClient] 连接异常: ${err.message}`);
+      return false;
+    }
+  }
+
+  handleReceivedMessage(message) {
+    if (message.isOffLineMessage) {
+      return;
+    }
+
+    try {
+      const msgType = message.messageType;
+      let rawContent = message.content;
+
+      // 自定义消息 content 可能是对象，提取文本内容
+      if (rawContent && typeof rawContent === 'object') {
+        rawContent = rawContent.content || rawContent.text || JSON.stringify(rawContent);
+      }
+
+      const content = rawContent || '';
+
+      this.log?.info(`[RongCloudClient] 收到消息: type=${msgType}, from=${message.senderUserId}`);
+
+      if (!content || !content.trim || !content.trim()) {
+        return;
+      }
+
+      let parsed = null;
+      try {
+        parsed = JSON.parse(content);
+      } catch { }
+
+      if (parsed && parsed.msg_type) {
+        if (SYSTEM_MSG_TYPES.has(parsed.msg_type)) {
+          return;
+        }
+        if (parsed.source_im_id === this.config.accountId) {
+          return;
+        }
+      }
+
+      const userContent = parsed && !parsed.msg_type
+        ? (parsed.content || parsed.text || JSON.stringify(parsed))
+        : content;
+
+      if (!userContent || !userContent.trim || !userContent.trim()) {
+        return;
+      }
+
+      const senderUserId = parsed?.source_im_id || message.senderUserId || 'unknown';
+
+      const rongCloudMsg = {
+        senderUserId,
+        targetId: message.targetId || senderUserId,
+        conversationType: message.conversationType || ConversationType.PRIVATE,
+        content: userContent,
+        messageType: msgType || 'RC:TxtMsg',
+        isOffLineMessage: message.isOffLineMessage || false,
+        messageUId: message.messageUId || `local-${Date.now()}`,
+        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}`);
+      });
+    } catch (err) {
+      this.log?.error(`[RongCloudClient] 解析消息失败: ${err.message}`);
+    }
+  }
+
+  async sendMessage(targetId, content, conversationType) {
+    if (!this.isConnected) {
+      this.log?.error('[RongCloudClient] 未连接，无法发送消息');
+      return false;
+    }
+
+    try {
+      const convType = conversationType === ConversationType.GROUP
+        ? (RongIMLib.ConversationType?.GROUP || ConversationType.GROUP)
+        : (RongIMLib.ConversationType?.PRIVATE || ConversationType.PRIVATE);
+
+      this.log?.info(`[RongCloudClient] 发送消息 -> ${targetId} (Type: ${convType}): ${content.substring(0, 50)}`);
+
+      const result = await RongIMLib.sendTextMessage(
+        { conversationType: convType, targetId },
+        { content }
+      );
+
+      // this.log?.info(`[RongCloudClient] 发送结果: code=${result.code}`);
+
+      if (result.code === 0 || result.code === 200) {
+        this.log?.info(`[RongCloudClient] 发送成功, messageUId: ${result.data?.messageUId}`);
+        return true;
+      } else {
+        this.log?.error(`[RongCloudClient] 发送失败, code: ${result.code}`);
+        return false;
+      }
+    } catch (err) {
+      this.log?.error(`[RongCloudClient] 发送异常: ${err.message}`);
+      return false;
+    }
+  }
+
+  async sendReadReceipt(msg) {
+    if (!this.isConnected) {
+      this.log?.warn('[RongCloudClient] 未连接，无法发送已读回执');
+      return false;
+    }
+
+    const { conversationType, senderUserId, targetId, messageUId, sentTime } = msg;
+    if (!messageUId || !sentTime) {
+      this.log?.warn('[RongCloudClient] 消息缺少 messageUId 或 sentTime，无法发送已读回执');
+      return false;
+    }
+
+    // 本地生成的 messageUId 无法发送已读回执
+    if (String(messageUId).startsWith('local-')) {
+      this.log?.warn('[RongCloudClient] messageUId 为本地生成，跳过已读回执');
+      return false;
+    }
+
+    this.log?.info(`[RongCloudClient] 准备发送已读回执: conversationType=${conversationType}, senderUserId=${senderUserId}, targetId=${targetId}, messageUId=${messageUId}, sentTime=${sentTime}`);
+
+    try {
+      // 优先使用 V5 已读回执 API（与前端 enableReadV5 对齐）
+      if (typeof RongIMLib.sendReadReceiptResponseV5 === 'function') {
+        this.log?.info(`[RongCloudClient] 发送 V5 已读回执 -> targetId=${targetId}, messageUId=${messageUId}`);
+        const result = await RongIMLib.sendReadReceiptResponseV5(
+          { conversationType, targetId },
+          [messageUId]
+        );
+        this.log?.info(`[RongCloudClient] V5 已读回执结果: code=${result.code}, msg=${result.msg || ''}`);
+        return result.code === 0 || result.code === 200;
+      }
+
+      if (conversationType === ConversationType.GROUP) {
+        if (typeof RongIMLib.sendReadReceiptResponseV2 !== 'function') {
+          this.log?.warn('[RongCloudClient] SDK 不支持群聊已读回执');
+          return false;
+        }
+        this.log?.info(`[RongCloudClient] 发送群聊已读回执 -> ${targetId}, messageUId=${messageUId}`);
+        const result = await RongIMLib.sendReadReceiptResponseV2(targetId, {
+          [senderUserId]: [messageUId]
+        });
+        this.log?.info(`[RongCloudClient] 群聊已读回执结果: code=${result.code}, msg=${result.msg || ''}`);
+        return result.code === 0 || result.code === 200;
+      } else {
+        if (typeof RongIMLib.sendReadReceiptMessage !== 'function') {
+          this.log?.warn('[RongCloudClient] SDK 不支持单聊已读回执');
+          return false;
+        }
+        this.log?.info(`[RongCloudClient] 发送单聊已读回执 -> ${senderUserId}, messageUId=${messageUId}`);
+        const result = await RongIMLib.sendReadReceiptMessage(senderUserId, messageUId, sentTime);
+        this.log?.info(`[RongCloudClient] 单聊已读回执结果: code=${result.code}, msg=${result.msg || ''}`);
+        return result.code === 0 || result.code === 200;
+      }
+    } catch (err) {
+      this.log?.error(`[RongCloudClient] 发送已读回执异常: ${err.message}`);
+      return false;
+    }
+  }
+
+  async disconnect() {
+    this.log?.info('[RongCloudClient] 断开连接...');
+    this.isConnected = false;
+    try {
+      await RongIMLib.disconnect();
+      this.log?.info('[RongCloudClient] 已断开');
+    } catch (err) {
+      this.log?.error(`[RongCloudClient] 断开异常: ${err.message}`);
+    }
+  }
+}
+
+module.exports = { RongCloudClient, ConversationType };

package/service/rongcloud/types.js

@@ -0,0 +1,9 @@
+const MessageType = {
+  COMMAND: 'command',
+  NORMAL: 'normal',
+  CLAW: 'claw'
+};
+
+module.exports = {
+  MessageType
+};