claw-subagent-service 0.0.0

package/service/daemon.js

@@ -0,0 +1,189 @@
+const { fork } = require('child_process');
+const path = require('path');
+const { createLogger } = require('./logger');
+const { Updater } = require('./updater');
+
+const log = createLogger('daemon');
+const WORKER_PATH = path.join(__dirname, 'worker.js');
+
+let worker = null;
+let stopping = false;
+let isRollingBack = false;
+let healthTimer = null;
+let currentBackupDir = null;
+const updater = new Updater();
+
+process.chdir(__dirname);
+
+function startWorker(isAfterUpdate = false, backupDirForRollback = null) {
+  if (stopping || isRollingBack) return;
+
+  log.info(`[DAEMON] 启动 Worker，PID: ${process.pid}，更新后重启: ${isAfterUpdate}`);
+
+  // Windows 服务中需要使用 detached: true 避免控制台关联问题
+  const forkOptions = {
+    stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+    detached: process.platform === 'win32',
+    windowsHide: process.platform === 'win32'
+  };
+
+  worker = fork(WORKER_PATH, [], forkOptions);
+
+  worker.stdout?.on('data', d => log.info(`[WORKER] ${d.toString().trim()}`));
+  worker.stderr?.on('data', d => log.error(`[WORKER] ${d.toString().trim()}`));
+
+  if (isAfterUpdate && backupDirForRollback) {
+    currentBackupDir = backupDirForRollback;
+    healthTimer = setTimeout(() => {
+      log.info('[DAEMON] 新版 Worker 健康观察通过（5分钟未崩溃），更新成功');
+      currentBackupDir = null;
+    }, 5 * 60 * 1000);
+  }
+
+  worker.on('exit', (code, signal) => {
+    if (healthTimer) {
+      clearTimeout(healthTimer);
+      healthTimer = null;
+    }
+
+    log.error(`[DAEMON] Worker 退出，code=${code}, signal=${signal}`);
+    worker = null;
+
+    if (isAfterUpdate && code !== 0 && currentBackupDir && !isRollingBack) {
+      isRollingBack = true;
+      log.error('[DAEMON] 新版 Worker 启动后异常退出，触发自动回滚！');
+
+      updater.rollback(currentBackupDir).then(() => {
+        isRollingBack = false;
+        currentBackupDir = null;
+        log.info('[DAEMON] 回滚完成，重新启动旧版 Worker...');
+        startWorker(false, null);
+      }).catch(err => {
+        log.error(`[DAEMON] 回滚失败: ${err.message}`);
+        isRollingBack = false;
+        currentBackupDir = null;
+        startWorker(false, null);
+      });
+      return;
+    }
+
+    if (!stopping && !isRollingBack) {
+      setTimeout(() => startWorker(false, null), 3000);
+    }
+  });
+
+  worker.on('error', (err) => {
+    log.error(`[DAEMON] Worker 启动错误: ${err.message}`);
+  });
+}
+
+function restartWorkerWithUpdate(backupDir) {
+  if (!worker) {
+    startWorker(true, backupDir);
+    return;
+  }
+
+  log.info('[DAEMON] 收到更新重启指令，优雅终止当前 Worker...');
+
+  worker.send({ type: 'prepare-shutdown', reason: 'update' });
+
+  // Windows 上等待时间稍长
+  const waitTime = process.platform === 'win32' ? 5000 : 3000;
+
+  setTimeout(() => {
+    if (worker) {
+      worker.removeAllListeners('exit');
+
+      // Windows 上使用 taskkill 确保进程树被终止
+      if (process.platform === 'win32' && worker.pid) {
+        try {
+          const { execSync } = require('child_process');
+          execSync(`taskkill /pid ${worker.pid} /T /F 2>nul`, { windowsHide: true });
+        } catch (e) {
+          // 忽略错误，使用 kill 作为后备
+          worker.kill('SIGTERM');
+        }
+      } else {
+        worker.kill('SIGTERM');
+      }
+
+      const waitKill = setInterval(() => {
+        if (!worker || worker.killed) {
+          clearInterval(waitKill);
+          worker = null;
+          setTimeout(() => startWorker(true, backupDir), 1000);
+        } else {
+          // 再次尝试强制终止
+          if (process.platform === 'win32' && worker.pid) {
+            try {
+              const { execSync } = require('child_process');
+              execSync(`taskkill /pid ${worker.pid} /T /F 2>nul`, { windowsHide: true });
+            } catch (e) {
+              worker.kill('SIGKILL');
+            }
+          } else {
+            worker.kill('SIGKILL');
+          }
+        }
+      }, 500);
+    } else {
+      startWorker(true, backupDir);
+    }
+  }, waitTime);
+}
+
+function gracefulShutdown() {
+  stopping = true;
+  updater.stopSchedule();
+  log.info('[DAEMON] 收到停止信号，正在终止 Worker...');
+
+  if (worker) {
+    // 先尝试优雅地通知 Worker 退出
+    try {
+      worker.send({ type: 'prepare-shutdown', reason: 'daemon-stopping' });
+    } catch (e) {
+      // 忽略发送失败
+    }
+
+    // Windows 上等待时间稍长，给子进程时间清理
+    const waitTime = process.platform === 'win32' ? 8000 : 5000;
+
+    setTimeout(() => {
+      if (worker && !worker.killed) {
+        log.error('[DAEMON] Worker 未响应，强制杀死');
+        // Windows 上使用 taskkill 确保进程树被终止
+        if (process.platform === 'win32' && worker.pid) {
+          try {
+            const { execSync } = require('child_process');
+            execSync(`taskkill /pid ${worker.pid} /T /F 2>nul`, { windowsHide: true });
+          } catch (e) {
+            // 忽略错误，使用 kill 作为后备
+            worker.kill('SIGKILL');
+          }
+        } else {
+          worker.kill('SIGKILL');
+        }
+      }
+      process.exit(0);
+    }, waitTime);
+  } else {
+    process.exit(0);
+  }
+}
+
+process.on('SIGINT', gracefulShutdown);
+process.on('SIGTERM', gracefulShutdown);
+process.on('message', (msg) => {
+  if (msg === 'shutdown') gracefulShutdown();
+});
+
+startWorker(false, null);
+updater.startSchedule(restartWorkerWithUpdate);
+
+process.on('uncaughtException', (err) => {
+  log.error(`[DAEMON] 未捕获异常: ${err.message}`);
+});
+
+process.on('unhandledRejection', (reason) => {
+  log.error(`[DAEMON] 未捕获 Promise: ${reason}`);
+});

package/service/logger.js

@@ -0,0 +1,31 @@
+const fs = require('fs');
+const path = require('path');
+
+const LOG_DIR = path.join(__dirname, '..', 'logs');
+if (!fs.existsSync(LOG_DIR)) {
+  fs.mkdirSync(LOG_DIR, { recursive: true });
+}
+
+function createLogger(name) {
+  const getFile = () => {
+    const date = new Date().toISOString().slice(0, 10);
+    return path.join(LOG_DIR, `${name}-${date}.log`);
+  };
+
+  const write = (level, msg) => {
+    const line = `[${new Date().toISOString()}] [${level}] ${msg}\n`;
+    try {
+      fs.appendFileSync(getFile(), line);
+    } catch (e) {
+      // ignore write errors
+    }
+  };
+
+  return {
+    info: (msg) => write('INFO', msg),
+    error: (msg) => write('ERROR', msg),
+    warn: (msg) => write('WARN', msg)
+  };
+}
+
+module.exports = { createLogger };

package/service/modules/auth.js

@@ -0,0 +1,17 @@
+const crypto = require('crypto');
+
+function generateSecret(mac, secretKey) {
+  return crypto.createHash('md5')
+    .update(mac + secretKey)
+    .digest('hex');
+}
+
+function verifySecret(mac, secretKey, expectedSecret) {
+  const calculated = generateSecret(mac, secretKey);
+  return calculated === expectedSecret;
+}
+
+module.exports = {
+  generateSecret,
+  verifySecret
+};

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

@@ -0,0 +1,118 @@
+/**
+ * 消息业务处理器 - 处理 rongcloud 转发过来的消息
+ * 
+ * 被调用位置：rongcloud/message-handler.js
+ * - handleNormal() 第68行：处理普通消息（AI聊天）
+ * - handleCommand() 第70行：处理命令消息（以/开头）
+ * 
+ * 注入方式：通过 config.onCommand 回调
+ * 位置：rongcloud/message-handler.js 第93行
+ */
+const { CommandHandler, OpenClawCommandEnum } = require('./command-handler');
+const { RongyunMessageSender } = require('./rongyun-message-sender');
+
+class BusinessMessageHandler {
+  constructor(config, rongcloudClient, log) {
+    this.config = config;
+    this.rongcloudClient = rongcloudClient;
+    this.log = log;
+    this.commandHandler = new CommandHandler(config, log);
+    this.messageSender = new RongyunMessageSender(rongcloudClient, config, log);
+  }
+
+  /**
+   * 处理命令消息
+   * 被调用位置：rongcloud/message-handler.js 第93行
+   * 
+   * @param {Object} payload - 命令对象
+   * @param {string} payload.command - 命令名称
+   * @param {string[]} payload.args - 命令参数
+   * @param {string} payload.rawMessage - 原始消息
+   * @param {string} payload.senderId - 发送者ID
+   * @returns {string} 回复内容
+   */
+  async handleCommand(payload) {
+    this.log?.info(`[BusinessMessageHandler] 收到命令: ${payload.command}, args=${JSON.stringify(payload.args)}`);
+    
+    try {
+      // 将命令名称或枚举值映射到枚举值
+      // 后端可能发送字符串（如 "start"）或整数（如 1）
+      const commandMap = {
+        'start': OpenClawCommandEnum.START,
+        'stop': OpenClawCommandEnum.STOP,
+        'status': OpenClawCommandEnum.STATUS,
+        'restart': OpenClawCommandEnum.RESTART,
+        1: OpenClawCommandEnum.START,
+        2: OpenClawCommandEnum.STOP,
+        3: OpenClawCommandEnum.RESTART,
+        4: OpenClawCommandEnum.STATUS
+      };
+      
+      // 支持字符串和整数命令
+      const commandKey = typeof payload.command === 'string' 
+        ? payload.command.toLowerCase() 
+        : payload.command;
+      
+      const command = commandMap[commandKey];
+      if (!command) {
+        return `未知命令: ${payload.command}\n可用命令: start, stop, status, restart`;
+      }
+      
+      // 执行命令
+      const result = await this.commandHandler.execute(command);
+      
+      // 发送命令结果到服务端
+      try {
+        await this.messageSender.sendCommandResult(
+          command,
+          payload.senderId,
+          result.status,
+          result.message
+        );
+      } catch (err) {
+        this.log?.error(`[BusinessMessageHandler] 发送命令结果失败: ${err.message}`);
+      }
+      
+      return result.message;
+      
+    } catch (err) {
+      this.log?.error(`[BusinessMessageHandler] 命令处理异常: ${err.message}`);
+      return `执行失败: ${err.message}`;
+    }
+  }
+
+  /**
+   * 处理普通消息（AI聊天）
+   * 被调用位置：rongcloud/message-handler.js 第68行
+   * 
+   * @param {Object} msg - 消息对象
+   * @param {string} msg.content - 消息内容
+   * @param {string} msg.senderUserId - 发送者ID
+   * @returns {string} 回复内容
+   */
+  async handleNormalMessage(msg) {
+    this.log?.info(`[BusinessMessageHandler] 收到普通消息 from=${msg.senderUserId}: ${msg.content?.substring(0, 50)}`);
+    
+    try {
+      // TODO: 调用 AI 服务进行回复
+      // 这里可以调用 opencode 服务或其他 AI 服务
+      
+      const reply = `收到您的消息: ${msg.content}`;
+      
+      // 发送聊天消息回复到服务端
+      try {
+        await this.messageSender.sendChatMessage(reply);
+      } catch (err) {
+        this.log?.error(`[BusinessMessageHandler] 发送聊天回复失败: ${err.message}`);
+      }
+      
+      return reply;
+      
+    } catch (err) {
+      this.log?.error(`[BusinessMessageHandler] 处理普通消息异常: ${err.message}`);
+      return `抱歉，处理消息时出错: ${err.message}`;
+    }
+  }
+}
+
+module.exports = { BusinessMessageHandler };

package/service/modules/command-handler.js

@@ -0,0 +1,152 @@
+/**
+ * 命令处理器 - 处理 start/stop/status/restart 命令
+ * 
+ * 使用 script-executor.js 执行实际的脚本文件
+ */
+const { ScriptExecutor, OpenClawCommandEnum, OpenClawServiceStatus } = require('./script-executor');
+const path = require('path');
+
+class CommandHandler {
+  constructor(config, log) {
+    this.config = config;
+    this.log = log;
+    
+    // 初始化脚本执行器
+    const scriptDir = this.getScriptDir();
+    this.executor = new ScriptExecutor(
+      scriptDir,
+      config.successKeyword || 'Success',
+      config.scriptTimeout || 180
+    );
+  }
+
+  /**
+   * 获取脚本目录
+   */
+  getScriptDir() {
+    const system = process.platform;
+    const subDir = system === 'win32' ? path.join('command', 'win') : path.join('command', 'linux');
+    return path.join(__dirname, '..', '..', subDir);
+  }
+
+  /**
+   * 获取脚本文件名
+   */
+  getScriptName(command) {
+    const system = process.platform;
+    const ext = system === 'win32' ? '.bat' : '.sh';
+    const names = {
+      [OpenClawCommandEnum.START]: 'start',
+      [OpenClawCommandEnum.STOP]: 'stop',
+      [OpenClawCommandEnum.RESTART]: 'restart',
+      [OpenClawCommandEnum.STATUS]: 'status',
+      [OpenClawCommandEnum.CONFIG_FIX]: null  // 配置修复不需要脚本，直接执行命令
+    };
+    const name = names[command];
+    return name ? name + ext : null;
+  }
+
+  /**
+   * 执行命令
+   * @param {number} command - 命令枚举值 (1=start, 2=stop, 3=restart, 4=status, 5=config_fix)
+   * @returns {Object} { status, message }
+   */
+  async execute(command) {
+    const scriptName = this.getScriptName(command);
+    const commandName = this.getCommandName(command);
+    
+    // 配置修复命令特殊处理：直接执行 openclaw doctor --fix
+    if (command === OpenClawCommandEnum.CONFIG_FIX) {
+      return await this.executeConfigFix();
+    }
+    
+    this.log?.info(`[CommandHandler] 执行 ${commandName} 命令，脚本: ${scriptName}`);
+    
+    try {
+      const result = await this.executor.executeWithStatus(command, scriptName);
+      this.log?.info(`[CommandHandler] ${commandName} 结果: ${result.status} - ${result.message}`);
+      return result;
+    } catch (err) {
+      this.log?.error(`[CommandHandler] ${commandName} 异常: ${err.message}`);
+      return {
+        status: OpenClawServiceStatus.ERROR,
+        message: `执行异常: ${err.message}`
+      };
+    }
+  }
+
+  /**
+   * 执行配置修复命令
+   * 直接运行 openclaw doctor --fix
+   */
+  async executeConfigFix() {
+    this.log?.info('[CommandHandler] 执行配置修复命令: openclaw doctor --fix');
+    
+    try {
+      const result = await this.executor.executeCommandDirect('openclaw doctor --fix', 120); // 2分钟超时
+      this.log?.info(`[CommandHandler] 配置修复结果: ${result.status} - ${result.message}`);
+      return result;
+    } catch (err) {
+      this.log?.error(`[CommandHandler] 配置修复异常: ${err.message}`);
+      return {
+        status: OpenClawServiceStatus.ERROR,
+        message: `配置修复异常: ${err.message}`
+      };
+    }
+  }
+
+  /**
+   * 获取命令名称
+   */
+  getCommandName(command) {
+    const names = {
+      [OpenClawCommandEnum.START]: '启动',
+      [OpenClawCommandEnum.STOP]: '停止',
+      [OpenClawCommandEnum.RESTART]: '重启',
+      [OpenClawCommandEnum.STATUS]: '状态检查',
+      [OpenClawCommandEnum.CONFIG_FIX]: '配置修复'
+    };
+    return names[command] || '未知命令';
+  }
+
+  /**
+   * 启动服务
+   */
+  async start() {
+    return await this.execute(OpenClawCommandEnum.START);
+  }
+
+  /**
+   * 停止服务
+   */
+  async stop() {
+    return await this.execute(OpenClawCommandEnum.STOP);
+  }
+
+  /**
+   * 重启服务
+   */
+  async restart() {
+    return await this.execute(OpenClawCommandEnum.RESTART);
+  }
+
+  /**
+   * 检查状态
+   */
+  async status() {
+    return await this.execute(OpenClawCommandEnum.STATUS);
+  }
+
+  /**
+   * 配置修复
+   */
+  async configFix() {
+    return await this.execute(OpenClawCommandEnum.CONFIG_FIX);
+  }
+}
+
+module.exports = {
+  CommandHandler,
+  OpenClawCommandEnum,
+  OpenClawServiceStatus
+};

package/service/modules/config.js

@@ -0,0 +1,44 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function loadConfig() {
+  // Read from ~/.claw-bridge/config.json
+  const clawBridgePath = path.join(os.homedir(), '.claw-bridge', 'config.json');
+  let clawBridgeConfig = {};
+  if (fs.existsSync(clawBridgePath)) {
+    try {
+      clawBridgeConfig = JSON.parse(fs.readFileSync(clawBridgePath, 'utf-8'));
+    } catch (e) {
+      console.error('读取 claw-bridge 配置失败:', e);
+    }
+  }
+
+  // Read from local rongcloud-config.json
+  const localConfigPath = path.join(__dirname, '..', '..', 'rongcloud-config.json');
+  let localConfig = {};
+  if (fs.existsSync(localConfigPath)) {
+    try {
+      localConfig = JSON.parse(fs.readFileSync(localConfigPath, 'utf-8'));
+    } catch (e) {
+      console.error('读取本地配置失败:', e);
+    }
+  }
+
+  return {
+    appKey: process.env.DM_APP_KEY || localConfig.appKey || 'bmdehs6pbyyks',
+    token: localConfig.token || clawBridgeConfig.token,
+    accountId: localConfig.accountId || clawBridgeConfig.nodeId,
+    nodeName: clawBridgeConfig.nodeName || 'cli-client',
+    secretKey: localConfig.secretKey || 'secret_key',
+    nickname: localConfig.nickname || 'CLI客户端',
+    reconnectInterval: localConfig.reconnectInterval || 60,
+    heartbeatInterval: localConfig.heartbeatInterval || 20,
+    openclawPort: localConfig.openclawPort || 18789,
+    scriptTimeout: localConfig.scriptTimeout || 180,
+    successKeyword: localConfig.successKeyword || 'Success',
+    chatTimeout: localConfig.chatTimeout || 600
+  };
+}
+
+module.exports = { loadConfig };