claw-subagent-service 0.0.41 → 0.0.43

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "claw-subagent-service",
-  "version": "0.0.41",
-  "description": "虾说静态服务",
+  "version": "0.0.43",
+  "description": "虾说智能助手",
   "main": "cli.js",
   "bin": {
     "claw-subagent-service": "cli.js"

package/service/daemon.js

@@ -211,10 +211,17 @@ function startWorker(isAfterUpdate = false, backupDirForRollback = null) {
       healthTimer = null;
     }
 
-    log.error(`[DAEMON] Worker 退出，code=${code}, signal=${signal}`);
     worker = null;
     currentWorkerPid = null;
 
+    // 正常退出（code=0, signal=null）视为优雅关闭，不增加崩溃计数
+    const isNormalExit = code === 0 && signal === null;
+    if (isNormalExit) {
+      log.info(`[DAEMON] Worker 正常退出，code=${code}, signal=${signal}`);
+    } else {
+      log.error(`[DAEMON] Worker 异常退出，code=${code}, signal=${signal}`);
+    }
+
     if (isAfterUpdate && code !== 0 && currentBackupDir && !isRollingBack) {
       isRollingBack = true;
       log.error('[DAEMON] 新版 Worker 启动后异常退出，触发自动回滚！');
@@ -234,9 +241,11 @@ function startWorker(isAfterUpdate = false, backupDirForRollback = null) {
     }
 
     if (!stopping && !isRollingBack) {
-      // 使用指数退避延迟后重启；端口释放交由 startWorker 中的 freePortIfNeeded 处理，
-      // 避免此处误杀刚刚由其他实例启动的 worker
-      const delay = getRestartDelay();
+      // 正常退出使用固定 1 秒延迟；异常退出使用指数退避
+      const delay = isNormalExit ? 1000 : getRestartDelay();
+      if (!isNormalExit) {
+        log.info(`[DAEMON] Worker 连续崩溃 ${crashCount} 次，等待 ${delay / 1000}s 后重启`);
+      }
       setTimeout(() => startWorker(false, null), delay);
     }
   });
@@ -270,10 +279,10 @@ function restartWorkerWithUpdate(backupDir) {
           execSync(`taskkill /pid ${worker.pid} /T /F 2>nul`, { windowsHide: true });
         } catch (e) {
           // 忽略错误，使用 kill 作为后备
-          worker.kill('SIGTERM');
+          try { worker.kill('SIGTERM'); } catch { /* 进程可能已退出 */ }
         }
       } else {
-        worker.kill('SIGTERM');
+        try { worker.kill('SIGTERM'); } catch { /* 进程可能已退出 */ }
       }
 
       const waitKill = setInterval(() => {
@@ -288,10 +297,10 @@ function restartWorkerWithUpdate(backupDir) {
               const { execSync } = require('child_process');
               execSync(`taskkill /pid ${worker.pid} /T /F 2>nul`, { windowsHide: true });
             } catch (e) {
-              worker.kill('SIGKILL');
+              try { worker.kill('SIGKILL'); } catch { /* 进程可能已退出 */ }
             }
           } else {
-            worker.kill('SIGKILL');
+            try { worker.kill('SIGKILL'); } catch { /* 进程可能已退出 */ }
           }
         }
       }, 500);

package/service/rongcloud/message-handler.js

@@ -63,8 +63,8 @@ class MessageHandler {
       }
       this.log?.info(`[MessageHandler] 消息提及本节点(${this.nodeId})，处理`);
     } else if (msg.conversationType === 3) {
-      this.log?.info(`[MessageHandler] 群聊消息未 @ 本节点(${this.nodeId})，忽略`);
-      return false;
+      // 群聊消息未 @ 任何人 → 视为所有人参与，正常处理
+      this.log?.info(`[MessageHandler] 群聊消息未 @ 任何人，本节点(${this.nodeId})参与处理`);
     } else {
       this.log?.info(`[MessageHandler] 单聊消息未指定节点，本节点(${this.nodeId})处理`);
     }

package/service/updater.js

@@ -15,14 +15,25 @@ class Updater {
     this.currentVersion = this.loadCurrentVersion();
     this.isUpdating = false;
     this.updateTimer = null;
+    this.pkgJsonPath = path.join(__dirname, '..', 'package.json');
+    this.isGlobalInstall = this.detectGlobalInstall();
+  }
+
+  detectGlobalInstall() {
+    const cwd = path.normalize(__dirname).toLowerCase();
+    const inNodeModules = cwd.includes('node_modules');
+    const globalPaths = [
+      'npm', 'node_modules', '.nvm', 'usr/local/lib', 'usr/lib',
+    ];
+    const inGlobalPath = globalPaths.some(p => cwd.includes(p.toLowerCase()));
+    return inNodeModules || inGlobalPath;
   }
 
   loadCurrentVersion() {
     try {
-      // 从全局安装的 package.json 读取版本
-      const globalPkg = path.join(__dirname, '..', 'package.json');
-      if (fs.existsSync(globalPkg)) {
-        const pkg = JSON.parse(fs.readFileSync(globalPkg, 'utf8'));
+      const pkgPath = path.join(__dirname, '..', 'package.json');
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
         return pkg.version || '0.0.0';
       }
     } catch {
@@ -77,20 +88,19 @@ class Updater {
     try {
       log.info(`[UPDATER] 开始更新: ${this.currentVersion} → ${info.version}`);
 
-      // 使用 npm 全局安装最新版本
-      const { stdout, stderr } = await execAsync(
-        `npm install -g ${PACKAGE_NAME}@latest`,
-        { timeout: 300000, windowsHide: true }
-      );
-
-      if (stderr) {
-        log.warn(`[UPDATER] npm 安装警告: ${stderr.substring(0, 500)}`);
+      let updateOk = false;
+      if (this.isGlobalInstall) {
+        updateOk = await this.updateGlobalPackage(info.version);
+      } else {
+        updateOk = await this.updateLocalPackage(info.version);
       }
 
-      log.info(`[UPDATER] npm 安装输出: ${stdout.substring(0, 500)}`);
-      log.info(`[UPDATER] 更新完成，准备重启 Worker`);
+      if (!updateOk) {
+        return { success: false, error: '版本未变化' };
+      }
 
       this.currentVersion = info.version;
+      log.info(`[UPDATER] 更新完成，当前版本: ${this.currentVersion}，准备重启 Worker`);
       return { success: true };
     } catch (err) {
       log.error(`[UPDATER] 更新失败: ${err.message}`);
@@ -100,16 +110,136 @@ class Updater {
     }
   }
 
+  async updateGlobalPackage(version) {
+    const { stdout, stderr } = await execAsync(
+      `npm install -g ${PACKAGE_NAME}@${version}`,
+      { timeout: 300000, windowsHide: true }
+    );
+
+    if (stderr) {
+      log.warn(`[UPDATER] npm 安装警告: ${stderr.substring(0, 500)}`);
+    }
+    log.info(`[UPDATER] npm 安装输出: ${stdout.substring(0, 500)}`);
+
+    // 全局安装后重新读取版本确认
+    const newVersion = this.loadCurrentVersion();
+    if (this.compareVersion(newVersion, this.currentVersion) <= 0) {
+      log.warn(`[UPDATER] 更新后版本未变化: ${this.currentVersion} → ${newVersion}，可能安装路径不一致`);
+      return false;
+    }
+    return true;
+  }
+
+  async updateLocalPackage(version) {
+    const pkgDir = path.dirname(this.pkgJsonPath);
+    const tmpDir = path.join(pkgDir, '.update-tmp');
+
+    try {
+      // 1. 清理临时目录
+      if (fs.existsSync(tmpDir)) {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+      fs.mkdirSync(tmpDir, { recursive: true });
+
+      // 2. 下载 tarball
+      log.info(`[UPDATER] 下载 ${PACKAGE_NAME}@${version} ...`);
+      const { stdout } = await execAsync(
+        `npm pack ${PACKAGE_NAME}@${version}`,
+        { cwd: tmpDir, timeout: 120000, windowsHide: true }
+      );
+      const tarballName = stdout.trim().split('\n').pop();
+      const tarballPath = path.join(tmpDir, tarballName);
+      if (!fs.existsSync(tarballPath)) {
+        throw new Error('tarball 下载失败');
+      }
+
+      // 3. 解压 tarball
+      log.info(`[UPDATER] 解压 ${tarballName} ...`);
+      await execAsync(
+        `tar -xzf ${tarballPath} -C ${tmpDir}`,
+        { timeout: 30000 }
+      );
+
+      // 4. 复制 package/ 下的文件覆盖当前目录
+      const extractedDir = path.join(tmpDir, 'package');
+      if (!fs.existsSync(extractedDir)) {
+        throw new Error('解压后未找到 package 目录');
+      }
+
+      log.info(`[UPDATER] 覆盖本地文件...`);
+      this.copyDirSync(extractedDir, pkgDir);
+
+      // 5. 重新安装依赖（因为 node_modules 被覆盖）
+      log.info(`[UPDATER] 重新安装依赖...`);
+      const { stdout: installOut, stderr: installErr } = await execAsync(
+        'npm install --production',
+        { cwd: pkgDir, timeout: 300000, windowsHide: true }
+      );
+      if (installErr) {
+        log.warn(`[UPDATER] npm install 警告: ${installErr.substring(0, 500)}`);
+      }
+      log.info(`[UPDATER] npm install 输出: ${installOut.substring(0, 500)}`);
+
+      // 6. 验证版本
+      const newVersion = this.loadCurrentVersion();
+      if (this.compareVersion(newVersion, this.currentVersion) <= 0) {
+        log.warn(`[UPDATER] 更新后版本未变化: ${this.currentVersion} → ${newVersion}`);
+        return false;
+      }
+
+      log.info(`[UPDATER] 本地更新成功: ${this.currentVersion} → ${newVersion}`);
+      return true;
+    } catch (err) {
+      log.error(`[UPDATER] 本地更新异常: ${err.message}`);
+      return false;
+    } finally {
+      // 清理临时目录
+      try {
+        if (fs.existsSync(tmpDir)) {
+          fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+      } catch { /* 忽略 */ }
+    }
+  }
+
+  copyDirSync(src, dest) {
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      // 跳过隐藏文件、日志和临时目录
+      if (entry.name.startsWith('.') || entry.name === 'logs') {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        if (!fs.existsSync(destPath)) {
+          fs.mkdirSync(destPath, { recursive: true });
+        }
+        this.copyDirSync(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
   startSchedule(restartWorkerCallback) {
     this.restartWorker = restartWorkerCallback;
 
+    // Docker / 本地开发环境可通过环境变量禁用自动更新
+    if (process.env.DISABLE_AUTO_UPDATE === 'true' || process.env.DISABLE_AUTO_UPDATE === '1') {
+      log.info('[UPDATER] 已禁用自动更新（DISABLE_AUTO_UPDATE 已设置）');
+      return;
+    }
+
     const run = async () => {
       try {
         const info = await this.check();
         if (info) {
           const result = await this.execute(info);
           if (result.success) {
-            // npm 全局安装完成后，直接重启 Worker 即可加载新代码
+            // npm 安装完成后，直接重启 Worker 即可加载新代码
             this.restartWorker(null);
           }
         }