claw-subagent-service 0.0.42 → 0.0.45

package/package.json

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

package/service/daemon.js

@@ -145,11 +145,11 @@ function freePortIfNeeded(port) {
           log.warn(`[DAEMON] 终止进程 ${pid} 失败: ${e.message}`);
         }
       } else {
-        // 所有命令都不可用，尝试按脚本名批量杀掉残留进程
+        // 所有端口查询命令都不可用（常见于精简 Docker 镜像）
+        // 兜底：杀掉残留 Worker 进程（Daemon 自身的命令行不含 worker.js，不会自杀）
         try {
-          execSync('pkill -9 -f "daemon.js" 2>/dev/null || true', { timeout: 5000 });
           execSync('pkill -9 -f "worker.js" 2>/dev/null || true', { timeout: 5000 });
-          log.warn(`[DAEMON] 已尝试按脚本名释放端口 ${port}`);
+          log.warn(`[DAEMON] 已尝试杀掉残留 Worker 进程`);
         } catch { /* 忽略 */ }
       }
     }
@@ -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/modules/script-executor.js

@@ -113,7 +113,8 @@ class ScriptExecutor {
         cmd = 'cmd';
         args = ['/c', command];
       } else {
-        cmd = 'bash';
+        // Alpine 等精简镜像可能缺少 bash，优先使用 sh
+        cmd = 'sh';
         args = ['-c', command];
       }
 
@@ -186,7 +187,8 @@ class ScriptExecutor {
         cmd = 'cmd';
         args = ['/c', scriptPath];
       } else {
-        cmd = 'bash';
+        // Alpine 等精简镜像可能缺少 bash，优先使用 sh
+        cmd = 'sh';
         args = [scriptPath];
       }
 

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,142 @@ 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;
+    }
+
+    // Linux 平台默认禁用自动更新 npm 包
+    if (process.platform === 'linux') {
+      log.info('[UPDATER] Linux 平台已禁用自动 npm 更新');
+      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);
           }
         }

package/service/worker.js

@@ -18,16 +18,6 @@ const PORT = process.env.SILENT_SERVICE_PORT ? parseInt(process.env.SILENT_SERVI
 const HOST = process.env.SILENT_SERVICE_HOST || '127.0.0.1';
 
 
-// 捕获所有异常，强制打印到控制台（绕过 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) => {
@@ -96,13 +86,11 @@ function ensurePortFree(port) {
   for (let i = 0; i < 3; i++) {
     const pid = findPidOnPort(port);
     if (!pid) {
-      // 端口查询工具都不可用但端口仍可能被占用，按脚本名兜底清理一次
-      if (i === 0 && process.platform !== 'win32') {
-        try {
-          execSync('pkill -9 -f "daemon.js" 2>/dev/null || true', { timeout: 5000 });
-          execSync('pkill -9 -f "worker.js" 2>/dev/null || true', { timeout: 5000 });
-          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2000);
-        } catch { /* 忽略 */ }
+      // 端口查询工具都不可用（常见于精简 Docker 镜像）
+      // 不执行 pkill 兜底，避免自杀；依赖 Daemon 的 freePortIfNeeded 清理残留 Worker
+      if (i === 0) {
+        log.warn(`[WORKER] 端口查询工具不可用，等待 Daemon 清理残留进程...`);
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2000);
         continue;
       }
       return true;
@@ -494,12 +482,9 @@ server.on('error', (err) => {
       log.warn(`[WORKER] 发现占用进程 ${pid}，强制终止...`);
       forceKill(pid);
     } else if (!pid) {
-      // 所有端口查询工具都不可用（常见于精简 Docker 镜像），按脚本名兜底清理
-      log.warn('[WORKER] 无法查询端口占用进程，尝试按脚本名清理残留...');
-      try {
-        execSync('pkill -9 -f "daemon.js" 2>/dev/null || true', { timeout: 5000 });
-        execSync('pkill -9 -f "worker.js" 2>/dev/null || true', { timeout: 5000 });
-      } catch { /* 忽略 */ }
+      // 端口查询工具都不可用（常见于精简 Docker 镜像）
+      // 不执行 pkill 兜底避免自杀；依赖 Daemon 的 freePortIfNeeded 清理残留 Worker
+      log.warn('[WORKER] 无法查询端口占用进程，等待 Daemon 清理残留...');
     }
     // 延迟 3 秒后重试，给进程退出和端口释放留出足够时间
     setTimeout(() => {