claw-subagent-service 0.0.28 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claw-subagent-service",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "虾说静态服务",
   "main": "cli.js",
   "bin": {
@@ -14,7 +14,8 @@
     "dev": "nodemon cli.js --run",
     "publish:patch": "npm version patch && npm publish",
     "publish:minor": "npm version minor && npm publish",
-    "publish:major": "npm version major && npm publish"
+    "publish:major": "npm version major && npm publish",
+    "sync": "node scripts/sync-local.js"
   },
   "files": [
     "cli.js",

package/scripts/sync-local.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+/**
+ * sync-local.js - 本地开发快速同步脚本
+ *
+ * 运行后将当前代码直接替换到全局安装的 claw-subagent-service 目录，
+ * 无需发布到 npm 后再重新下载安装。
+ *
+ * 用法:
+ *   npm run sync        (推荐)
+ *   node scripts/sync-local.js
+ *
+ * 注意: Windows 下若服务正在运行，会自动卸载服务、同步后再重新安装。
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const isWindows = process.platform === 'win32';
+const SERVICE_NAME = 'claw-subagent-service';
+const PACKAGE_NAME = 'claw-subagent-service';
+const ROOT = path.join(__dirname, '..');
+
+// 需要同步的文件/目录（与 package.json files 保持一致）
+const FILES_TO_SYNC = [
+  'cli.js',
+  'service',
+  'scripts',
+  'command',
+  'version.json',
+  'README.md',
+  'package.json',
+];
+
+function getGlobalPackageDir() {
+  try {
+    const globalRoot = execSync('npm root -g', {
+      encoding: 'utf-8',
+      windowsHide: true,
+    }).trim();
+    return path.join(globalRoot, PACKAGE_NAME);
+  } catch (e) {
+    console.error('❌ 无法获取全局 npm 路径:', e.message);
+    process.exit(1);
+  }
+}
+
+function stopAndUninstallService() {
+  if (!isWindows) {
+    try {
+      execSync('systemctl stop claw-subagent-service 2>/dev/null', {
+        stdio: 'ignore',
+        timeout: 15000,
+      });
+      console.log('✅ 服务已停止');
+    } catch {}
+    return;
+  }
+
+  console.log('🛑 正在停止并卸载 Windows 服务（释放文件锁）...');
+
+  // 1. 停止服务
+  try {
+    execSync('net stop "claw-subagent-service" 2>nul', {
+      stdio: 'ignore',
+      timeout: 35000,
+    });
+    console.log('  ✅ 服务已停止');
+  } catch {}
+
+  // 2. 杀掉 wrapper 进程（node-windows 生成的 .exe）
+  try {
+    execSync('taskkill /f /im "claw-subagent-service.exe" 2>nul', {
+      stdio: 'ignore',
+      timeout: 10000,
+    });
+    console.log('  ✅ wrapper 进程已终止');
+  } catch {}
+
+  // 3. 杀掉相关 node 进程
+  try {
+    execSync(
+      'powershell -NoProfile -Command "Get-Process node -ErrorAction SilentlyContinue | Where-Object {$_.Path -like \'*claw-subagent*\'} | Stop-Process -Force -ErrorAction SilentlyContinue" 2>nul',
+      { stdio: 'ignore', timeout: 15000 }
+    );
+  } catch {}
+
+  // 4. 通过 wmic 按命令行匹配杀掉相关 node 进程
+  try {
+    execSync('wmic process where "name=\'node.exe\' and commandline like \'%claw-subagent%\'" delete 2>nul', {
+      stdio: 'ignore',
+      timeout: 10000,
+    });
+    console.log('  ✅ 相关 node 进程已清理');
+  } catch {}
+
+  // 5. 从注册表删除服务（彻底释放 node-windows wrapper 的文件锁）
+  try {
+    execSync('sc.exe delete "claw-subagent-service" 2>nul', {
+      stdio: 'ignore',
+      timeout: 10000,
+    });
+    console.log('  ✅ 服务已从注册表删除');
+  } catch {}
+
+  // 6. 等待 Windows 回收文件句柄（关键！node-windows wrapper 需要足够时间释放）
+  console.log('  ⏳ 等待系统释放文件锁（10秒）...');
+  execSync('ping -n 11 127.0.0.1 >nul', { stdio: 'ignore', windowsHide: true });
+}
+
+function installAndStartService() {
+  console.log('🚀 正在安装并启动服务...');
+  try {
+    if (isWindows) {
+      execSync('claw-subagent-service --install', {
+        stdio: 'inherit',
+        timeout: 60000,
+        windowsHide: true,
+      });
+    } else {
+      execSync('systemctl start claw-subagent-service', {
+        stdio: 'inherit',
+        timeout: 15000,
+      });
+    }
+    console.log('✅ 服务已安装/启动');
+  } catch (e) {
+    console.error('⚠️  服务安装/启动失败:', e.message);
+    console.log('   请手动运行: claw-subagent-service --install');
+  }
+}
+
+function isServiceInstalled() {
+  try {
+    if (isWindows) {
+      execSync('sc query "claw-subagent-service" | findstr SERVICE_NAME >nul', {
+        stdio: 'ignore',
+        windowsHide: true,
+      });
+      return true;
+    } else {
+      execSync('systemctl is-active --quiet claw-subagent-service || systemctl is-enabled --quiet claw-subagent-service', {
+        stdio: 'ignore',
+      });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
+
+function copyDirSync(src, dest) {
+  if (isWindows) {
+    // 确保目标目录存在
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    // 使用 robocopy，遇到锁定的文件时跳过（/R:0 /W:0 表示不重试）
+    const cmd = `robocopy "${src}" "${dest}" /E /R:0 /W:0 /NJH /NJS /NDL /NC /NS /NFL`;
+    try {
+      execSync(cmd, { encoding: 'utf-8', windowsHide: true });
+    } catch (e) {
+      // robocopy 返回码含义：
+      // 0 = 成功，1 = 有文件被跳过，2 = 有额外文件，4 = 有不匹配，8 = 有错误，16 = 严重错误
+      const status = e.status || 0;
+      if (status === 1) {
+        console.log('  ℹ️  部分文件被跳过（可能正在使用）');
+      } else if (status >= 8) {
+        throw new Error(`robocopy 失败 (code ${status})`);
+      }
+    }
+  } else {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+      const s = path.join(src, entry.name);
+      const d = path.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        copyDirSync(s, d);
+      } else {
+        fs.copyFileSync(s, d);
+      }
+    }
+  }
+}
+
+function syncFiles(targetDir) {
+  console.log(`📦 同步到: ${targetDir}\n`);
+
+  for (const file of FILES_TO_SYNC) {
+    const src = path.join(ROOT, file);
+    const dest = path.join(targetDir, file);
+
+    if (!fs.existsSync(src)) {
+      console.log(`  ⚠️  跳过: ${file} (不存在)`);
+      continue;
+    }
+
+    try {
+      const stat = fs.statSync(src);
+      if (stat.isDirectory()) {
+        copyDirSync(src, dest);
+      } else {
+        fs.copyFileSync(src, dest);
+      }
+      console.log(`  ✅ ${file}`);
+    } catch (e) {
+      console.error(`  ❌ ${file}: ${e.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+function installDepsIfNeeded(targetDir) {
+  const nodeModulesPath = path.join(targetDir, 'node_modules');
+  const hasNodeModules = fs.existsSync(nodeModulesPath) && fs.readdirSync(nodeModulesPath).length > 0;
+
+  if (hasNodeModules) {
+    console.log('\n📦 依赖已存在，跳过安装');
+    return;
+  }
+
+  console.log('\n📦 安装依赖...');
+  try {
+    execSync('npm install --ignore-scripts --prefer-offline --no-audit --no-fund --progress=false', {
+      cwd: targetDir,
+      stdio: 'inherit',
+      encoding: 'utf-8',
+      windowsHide: true,
+      timeout: 300000,
+    });
+    console.log('✅ 依赖安装完成');
+  } catch (e) {
+    console.error('⚠️  依赖安装失败，请手动运行:');
+    console.error(`   cd "${targetDir}" && npm install`);
+  }
+}
+
+function main() {
+  console.log('🦞 claw-subagent-service - 本地同步\n');
+
+  const targetDir = getGlobalPackageDir();
+  const wasInstalled = isServiceInstalled();
+
+  if (wasInstalled) {
+    console.log('ℹ️  检测到服务已安装，先卸载以释放文件锁\n');
+    stopAndUninstallService();
+  }
+
+  syncFiles(targetDir);
+  installDepsIfNeeded(targetDir);
+
+  console.log('\n✅ 同步完成!');
+  console.log(`   目标目录: ${targetDir}`);
+
+  if (wasInstalled) {
+    console.log('\n🔄 正在重新安装并启动服务...');
+    installAndStartService();
+  } else {
+    console.log('\n💡 提示:');
+    console.log('   服务未安装，如需安装请运行:');
+    console.log('   claw-subagent-service --install');
+  }
+}
+
+main();

package/service/daemon.js

@@ -10,9 +10,16 @@ const log = createLogger('daemon');
 const WORKER_PATH = path.join(__dirname, 'worker.js');
 const PORT = process.env.SILENT_SERVICE_PORT ? parseInt(process.env.SILENT_SERVICE_PORT, 10) : 28765;
 // 使用全局 PID 文件，防止不同安装路径的多个实例同时运行
-const PID_FILE = path.join(os.homedir(), '.claw-subagent-service.pid');
+const PID_FILE = (() => {
+  if (process.platform === 'win32') {
+    const programData = process.env.PROGRAMDATA || process.env.ALLUSERSPROFILE || 'C:\\ProgramData';
+    return path.join(programData, 'claw-subagent-service', 'daemon.pid');
+  }
+  return path.join(os.tmpdir(), '.claw-subagent-service.pid');
+})();
 
 let worker = null;
+let currentWorkerPid = null;
 let stopping = false;
 let isRollingBack = false;
 let healthTimer = null;
@@ -36,7 +43,12 @@ function checkSingleton() {
           process.kill(pid, 0);
           log.error(`[DAEMON] 另一个 Daemon 实例已在运行 (PID: ${pid})，当前实例退出`);
           return false;
-        } catch {
+        } catch (err) {
+          if (err.code === 'EPERM') {
+            // 进程存在但无权限发送信号，视为仍在运行
+            log.error(`[DAEMON] 另一个 Daemon 实例已在运行 (PID: ${pid}, 权限不足)，当前实例退出`);
+            return false;
+          }
           // 进程不存在，继续启动
         }
       }
@@ -46,6 +58,10 @@ function checkSingleton() {
   }
 
   try {
+    const pidDir = path.dirname(PID_FILE);
+    if (!fs.existsSync(pidDir)) {
+      fs.mkdirSync(pidDir, { recursive: true });
+    }
     fs.writeFileSync(PID_FILE, String(process.pid));
   } catch (err) {
     log.warn(`[DAEMON] 写入 PID 文件失败: ${err.message}`);
@@ -92,7 +108,7 @@ function freePortIfNeeded(port) {
         const localAddr = parts[1] || '';
         if (localAddr.endsWith(`:${port}`) || localAddr.endsWith(`]:${port}`)) {
           const pid = parseInt(parts[parts.length - 1], 10);
-          if (pid && pid > 0) {
+          if (pid && pid > 0 && pid !== currentWorkerPid && pid !== process.pid) {
             log.warn(`[DAEMON] 端口 ${port} 被进程 ${pid} 占用，正在释放...`);
             try {
               execSync(`taskkill /F /PID ${pid}`, { timeout: 5000, windowsHide: true });
@@ -126,7 +142,7 @@ function getRestartDelay() {
   crashCount++;
   // 指数退避: 1s, 2s, 4s, 8s, 16s, 32s, 60s(封顶)
   const delay = Math.min(1000 * Math.pow(2, crashCount - 1), 60000);
-  log.info(`[DAEMON] Worker 连续崩溃 ${crashCount} 次，等待 ${delay/1000}s 后重启`);
+  log.info(`[DAEMON] Worker 连续崩溃 ${crashCount} 次，等待 ${delay / 1000}s 后重启`);
   return delay;
 }
 
@@ -146,9 +162,13 @@ function startWorker(isAfterUpdate = false, backupDirForRollback = null) {
   };
 
   worker = fork(WORKER_PATH, [], forkOptions);
+  currentWorkerPid = worker.pid || null;
 
-  worker.stdout?.on('data', d => log.info(`[WORKER] ${d.toString().trim()}`));
-  worker.stderr?.on('data', d => log.error(`[WORKER] ${d.toString().trim()}`));
+  // 只有 pipe 模式才需要手动转发到 logger
+  if (forkOptions.stdio !== 'inherit') {
+    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;
@@ -166,6 +186,7 @@ function startWorker(isAfterUpdate = false, backupDirForRollback = null) {
 
     log.error(`[DAEMON] Worker 退出，code=${code}, signal=${signal}`);
     worker = null;
+    currentWorkerPid = null;
 
     if (isAfterUpdate && code !== 0 && currentBackupDir && !isRollingBack) {
       isRollingBack = true;
@@ -186,8 +207,8 @@ function startWorker(isAfterUpdate = false, backupDirForRollback = null) {
     }
 
     if (!stopping && !isRollingBack) {
-      // 释放端口后使用指数退避重启
-      freePortIfNeeded(PORT);
+      // 使用指数退避延迟后重启；端口释放交由 startWorker 中的 freePortIfNeeded 处理，
+      // 避免此处误杀刚刚由其他实例启动的 worker
       const delay = getRestartDelay();
       setTimeout(() => startWorker(false, null), delay);
     }

package/service/logger.js

@@ -13,12 +13,16 @@ function createLogger(name) {
   };
 
   const write = (level, msg) => {
-    const line = `[${new Date().toISOString()}] [${level}] ${msg}\n`;
+    const line = `[${new Date().toISOString()}] [${level}] ${msg}`;
     try {
-      fs.appendFileSync(getFile(), line);
+      fs.appendFileSync(getFile(), line + '\n');
     } catch (e) {
       // ignore write errors
     }
+    if (process.stdout && process.stdout.isTTY) {
+      const fn = level === 'ERROR' ? 'error' : level === 'WARN' ? 'warn' : 'log';
+      console[fn](line);
+    }
   };
 
   return {

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

@@ -1,9 +1,9 @@
 /**
  * 普通消息处理器 - 接收 rongcloud 转发的普通消息并调用 AI 服务
- * 
- * 被调用位置：rongcloud/message-handler.js 第68行
+ *
+ * 被调用位置：rongcloud/message-handler.js
  * 调用方式：await this.handleNormalMessage(msg)
- * 
+ *
  * @param {Object} msg - 消息对象
  * @param {string} msg.content - 消息内容
  * @param {string} msg.senderUserId - 发送者ID
@@ -11,7 +11,9 @@
  * @param {number} msg.conversationType - 会话类型 (1=私聊, 3=群聊)
  * @returns {string} 回复内容
  */
-const { forwardChatMessage } = require('./opencode-service');
+const { OpenClawClient } = require('../rongcloud/openclaw-client');
+
+const openclawClient = new OpenClawClient(console);
 
 async function handleNormalMessage(msg) {
   console.log(`[NormalMessageHandler] 收到普通消息:`, {
@@ -21,34 +23,14 @@ async function handleNormalMessage(msg) {
   });
 
   try {
-    // 使用 senderUserId 作为 session ID，确保每个用户有独立的会话
-    const sessionId = msg.senderUserId || 'default';
     const content = msg.content;
-    
     if (!content || !content.trim()) {
       return '消息内容为空';
     }
 
-    // 调用 opencode 服务进行 AI 聊天
-    let fullResponse = '';
-    
-    await forwardChatMessage(
-      sessionId,
-      content,
-      async (delta) => {
-        // 收集响应片段
-        fullResponse += delta;
-      },
-      (level, message) => {
-        // 日志回调
-        console.log(`[CHAT-${level}] ${message}`);
-      },
-      600000 // 10分钟超时
-    );
-
-    console.log(`[NormalMessageHandler] AI 回复: ${fullResponse.substring(0, 50)}...`);
-    return fullResponse;
-
+    const reply = await openclawClient.chat(content, msg.senderUserId);
+    console.log(`[NormalMessageHandler] AI 回复: ${reply.substring(0, 50)}...`);
+    return reply;
   } catch (err) {
     console.error(`[NormalMessageHandler] 处理异常:`, err.message);
     return `抱歉，处理消息时出错: ${err.message}`;

package/service/rongcloud/message-handler.js

@@ -41,7 +41,13 @@ class MessageHandler {
       return false;
     }
 
-    const mentions = this.extractMentions(msg.content);
+    // claw 控制消息不需要 @mention 过滤
+    if (msg.messageType === 'claw') {
+      return true;
+    }
+
+    const textContent = typeof msg.content === 'string' ? msg.content : (msg.content?.content || '');
+    const mentions = this.extractMentions(textContent);
 
     if (mentions.length > 0) {
       if (!mentions.includes(this.nodeId)) {
@@ -49,8 +55,11 @@ class MessageHandler {
         return false;
       }
       this.log?.info(`[MessageHandler] 消息提及本节点(${this.nodeId})，处理`);
+    } else if (msg.conversationType === 3) {
+      this.log?.info(`[MessageHandler] 群聊消息未 @ 本节点(${this.nodeId})，忽略`);
+      return false;
     } else {
-      this.log?.info(`[MessageHandler] 消息未指定节点，本节点(${this.nodeId})处理`);
+      this.log?.info(`[MessageHandler] 单聊消息未指定节点，本节点(${this.nodeId})处理`);
     }
 
     return true;
@@ -63,12 +72,17 @@ class MessageHandler {
 
     try {
       const type = this.getMessageType(msg);
-      this.log?.info(`[MessageHandler] 收到消息 from=${msg.senderUserId}, type=${type}, content=${msg.content.substring(0, 50)}`);
+      const logContent = typeof msg.content === 'string' ? msg.content : (msg.content?.content || '');
+      this.log?.info(`[MessageHandler] 收到消息 from=${msg.senderUserId}, type=${type}, content=${logContent.substring(0, 50)}`);
       if (msg.messageType === 'claw') {
         this.log?.info(`收到龙虾消息，交由 OpenClawClient 处理`);
         await this.handleClaw(msg);
       } else {
-        await this.handleNormalMessage(msg);
+        const reply = await this.handleNormalMessage(msg);
+        if (reply) {
+          const targetId = this.getReplyTarget(msg);
+          await this.sendFn(targetId, reply, msg.conversationType);
+        }
       }
     } catch (err) {
       this.log?.error(`[MessageHandler] 处理消息异常: ${err.message}`);
@@ -81,7 +95,8 @@ class MessageHandler {
     if (msg.messageType === 'claw') {
       return MessageType.CLAW;
     }
-    if (msg.content && msg.content.startsWith('/')) {
+    const text = typeof msg.content === 'string' ? msg.content : (msg.content?.content || '');
+    if (text.startsWith('/')) {
       return MessageType.COMMAND;
     }
     return MessageType.NORMAL;

package/service/rongcloud/openclaw-client.js

@@ -249,44 +249,8 @@ class OpenClawClient {
 
     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);
-    }
+    // 直接走 CLI 调用（OpenClaw Gateway 未暴露兼容的 HTTP REST API）
+    return this.chatViaCLI(message, fromUser);
   }
 
   async chatViaCLI(message, fromUser) {
@@ -307,12 +271,14 @@ class OpenClawClient {
       this.log?.info('[OpenClawClient] 已读取到 gateway token');
     }
 
-    const args = ['agent', '-m', escapedMessage, '--session-id', sessionId];
+    const quoteArg = (s) => `"${s}"`;
+    const cmdParts = ['openclaw', 'agent', '-m', quoteArg(escapedMessage), '--session-id', quoteArg(sessionId)];
     if (gatewayToken) {
-      args.push('--token', gatewayToken);
+      cmdParts.push('--token', quoteArg(gatewayToken));
     }
+    const command = cmdParts.join(' ');
 
-    this.log?.info(`[OpenClawClient] 执行: openclaw ${args.map(a => a.includes(' ') ? `"${a}"` : a).join(' ')}`);
+    this.log?.info(`[OpenClawClient] 执行: ${command}`);
 
     return new Promise((resolve) => {
       let stdout = '';
@@ -321,7 +287,7 @@ class OpenClawClient {
 
       // 关键：不设置 OPENCLAW_GATEWAY_URL，避免触发 "gateway url override requires explicit credentials"
       // 让 openclaw agent 通过默认方式自动发现本地 gateway
-      const child = spawn('openclaw', args, {
+      const child = spawn(command, {
         shell: true,
         windowsHide: true,
         env: getOpenClawEnv(),
@@ -339,12 +305,12 @@ class OpenClawClient {
         this.log?.info(`[OpenClawClient] CLI stderr: ${text.trim().substring(0, 300)}`);
       });
 
-      // 超时兜底（30 秒）
+      // 超时兜底（30 分钟）
       const timeout = setTimeout(() => {
         killed = true;
         child.kill('SIGTERM');
-        this.log?.error('[OpenClawClient] CLI 执行超时（30秒），强制终止');
-      }, 30000);
+        this.log?.error('[OpenClawClient] CLI 执行超时（30分钟），强制终止');
+      }, 1800000);
 
       child.on('error', (err) => {
         clearTimeout(timeout);
@@ -360,7 +326,7 @@ class OpenClawClient {
         clearTimeout(timeout);
 
         if (killed) {
-          resolve('OpenClaw 响应超时（30秒），请检查 openclaw 服务状态');
+          resolve('OpenClaw 响应超时（30分钟），请检查 openclaw 服务状态');
           return;
         }
 

package/service/rongcloud/rongcloud-client.js

@@ -20,6 +20,8 @@ class RongCloudClient {
     this.isConnected = false;
     this.handler = null;
     this.processingQueue = Promise.resolve();
+    this.processedMessageUIds = new Set();
+    this.messageDedupMaxSize = 1000;
   }
 
   async connect(handler) {
@@ -98,10 +100,31 @@ class RongCloudClient {
   }
 
   handleReceivedMessage(message) {
+    // 1. 过滤离线消息
     if (message.isOffLineMessage) {
       return;
     }
 
+    // 2. 过滤自己发送的消息（融云 SDK 可能将发送消息回传）
+    // messageDirection: 1=发送, 2=接收
+    if (message.messageDirection === 1) {
+      return;
+    }
+    if (message.senderUserId === this.config.accountId) {
+      return;
+    }
+
+    // 3. 消息去重：防止同一条消息被多次触发（融云重推或多端同步）
+    const dedupKey = message.messageUId || `${message.senderUserId}-${message.sentTime}-${message.messageType}`;
+    if (this.processedMessageUIds.has(dedupKey)) {
+      return;
+    }
+    this.processedMessageUIds.add(dedupKey);
+    if (this.processedMessageUIds.size > this.messageDedupMaxSize) {
+      const first = this.processedMessageUIds.values().next().value;
+      this.processedMessageUIds.delete(first);
+    }
+
     try {
       const msgType = message.messageType;
       let rawContent = message.content;

package/service/worker.js

@@ -15,6 +15,23 @@ const { startOpencodeService, stopOpencodeService } = require('./modules/opencod
 const log = createLogger('worker');
 const PORT = process.env.SILENT_SERVICE_PORT ? parseInt(process.env.SILENT_SERVICE_PORT, 10) : 28765;
 
+
+// 捕获所有异常，强制打印到控制台（绕过 logger）
+process.on('uncaughtException', (err) => {
+  console.error('[WORKER_FATAL] 未捕获异常:', err);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('[WORKER_FATAL] 未捕获Promise:', reason);
+});
+
+// 如果 logger 初始化后，也同步写到 logger
+const originalStderr = process.stderr.write.bind(process.stderr);
+process.stderr.write = (chunk, encoding, callback) => {
+  originalStderr(chunk, encoding, callback);
+};
+
 /**
  * 查找占用指定端口的进程 PID
  * Windows 下检查本地地址（第二列）是否匹配目标端口，不限于 LISTENING 状态