claw-subagent-service 0.0.0

package/service/modules/opencode-service.js

@@ -0,0 +1,199 @@
+const axios = require('axios');
+
+const GATEWAY_URL = 'http://127.0.0.1:4096';
+
+// 系统提示词 - OpenClaw 运维助手智能体
+const SYSTEM_PROMPT = `你是 虾说app的 openclaw 运维助手智能体，职责有：保活、修配置、做备份 等运维工作。
+
+## 核心职责
+1. **保活**：openclaw 挂了自动拉起来
+2. **修配置**：配置报错时自动修复，修不好就回滚备份
+3. **做备份**：改配置前自动备份到 config.json.bak.时间戳
+
+## 常用运维指令
+| 命令 | 功能 |
+|------|------|
+| \`openclaw doctor\` | 诊断并自动修复问题 |
+| \`openclaw doctor --fix\` | 强制修复配置错误 |
+| \`openclaw status\` | 查看整体运行状态 |
+| \`openclaw dashboard\` | 启动 Web 控制台（默认端口 18789） |
+| \`openclaw gateway start/restart\` | 启动/重启 Gateway |
+| \`openclaw models list\` | 查看可用模型 |
+| \`openclaw channels status\` | 查看通讯平台连接状态 |
+| \`openclaw logs --follow\` | 实时查看运行日志 |
+| \`openclaw onboard --install-daemon\` | 首次配置向导 |
+
+## 修不好的时候，查资料顺序
+1. \`openclaw <命令> --help\` 先看本地帮助
+2. https://docs.openclaw.ai 官方文档
+3. https://github.com/openclaw/openclaw/issues GitHub 搜报错关键词
+
+## 铁律
+- 改配置必须先备份
+- 执行命令后汇报结果，别沉默
+- 不知道就查资料，别瞎猜
+- 不要对外透漏你是什么模型，不要说你是opencode，对外你就说你是 虾说运维大模型；
+`;
+
+async function createOpencodeSession(title) {
+  const response = await axios.post(`${GATEWAY_URL}/session`, { title }, {
+    headers: { 'Content-Type': 'application/json' },
+    timeout: 10000
+  });
+  return response.data || {};
+}
+
+async function deleteOpencodeSession(sessionId) {
+  try {
+    await axios.delete(`${GATEWAY_URL}/session/${sessionId}`, { timeout: 10000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function getOrCreateGatewaySession(fallbackSessionId) {
+  console.log(`[CHAT-DEBUG] getOrCreateGatewaySession called with fallback: ${fallbackSessionId}`);
+  
+  try {
+    const response = await axios.get(`${GATEWAY_URL}/api/sessions`, { timeout: 5000 });
+    const sessions = response.data;
+    console.log(`[CHAT-DEBUG] Existing sessions: ${JSON.stringify(sessions)}`);
+    if (Array.isArray(sessions) && sessions.length > 0) {
+      const sessionId = sessions[0].id || sessions[0].session_id;
+      if (sessionId) {
+        console.log(`[CHAT-DEBUG] Using existing session: ${sessionId}`);
+        return sessionId;
+      }
+    }
+  } catch (e) {
+    console.log(`[CHAT-DEBUG] Failed to get sessions: ${e.message}`);
+  }
+
+  try {
+    const response = await axios.post(
+      `${GATEWAY_URL}/api/sessions`,
+      { title: 'Chat session' },
+      { headers: { 'Content-Type': 'application/json' }, timeout: 5000 }
+    );
+    const newSessionId = response.data?.id || response.data?.session_id;
+    console.log(`[CHAT-DEBUG] Created new session: ${newSessionId}`);
+    if (newSessionId) {
+      return newSessionId;
+    }
+  } catch (e) {
+    console.log(`[CHAT-DEBUG] Failed to create session: ${e.message}`);
+  }
+  
+  if (fallbackSessionId) {
+    console.log(`[CHAT-DEBUG] Using fallback session: ${fallbackSessionId}`);
+    return fallbackSessionId;
+  }
+  
+  throw new Error('无法获取或创建有效的 session ID');
+}
+
+async function forwardChatMessage(sessionId, content, onDelta, logFn, timeoutMs = 600000) {
+  const log = (level, message) => {
+    console.log(`[CHAT-DEBUG] ${level}: ${message}`);
+    if (logFn) logFn(level, message);
+  };
+
+  log('DEBUG', `原始 sessionId: ${sessionId}`);
+  const realSessionId = await getOrCreateGatewaySession(sessionId);
+  log('DEBUG', `实际 sessionId: ${realSessionId}`);
+  const url = `${GATEWAY_URL}/session/${realSessionId}/message`;
+  log('DEBUG', `请求 URL: ${url}`);
+
+  log('DEBUG', `系统提示词长度: ${SYSTEM_PROMPT.length} 字符`);
+  log('DEBUG', `发送消息: ${content}`);
+  log('DEBUG', `请求超时: ${timeoutMs}ms`);
+  
+  // 构建请求体，包含 system 参数
+  const requestBody = {
+    system: SYSTEM_PROMPT,
+    parts: [{ type: 'text', text: content }]
+  };
+  
+  log('DEBUG', `请求体包含 system 参数: ${!!requestBody.system}`);
+  
+  const response = await axios.post(url, requestBody, {
+    headers: { 'Content-Type': 'application/json' },
+    timeout: timeoutMs
+  });
+
+  const result = response.data || {};
+  log('DEBUG', `响应状态: ${response.status}`);
+  log('DEBUG', `响应数据 keys: ${Object.keys(result).join(', ')}`);
+  log('DEBUG', `响应数据: ${JSON.stringify(result).substring(0, 500)}`);
+
+  const parts = result.parts || [];
+  const info = result.info || {};
+
+  let fullContent = '';
+
+  for (const key of ['text', 'content', 'response', 'output', 'message', 'reply']) {
+    const val = result[key];
+    if (val && typeof val === 'string') {
+      fullContent = val;
+      log('DEBUG', `从顶层字段 ${key} 提取到内容`);
+      break;
+    }
+  }
+
+  if (!fullContent) {
+    for (const part of parts) {
+      const text = part.text || part.content || part.value || '';
+      const partType = part.type || '';
+      if (text && ['text', 'assistant', 'message', 'response', ''].includes(partType)) {
+        fullContent += String(text);
+      }
+    }
+    if (fullContent) log('DEBUG', `从 parts 中提取到内容, 长度: ${fullContent.length}`);
+  }
+
+  if (!fullContent) {
+    for (const part of parts) {
+      for (const key of ['text', 'content', 'value', 'output']) {
+        const val = part[key];
+        if (val && typeof val === 'string') {
+          fullContent += val;
+          break;
+        }
+      }
+    }
+    if (fullContent) log('DEBUG', `从所有 parts 兜底提取到内容, 长度: ${fullContent.length}`);
+  }
+
+  if (!fullContent) {
+    const infoText = info.text || info.content || '';
+    if (infoText) fullContent = infoText;
+  }
+
+  if (!fullContent) {
+    log('ERROR', `Gateway 返回空内容, parts 数量: ${parts.length}`);
+    throw new Error('Gateway 返回空内容');
+  }
+
+  log('DEBUG', `总内容长度: ${fullContent.length}, 开始模拟流式发送`);
+  const chunkSize = 50;
+  for (let i = 0; i < fullContent.length; i += chunkSize) {
+    const chunk = fullContent.slice(i, i + chunkSize);
+    await onDelta(chunk);
+    // 仅在非测试环境添加延迟
+    if (process.env.NODE_ENV !== 'test') {
+      await new Promise((resolve) => setTimeout(resolve, 30));
+    }
+  }
+  log('DEBUG', '流式发送完成');
+
+  return fullContent;
+}
+
+module.exports = {
+  createOpencodeSession,
+  deleteOpencodeSession,
+  getOrCreateGatewaySession,
+  forwardChatMessage,
+  SYSTEM_PROMPT
+};

package/service/modules/opencode-starter.js

@@ -0,0 +1,194 @@
+/**
+ * OpenClaw 服务启动器 - 与桌面客户端对齐
+ * 
+ * 桌面客户端启动流程：
+ * 1. 检查端口 4096 是否已被占用
+ * 2. 如果未占用，检查 opencode 是否已安装
+ * 3. 如果未安装，自动安装 opencode-ai
+ * 4. 启动 opencode serve --port 4096
+ * 
+ * 参考: nodejs_client/src/main/rongyun-client.ts startOpencodeService()
+ */
+const net = require('net');
+const { spawn, exec } = require('child_process');
+
+/**
+ * 检查端口是否可用
+ */
+function checkPort(port = 4096, host = '127.0.0.1') {
+  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, host);
+  });
+}
+
+/**
+ * 检查 opencode 是否已安装
+ */
+function checkOpencodeInstalled() {
+  return new Promise((resolve) => {
+    const checkCmd = process.platform === 'win32' ? 'where opencode' : 'which opencode';
+    exec(checkCmd, { timeout: 5000 }, (error) => {
+      resolve(!error);
+    });
+  });
+}
+
+/**
+ * 安装 opencode
+ */
+function installOpencode(log) {
+  return new Promise((resolve) => {
+    log?.info('[OPENCODE] 执行: npm install -g opencode-ai@latest');
+    
+    const installChild = spawn(
+      'npm',
+      ['install', '-g', 'opencode-ai@latest'],
+      { shell: true, windowsHide: true }
+    );
+    
+    let installOutput = '';
+    let installError = '';
+    
+    installChild.stdout?.on('data', (data) => {
+      installOutput += data.toString();
+    });
+    
+    installChild.stderr?.on('data', (data) => {
+      installError += data.toString();
+    });
+    
+    installChild.on('close', (code) => {
+      if (code === 0) {
+        log?.info('[OPENCODE] opencode 安装成功');
+        resolve(true);
+      } else {
+        log?.error(`[OPENCODE] 安装失败，退出码: ${code}`);
+        if (installError) {
+          log?.error(`[OPENCODE] 安装错误: ${installError.substring(0, 500)}`);
+        }
+        resolve(false);
+      }
+    });
+    
+    installChild.on('error', (err) => {
+      log?.error(`[OPENCODE] 安装进程错误: ${err.message}`);
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * 启动 opencode 服务
+ */
+function startOpencodeProcess(log) {
+  return new Promise((resolve) => {
+    log?.info('[OPENCODE] 正在启动 opencode serve...');
+    
+    const child = spawn(
+      'opencode',
+      ['serve', '--port', '4096', '--hostname', '127.0.0.1'],
+      { shell: true, windowsHide: true }
+    );
+    
+    // 保存进程引用，以便后续关闭
+    global.opencodeProcess = child;
+    
+    child.stdout?.on('data', (data) => {
+      log?.info(`[OPENCODE-OUT] ${data.toString().trim()}`);
+    });
+    
+    child.stderr?.on('data', (data) => {
+      log?.error(`[OPENCODE-ERR] ${data.toString().trim()}`);
+    });
+    
+    child.on('close', (code) => {
+      log?.warn(`[OPENCODE] 服务进程退出，退出码: ${code}`);
+      global.opencodeProcess = null;
+    });
+    
+    child.on('error', (err) => {
+      log?.error(`[OPENCODE] 服务进程错误: ${err.message}`);
+    });
+    
+    // 等待 10 秒让服务启动
+    setTimeout(() => {
+      resolve();
+    }, 10000);
+  });
+}
+
+/**
+ * 启动 OpenClaw 服务
+ * 与桌面客户端对齐
+ */
+async function startOpencodeService(log) {
+  // 检查端口是否已被占用
+  if (await checkPort(4096)) {
+    log?.info('[OPENCODE] 服务已在运行 (port 4096)');
+    return true;
+  }
+
+  // 检查 opencode 是否已安装
+  const isInstalled = await checkOpencodeInstalled();
+  if (!isInstalled) {
+    log?.warn('[OPENCODE] opencode 未安装，正在自动安装...');
+    
+    const installResult = await installOpencode(log);
+    if (!installResult) {
+      log?.error('[OPENCODE] 自动安装失败，请手动运行: npm install -g opencode-ai@latest');
+      return false;
+    }
+    
+    // 安装成功后等待 5 秒
+    log?.info('[OPENCODE] 等待 5 秒让安装生效...');
+    await new Promise(resolve => setTimeout(resolve, 5000));
+  }
+
+  // 启动服务
+  await startOpencodeProcess(log);
+  
+  // 再次检查端口
+  if (await checkPort(4096)) {
+    log?.info('[OPENCODE] 服务启动成功');
+    return true;
+  } else {
+    log?.warn('[OPENCODE] 服务可能未启动成功，请手动检查');
+    return false;
+  }
+}
+
+/**
+ * 停止 OpenClaw 服务
+ */
+function stopOpencodeService(log) {
+  if (global.opencodeProcess) {
+    log?.info('[OPENCODE] 正在停止服务...');
+    try {
+      global.opencodeProcess.kill();
+      global.opencodeProcess = null;
+      log?.info('[OPENCODE] 服务已停止');
+    } catch (err) {
+      log?.error(`[OPENCODE] 停止服务失败: ${err.message}`);
+    }
+  }
+}
+
+module.exports = {
+  startOpencodeService,
+  stopOpencodeService,
+  checkPort
+};

package/service/modules/port-checker.js

@@ -0,0 +1,31 @@
+const net = require('net');
+
+function checkPortListening(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');
+  });
+}
+
+async function getOpenClawStatus(port = 18789) {
+  const isListening = await checkPortListening(port);
+  return isListening ? 1 : 0;
+}
+
+module.exports = {
+  checkPortListening,
+  getOpenClawStatus,
+};

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

@@ -0,0 +1,250 @@
+/**
+ * 融云消息处理器 - 与桌面客户端对齐
+ * 
+ * 处理服务端发送的所有结构化消息类型：
+ * - COMMAND: 执行 start/stop/restart/status 命令
+ * - CHAT_MESSAGE: 转发消息到 OpenClaw AI 服务
+ * - CREATE_OPENCODE_SESSION: 创建新会话
+ * - DELETE_OPENCODE_SESSION: 删除会话
+ */
+const { RongyunMessageTypeEnum } = require('./rongyun-message-types');
+const { OpenClawCommandEnum } = require('./openclaw-enum');
+const { executeCommand } = require('./openclaw-control');
+const { createOpencodeSession, deleteOpencodeSession, forwardChatMessage } = require('./opencode-service');
+
+class RongyunMessageHandler {
+  constructor(rongcloudClient, config, log) {
+    this.rongcloudClient = rongcloudClient;
+    this.config = config;
+    this.log = log;
+    this.commandLock = false;
+    this.messageSender = null;
+  }
+
+  setMessageSender(messageSender) {
+    this.messageSender = messageSender;
+  }
+
+  logInfo(message) {
+    if (this.log?.info) {
+      this.log.info(message);
+    } else {
+      console.log(`[INFO] ${message}`);
+    }
+  }
+
+  logWarn(message) {
+    if (this.log?.warn) {
+      this.log.warn(message);
+    } else {
+      console.log(`[WARN] ${message}`);
+    }
+  }
+
+  logError(message) {
+    if (this.log?.error) {
+      this.log.error(message);
+    } else {
+      console.error(`[ERROR] ${message}`);
+    }
+  }
+
+  async handle(parsed) {
+    try {
+      if (!parsed || typeof parsed !== 'object') {
+        this.logWarn('Invalid message format');
+        return;
+      }
+
+      const msgType = parsed.msg_type;
+      this.logInfo(`[RongyunMessageHandler] 处理消息类型: ${msgType}`);
+
+      switch (msgType) {
+        case RongyunMessageTypeEnum.COMMAND:
+          await this.handleCommand(parsed);
+          break;
+        case RongyunMessageTypeEnum.CHAT_MESSAGE:
+          await this.handleChatMessage(parsed);
+          break;
+        case RongyunMessageTypeEnum.CREATE_OPENCODE_SESSION:
+          await this.handleCreateSession(parsed);
+          break;
+        case RongyunMessageTypeEnum.DELETE_OPENCODE_SESSION:
+          await this.handleDeleteSession(parsed);
+          break;
+        default:
+          this.logWarn(`未处理的消息类型: ${msgType}`);
+      }
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.logError(`消息处理异常: ${msg}`);
+    }
+  }
+
+  async handleCommand(data) {
+    const command = data.command;
+    const commandId = data.command_id;
+    const requestId = data.request_id;
+
+    this.logInfo(`[RongyunMessageHandler] 收到命令: command=${command}, command_id=${commandId}`);
+
+    // 验证命令是否有效
+    const validCommands = Object.values(OpenClawCommandEnum);
+    if (!validCommands.includes(command)) {
+      await this.sendResponse(RongyunMessageTypeEnum.COMMAND_RESULT, {
+        command,
+        command_id: commandId,
+        status: 'error',
+        message: `未知命令: ${command}`
+      }, requestId);
+      return;
+    }
+
+    // 检查命令锁
+    if (this.commandLock) {
+      await this.sendResponse(RongyunMessageTypeEnum.COMMAND_RESULT, {
+        command,
+        command_id: commandId,
+        status: 'busy',
+        message: '正在执行上一个指令，请稍后再试'
+      }, requestId);
+      return;
+    }
+
+    this.commandLock = true;
+    try {
+      await executeCommand(command, null, async (response) => {
+        // 增加短暂延迟，避免融云 SDK 在收到消息后立刻回复时消息丢失
+        await new Promise(resolve => setTimeout(resolve, 500));
+        await this.sendResponse(RongyunMessageTypeEnum.COMMAND_RESULT, {
+          ...response,
+          command_id: commandId
+        }, requestId);
+      });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.logError(`命令执行异常: ${msg}`);
+      await this.sendResponse(RongyunMessageTypeEnum.COMMAND_RESULT, {
+        command,
+        command_id: commandId,
+        status: 'error',
+        message: msg
+      }, requestId);
+    } finally {
+      this.commandLock = false;
+    }
+  }
+
+  async handleChatMessage(data) {
+    const roomId = data.room_id;
+    const sessionId = data.gateway_session_id || data.session_id;
+    const content = data.content;
+    const requestId = data.request_id;
+
+    this.logInfo(`[RongyunMessageHandler] 收到聊天消息, roomId=${roomId}, sessionId=${sessionId}`);
+
+    if (!roomId || !sessionId || !content) {
+      await this.sendResponse(RongyunMessageTypeEnum.CHAT_MESSAGE, {
+        status: 'error',
+        message: '缺少必要参数',
+        content: '[错误] 缺少必要参数',
+        metadata: {}
+      }, requestId);
+      return;
+    }
+
+    let fullResponse = '';
+    const chatTimeoutMs = (this.config.chatTimeout || 600) * 1000;
+
+    try {
+      await forwardChatMessage(sessionId, content, async (delta) => {
+        fullResponse += delta;
+      }, (level, message) => {
+        if (level === 'ERROR') {
+          this.logError(`[CHAT-API] ${message}`);
+        } else if (level === 'WARN') {
+          this.logWarn(`[CHAT-API] ${message}`);
+        } else {
+          this.logInfo(`[CHAT-API] ${message}`);
+        }
+      }, chatTimeoutMs);
+
+      await this.sendResponse(RongyunMessageTypeEnum.CHAT_MESSAGE, {
+        status: 'success',
+        message: 'Response received',
+        content: fullResponse,
+        metadata: {}
+      }, requestId);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.logError(`聊天消息处理异常: ${msg}`);
+      await this.sendResponse(RongyunMessageTypeEnum.CHAT_MESSAGE, {
+        status: 'error',
+        message: msg,
+        content: `[错误] 转发失败: ${msg}`,
+        metadata: {}
+      }, requestId);
+    }
+  }
+
+  async handleCreateSession(data) {
+    const requestId = data.request_id;
+    const title = data.title || '新会话';
+
+    this.logInfo(`[RongyunMessageHandler] 创建会话, title=${title}`);
+
+    try {
+      const session = await createOpencodeSession(title);
+      this.logInfo(`会话创建成功: ${session.id}`);
+      await this.sendResponse(RongyunMessageTypeEnum.OPENCODE_SESSION_CREATED, {
+        status: 'success',
+        opencode_session_id: session.id
+      }, requestId);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.logError(`创建会话失败: ${msg}`);
+      await this.sendResponse(RongyunMessageTypeEnum.OPENCODE_SESSION_CREATED, {
+        status: 'error',
+        message: msg
+      }, requestId);
+    }
+  }
+
+  async handleDeleteSession(data) {
+    const sessionId = data.opencode_session_id;
+
+    this.logInfo(`[RongyunMessageHandler] 删除会话, sessionId=${sessionId}`);
+
+    if (!sessionId) {
+      this.logError('删除会话失败: 缺少 opencode_session_id');
+      return;
+    }
+
+    try {
+      await deleteOpencodeSession(sessionId);
+      this.logInfo(`会话删除成功: ${sessionId}`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.logError(`删除会话失败: ${msg}`);
+    }
+  }
+
+  async sendResponse(msgType, content, requestId) {
+    if (!this.messageSender) {
+      this.logError('MessageSender 未设置，无法发送响应');
+      return;
+    }
+
+    try {
+      await this.messageSender.sendProtocolMessage(msgType, content, requestId);
+      this.logInfo(`响应已发送: ${msgType}`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      this.logError(`发送响应失败: ${msg}`);
+    }
+  }
+}
+
+module.exports = {
+  RongyunMessageHandler
+};