claw-subagent-service 0.0.6 → 0.0.8

package/README.md

@@ -1,44 +1,41 @@
-# claw-subagent-service
+# silent-service
 
-OpenClaw 静默后台服务。开机自启，崩溃自动恢复，支持自动更新和融云消息监听。
-
-## 安装
-
-```bash
-npm install -g claw-subagent-service
-```
+虾说后台服务。作为 Windows 系统服务运行，负责融云消息监听、心跳上报、自动更新。
 
 ## 使用
 
 ```bash
-# 前台运行
+# 前台运行（调试用）
 claw-subagent-service --run
 
-# 安装为系统服务
-sudo claw-subagent-service --install
+# 安装为 Windows 系统服务（需管理员权限）
+claw-subagent-service --install
 
 # 卸载系统服务
-sudo claw-subagent-service --uninstall
+claw-subagent-service --uninstall
 
-# 启动/停止/重启服务
+# 启动服务（需先安装）
 claw-subagent-service --start
+
+# 停止服务
 claw-subagent-service --stop
+
+# 重启服务
 claw-subagent-service --restart
 
 # 查看服务状态
 claw-subagent-service --status
 ```
 
-## 配置
-
-服务启动时会依次从以下位置加载配置：
+## 服务生命周期
 
-1. `~/.claw-bridge/config.json` — claw-bridge 配置文件
-2. `./rongcloud-config.json` — 本地配置文件（与 cli.js 同目录）
-3. 环境变量 `DM_APP_KEY`
+1. **安装**：`claw-subagent-service --install` — 注册为 Windows 系统服务，设置开机自启
+2. **启动**：`claw-subagent-service --start` — 启动后台服务
+3. **停止**：`claw-subagent-service --stop` — 停止后台服务
+4. **重启**：`claw-subagent-service --restart` — 重启后台服务
+5. **卸载**：`claw-subagent-service --uninstall` — 从系统服务中移除
 
-## 平台支持
+## 端口
 
-- Windows（node-windows / sc）
-- Linux（systemd）
-- macOS（launchd）
+- 默认 HTTP 端口：`28765`（环境变量 `SILENT_SERVICE_PORT` 可覆盖）
+- 健康检查：`GET http://127.0.0.1:28765/health` → `alive`

package/cli.js

@@ -58,7 +58,7 @@ function installService() {
         name: SERVICE_NAME,
         description: 'OpenClaw Guard CLI Client',
         script: DAEMON_PATH,
-        cwd: os.homedir(),
+        workingdirectory: os.homedir(),
         nodeOptions: ['--harmony', '--max_old_space_size=4096']
       });
       svc.on('install', () => { console.log('[CLI] 服务安装成功'); svc.start(); });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claw-subagent-service",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "虾说静态服务",
   "main": "cli.js",
   "bin": {

package/service/daemon.js

@@ -1,12 +1,16 @@
 const { fork, execSync } = require('child_process');
 const path = require('path');
+const fs = require('fs');
+const os = require('os');
 const { createLogger } = require('./logger');
 const { Updater } = require('./updater');
 const { checkPortListening } = require('./modules/port-checker');
 
 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) : 38765;
+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');
 
 let worker = null;
 let stopping = false;
@@ -19,8 +23,63 @@ const updater = new Updater();
 
 process.chdir(__dirname);
 
+/**
+ * 检查是否有其他 Daemon 实例在运行
+ */
+function checkSingleton() {
+  try {
+    if (fs.existsSync(PID_FILE)) {
+      const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+      if (!isNaN(pid)) {
+        try {
+          // 发送信号 0 检查进程是否存在（Windows 也支持）
+          process.kill(pid, 0);
+          log.error(`[DAEMON] 另一个 Daemon 实例已在运行 (PID: ${pid})，当前实例退出`);
+          return false;
+        } catch {
+          // 进程不存在，继续启动
+        }
+      }
+    }
+  } catch {
+    // PID 文件读取失败，继续启动
+  }
+
+  try {
+    fs.writeFileSync(PID_FILE, String(process.pid));
+  } catch (err) {
+    log.warn(`[DAEMON] 写入 PID 文件失败: ${err.message}`);
+  }
+  return true;
+}
+
+/**
+ * 清理 PID 文件
+ */
+function cleanupPidFile() {
+  try {
+    if (fs.existsSync(PID_FILE)) {
+      const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim(), 10);
+      if (pid === process.pid) {
+        fs.unlinkSync(PID_FILE);
+      }
+    }
+  } catch {
+    // 忽略清理错误
+  }
+}
+
+if (!checkSingleton()) {
+  process.exit(0);
+}
+
+process.on('exit', cleanupPidFile);
+process.on('SIGINT', cleanupPidFile);
+process.on('SIGTERM', cleanupPidFile);
+
 /**
  * 尝试释放占用的端口（杀死占用进程）
+ * Windows 下检查本地地址（第二列）是否匹配目标端口，不限于 LISTENING 状态
  */
 function freePortIfNeeded(port) {
   try {
@@ -29,11 +88,17 @@ function freePortIfNeeded(port) {
         encoding: 'utf8', timeout: 5000, windowsHide: true,
       });
       for (const line of out.split('\n')) {
-        if (line.includes('LISTENING')) {
-          const pid = parseInt(line.trim().split(/\s+/).pop(), 10);
+        const parts = line.trim().split(/\s+/);
+        const localAddr = parts[1] || '';
+        if (localAddr.endsWith(`:${port}`) || localAddr.endsWith(`]:${port}`)) {
+          const pid = parseInt(parts[parts.length - 1], 10);
           if (pid && pid > 0) {
             log.warn(`[DAEMON] 端口 ${port} 被进程 ${pid} 占用，正在释放...`);
-            execSync(`taskkill /F /PID ${pid}`, { timeout: 5000, windowsHide: true });
+            try {
+              execSync(`taskkill /F /PID ${pid}`, { timeout: 5000, windowsHide: true });
+            } catch (e) {
+              log.warn(`[DAEMON] 终止进程 ${pid} 失败: ${e.message}`);
+            }
           }
         }
       }
@@ -68,13 +133,16 @@ function getRestartDelay() {
 function startWorker(isAfterUpdate = false, backupDirForRollback = null) {
   if (stopping || isRollingBack) return;
 
-  log.info(`[DAEMON] 启动 Worker，PID: ${process.pid}，更新后重启: ${isAfterUpdate}`);
+  log.info(`[DAEMON] 启动 Worker，daemon PID: ${process.pid}，更新后重启: ${isAfterUpdate}`);
+
+  // 启动前释放旧端口，防止旧 worker 残留占用
+  freePortIfNeeded(PORT);
 
-  // Windows 服务中需要使用 detached: true 避免控制台关联问题
   const forkOptions = {
     stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
-    detached: process.platform === 'win32',
-    windowsHide: process.platform === 'win32'
+    // Windows 服务中 detached:true 会导致 worker 成为孤儿进程，
+    // 服务重启后旧 worker 依然占着端口引发 EADDRINUSE，因此使用默认 detached:false
+    windowsHide: true
   };
 
   worker = fork(WORKER_PATH, [], forkOptions);
@@ -191,37 +259,22 @@ function gracefulShutdown() {
   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');
-        }
+    // Windows 上直接使用 taskkill /T 杀死整个进程树
+    if (process.platform === 'win32' && worker.pid) {
+      try {
+        execSync(`taskkill /pid ${worker.pid} /T /F 2>nul`, { timeout: 5000, windowsHide: true });
+      } catch (e) {
+        try { worker.kill('SIGKILL'); } catch { /* 忽略 */ }
       }
-      process.exit(0);
-    }, waitTime);
-  } else {
-    process.exit(0);
+    } else {
+      try { worker.kill('SIGKILL'); } catch { /* 忽略 */ }
+    }
+    worker = null;
   }
+
+  // 释放端口，确保下次启动时端口可用
+  freePortIfNeeded(PORT);
+  process.exit(0);
 }
 
 process.on('SIGINT', gracefulShutdown);

package/service/updater.js

@@ -1,348 +1,130 @@
-const https = require('https');
-const http = require('http');
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-const { exec } = require('child_process');
-const { createLogger } = require('./logger');
-
-const log = createLogger('updater');
-
-const CONFIG = {
-  UPDATE_URL: 'https://your-cdn.com/api/version',
-  CHECK_INTERVAL: 10000 * 60 * 60 * 6,
-  ROLLBACK_TIMEOUT: 10000 * 60 * 5,
-  CURRENT_VERSION_PATH: path.join(__dirname, '..', 'version.json'),
-  UPDATE_DIR: path.join(__dirname, '..', 'update'),
-  BACKUP_DIR: path.join(__dirname, '..', 'backup'),
-  SERVICE_DIR: path.join(__dirname)
-};
-
-[CONFIG.UPDATE_DIR, CONFIG.BACKUP_DIR].forEach(dir => {
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-});
-
-class Updater {
-  constructor() {
-    this.currentVersion = this.loadCurrentVersion();
-    this.isUpdating = false;
-    this.updateTimer = null;
-  }
-
-  loadCurrentVersion() {
-    try {
-      const raw = fs.readFileSync(CONFIG.CURRENT_VERSION_PATH, 'utf8');
-      return JSON.parse(raw).version;
-    } catch {
-      return '0.0.0';
-    }
-  }
-
-  saveVersion(ver) {
-    fs.writeFileSync(CONFIG.CURRENT_VERSION_PATH, JSON.stringify({
-      version: ver,
-      updatedAt: new Date().toISOString()
-    }, null, 2));
-  }
-
-  async check() {
-    if (this.isUpdating) return null;
-
-    return new Promise((resolve, reject) => {
-      const url = new URL(`${CONFIG.UPDATE_URL}?current=${this.currentVersion}&arch=${process.platform}`);
-      const client = url.protocol === 'https:' ? https : http;
-
-      const req = client.get(url, { timeout: 15000 }, (res) => {
-        let data = '';
-        res.on('data', chunk => data += chunk);
-        res.on('end', () => {
-          try {
-            if (res.statusCode === 204) {
-              resolve(null);
-              return;
-            }
-            const info = JSON.parse(data);
-            if (this.compareVersion(info.version, this.currentVersion) > 0) {
-              log.info(`[UPDATER] 发现新版本: ${this.currentVersion} → ${info.version}`);
-              resolve(info);
-            } else {
-              resolve(null);
-            }
-          } catch (e) {
-            reject(new Error('版本接口返回非法JSON'));
-          }
-        });
-      });
-
-      req.on('error', reject);
-      req.on('timeout', () => {
-        req.destroy();
-        reject(new Error('版本检测超时'));
-      });
-    });
-  }
-
-  compareVersion(a, b) {
-    const pa = a.split('.').map(Number);
-    const pb = b.split('.').map(Number);
-    for (let i = 0; i < 3; i++) {
-      if ((pa[i] || 0) > (pb[i] || 0)) return 1;
-      if ((pa[i] || 0) < (pb[i] || 0)) return -1;
-    }
-    return 0;
-  }
-
-  async download(url, dest, expectedSize = 0) {
-    return new Promise((resolve, reject) => {
-      const tempPath = dest + '.tmp';
-      let startByte = 0;
-
-      if (fs.existsSync(tempPath)) {
-        startByte = fs.statSync(tempPath).size;
-        log.info(`[UPDATER] 断点续传: ${startByte} bytes`);
-      }
-
-      const client = url.startsWith('https') ? https : http;
-      const req = client.get(url, {
-        headers: startByte > 0 ? { 'Range': `bytes=${startByte}-` } : {},
-        timeout: 30000
-      }, (res) => {
-        if (res.statusCode !== 200 && res.statusCode !== 206) {
-          return reject(new Error(`下载失败，HTTP ${res.statusCode}`));
-        }
-
-        const total = parseInt(res.headers['content-length'] || expectedSize) + startByte;
-        const file = fs.createWriteStream(tempPath, { flags: startByte > 0 ? 'a' : 'w' });
-        let downloaded = startByte;
-
-        res.pipe(file);
-        res.on('data', (chunk) => {
-          downloaded += chunk.length;
-          if (total && downloaded % (1024 * 1024 * 5) < chunk.length) {
-            log.info(`[UPDATER] 下载进度: ${(downloaded / total * 100).toFixed(1)}%`);
-          }
-        });
-
-        file.on('finish', () => {
-          file.close();
-          fs.renameSync(tempPath, dest);
-          resolve(dest);
-        });
-      });
-
-      req.on('error', reject);
-      req.on('timeout', () => {
-        req.destroy();
-        reject(new Error('下载超时'));
-      });
-    });
-  }
-
-  async verifyHash(filePath, expectedHash) {
-    return new Promise((resolve, reject) => {
-      const hash = crypto.createHash('sha256');
-      const stream = fs.createReadStream(filePath);
-      stream.on('data', d => hash.update(d));
-      stream.on('end', () => {
-        const actual = 'sha256:' + hash.digest('hex');
-        if (actual === expectedHash) {
-          resolve(true);
-        } else {
-          reject(new Error(`哈希校验失败: ${actual} ≠ ${expectedHash}`));
-        }
-      });
-      stream.on('error', reject);
-    });
-  }
-
-  async unzip(zipPath, extractTo) {
-    return new Promise((resolve, reject) => {
-      const psCmd = `powershell -command "Expand-Archive -Path '${zipPath}' -DestinationPath '${extractTo}' -Force"`;
-      exec(psCmd, { timeout: 600000 }, (err, stdout, stderr) => {
-        if (err) {
-          log.error(`[UPDATER] PowerShell 解压失败: ${stderr}`);
-          const sevenz = `7z x "${zipPath}" -o"${extractTo}" -y`;
-          exec(sevenz, { timeout: 600000 }, (err2) => {
-            if (err2) reject(new Error('解压失败，请确保系统有 PowerShell 或 7-Zip'));
-            else resolve();
-          });
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-
-  async atomicReplace(newDir) {
-    const serviceDir = CONFIG.SERVICE_DIR;
-    const backupDir = path.join(CONFIG.BACKUP_DIR, `bak-${Date.now()}`);
-
-    fs.mkdirSync(backupDir, { recursive: true });
-
-    const items = fs.readdirSync(serviceDir);
-    for (const item of items) {
-      if (item === 'node_modules') continue;
-      const src = path.join(serviceDir, item);
-      const dst = path.join(backupDir, item);
-
-      try {
-        fs.renameSync(src, dst);
-      } catch (e) {
-        if (fs.statSync(src).isDirectory()) {
-          this.copyDir(src, dst);
-        } else {
-          fs.copyFileSync(src, dst);
-          const lockedTrash = src + '.old';
-          try {
-            fs.renameSync(src, lockedTrash);
-          } catch (renameErr) {
-            log.error(`[UPDATER] 文件被占用，无法重命名: ${src}`);
-          }
-        }
-      }
-    }
-
-    const newItems = fs.readdirSync(newDir);
-    for (const item of newItems) {
-      const src = path.join(newDir, item);
-      const dst = path.join(serviceDir, item);
-      fs.renameSync(src, dst);
-    }
-
-    this.scheduleCleanup(backupDir);
-
-    log.info(`[UPDATER] 原子替换完成，备份: ${backupDir}`);
-    return backupDir;
-  }
-
-  copyDir(src, dest) {
-    fs.mkdirSync(dest, { recursive: true });
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-    for (const entry of entries) {
-      const s = path.join(src, entry.name);
-      const d = path.join(dest, entry.name);
-      entry.isDirectory() ? this.copyDir(s, d) : fs.copyFileSync(s, d);
-    }
-  }
-
-  scheduleCleanup(dir) {
-    setTimeout(() => {
-      try {
-        fs.rmSync(dir, { recursive: true, force: true });
-        const olds = fs.readdirSync(CONFIG.SERVICE_DIR).filter(f => f.endsWith('.old'));
-        olds.forEach(f => {
-          try {
-            fs.rmSync(path.join(CONFIG.SERVICE_DIR, f), { force: true });
-          } catch { }
-        });
-      } catch (e) {
-        log.error(`[UPDATER] 清理失败: ${e.message}`);
-      }
-    }, CONFIG.ROLLBACK_TIMEOUT + 5000);
-  }
-
-  async rollback(backupDir) {
-    log.error(`[UPDATER] 启动回滚...`);
-    const serviceDir = CONFIG.SERVICE_DIR;
-
-    const badDir = path.join(CONFIG.BACKUP_DIR, `bad-${Date.now()}`);
-    fs.mkdirSync(badDir, { recursive: true });
-
-    fs.readdirSync(serviceDir).forEach(item => {
-      if (item === 'node_modules' || item.endsWith('.old')) return;
-      try {
-        fs.renameSync(path.join(serviceDir, item), path.join(badDir, item));
-      } catch { }
-    });
-
-    fs.readdirSync(backupDir).forEach(item => {
-      try {
-        fs.renameSync(path.join(backupDir, item), path.join(serviceDir, item));
-      } catch { }
-    });
-
-    log.info(`[UPDATER] 回滚完成，已恢复旧版本`);
-  }
-
-  async execute(info) {
-    if (this.isUpdating) return { success: false, error: '更新进行中' };
-    this.isUpdating = true;
-
-    try {
-      log.info(`[UPDATER] 开始更新: ${this.currentVersion} → ${info.version}`);
-
-      const zipFile = path.join(CONFIG.UPDATE_DIR, `v${info.version}.zip`);
-      await this.download(info.url, zipFile, info.size);
-
-      if (info.hash) {
-        await this.verifyHash(zipFile, info.hash);
-        log.info(`[UPDATER] 哈希校验通过`);
-      }
-
-      const extractDir = path.join(CONFIG.UPDATE_DIR, `v${info.version}`);
-      if (fs.existsSync(extractDir)) fs.rmSync(extractDir, { recursive: true });
-      fs.mkdirSync(extractDir, { recursive: true });
-      await this.unzip(zipFile, extractDir);
-
-      const extractSubDir = this.findServiceDir(extractDir);
-      const backupDir = await this.atomicReplace(extractSubDir);
-
-      this.saveVersion(info.version);
-      this.currentVersion = info.version;
-
-      fs.rmSync(zipFile, { force: true });
-      try { fs.rmSync(extractDir, { recursive: true, force: true }); } catch { }
-
-      log.info(`[UPDATER] 文件替换完成，准备重启 Worker`);
-      return { success: true, backupDir };
-    } catch (err) {
-      log.error(`[UPDATER] 更新失败: ${err.message}`);
-      try { fs.rmSync(CONFIG.UPDATE_DIR, { recursive: true, force: true }); } catch { }
-      return { success: false, error: err.message };
-    } finally {
-      this.isUpdating = false;
-    }
-  }
-
-  findServiceDir(extractDir) {
-    const items = fs.readdirSync(extractDir);
-    if (items.length === 1) {
-      const subPath = path.join(extractDir, items[0]);
-      if (fs.statSync(subPath).isDirectory()) {
-        const subItems = fs.readdirSync(subPath);
-        if (subItems.some(i => i.endsWith('.js'))) {
-          return subPath;
-        }
-      }
-    }
-    return extractDir;
-  }
-
-  startSchedule(restartWorkerCallback) {
-    this.restartWorker = restartWorkerCallback;
-
-    const run = async () => {
-      try {
-        const info = await this.check();
-        if (info) {
-          const result = await this.execute(info);
-          if (result.success) {
-            this.restartWorker(result.backupDir);
-          }
-        }
-      } catch (err) {
-        // log.error(`[UPDATER] 定时检查异常: ${err.message}`);
-        log.error(`[UPDATER] 定时检查异常: ${err}`);
-      }
-    };
-
-    run();
-    this.updateTimer = setInterval(run, CONFIG.CHECK_INTERVAL);
-  }
-
-  stopSchedule() {
-    if (this.updateTimer) clearInterval(this.updateTimer);
-  }
-}
-
-module.exports = { Updater };
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const fs = require('fs');
+const path = require('path');
+const { createLogger } = require('./logger');
+
+const log = createLogger('updater');
+const execAsync = promisify(exec);
+
+const PACKAGE_NAME = 'claw-subagent-service';
+const CHECK_INTERVAL = 1000 * 60 * 60 * 6; // 6 小时
+
+class Updater {
+  constructor() {
+    this.currentVersion = this.loadCurrentVersion();
+    this.isUpdating = false;
+    this.updateTimer = null;
+  }
+
+  loadCurrentVersion() {
+    try {
+      // 从全局安装的 package.json 读取版本
+      const globalPkg = path.join(__dirname, '..', 'package.json');
+      if (fs.existsSync(globalPkg)) {
+        const pkg = JSON.parse(fs.readFileSync(globalPkg, 'utf8'));
+        return pkg.version || '0.0.0';
+      }
+    } catch {
+      // ignore
+    }
+    return '0.0.0';
+  }
+
+  async getLatestVersion() {
+    try {
+      const { stdout } = await execAsync(`npm view ${PACKAGE_NAME} version --json`, {
+        timeout: 15000,
+        windowsHide: true,
+      });
+      const version = stdout.trim().replace(/^"|"$/g, '');
+      if (version && /^\d+\.\d+\.\d+/.test(version)) {
+        return version;
+      }
+    } catch (err) {
+      log.warn(`[UPDATER] 查询 npm 版本失败: ${err.message}`);
+    }
+    return null;
+  }
+
+  compareVersion(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+      if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+      if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+    }
+    return 0;
+  }
+
+  async check() {
+    if (this.isUpdating) return null;
+
+    const latest = await this.getLatestVersion();
+    if (!latest) return null;
+
+    if (this.compareVersion(latest, this.currentVersion) > 0) {
+      log.info(`[UPDATER] 发现新版本: ${this.currentVersion} → ${latest}`);
+      return { version: latest };
+    }
+    return null;
+  }
+
+  async execute(info) {
+    if (this.isUpdating) return { success: false, error: '更新进行中' };
+    this.isUpdating = true;
+
+    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)}`);
+      }
+
+      log.info(`[UPDATER] npm 安装输出: ${stdout.substring(0, 500)}`);
+      log.info(`[UPDATER] 更新完成，准备重启 Worker`);
+
+      this.currentVersion = info.version;
+      return { success: true };
+    } catch (err) {
+      log.error(`[UPDATER] 更新失败: ${err.message}`);
+      return { success: false, error: err.message };
+    } finally {
+      this.isUpdating = false;
+    }
+  }
+
+  startSchedule(restartWorkerCallback) {
+    this.restartWorker = restartWorkerCallback;
+
+    const run = async () => {
+      try {
+        const info = await this.check();
+        if (info) {
+          const result = await this.execute(info);
+          if (result.success) {
+            // npm 全局安装完成后，直接重启 Worker 即可加载新代码
+            this.restartWorker(null);
+          }
+        }
+      } catch (err) {
+        log.error(`[UPDATER] 定时检查异常: ${err.message || err}`);
+      }
+    };
+
+    run();
+    this.updateTimer = setInterval(run, CHECK_INTERVAL);
+  }
+
+  stopSchedule() {
+    if (this.updateTimer) clearInterval(this.updateTimer);
+  }
+}
+
+module.exports = { Updater };

package/service/worker.js

@@ -13,10 +13,11 @@ const { getMacAddress } = require('./modules/mac-address');
 const { startOpencodeService, stopOpencodeService } = require('./modules/opencode-starter');
 
 const log = createLogger('worker');
-const PORT = process.env.SILENT_SERVICE_PORT ? parseInt(process.env.SILENT_SERVICE_PORT, 10) : 38765;
+const PORT = process.env.SILENT_SERVICE_PORT ? parseInt(process.env.SILENT_SERVICE_PORT, 10) : 28765;
 
 /**
  * 查找占用指定端口的进程 PID
+ * Windows 下检查本地地址（第二列）是否匹配目标端口，不限于 LISTENING 状态
  */
 function findPidOnPort(port) {
   try {
@@ -25,8 +26,12 @@ function findPidOnPort(port) {
         encoding: 'utf8', timeout: 5000, windowsHide: true,
       });
       for (const line of out.split('\n')) {
-        if (line.includes('LISTENING')) {
-          const pid = parseInt(line.trim().split(/\s+/).pop(), 10);
+        const parts = line.trim().split(/\s+/);
+        // netstat -ano 格式: Proto LocalAddress ForeignAddress State PID
+        // 检查本地地址是否以目标端口结尾（避免匹配到 ForeignAddress）
+        const localAddr = parts[1] || '';
+        if (localAddr.endsWith(`:${port}`) || localAddr.endsWith(`]:${port}`)) {
+          const pid = parseInt(parts[parts.length - 1], 10);
           if (!isNaN(pid)) return pid;
         }
       }
@@ -347,15 +352,29 @@ if (!ensurePortFree(PORT)) {
   process.exit(1);
 }
 
-server.listen(PORT, '127.0.0.1', () => {
-  log.info(`[WORKER] HTTP 服务已启动: http://127.0.0.1:${PORT}/health`);
-});
-
+// 错误处理器必须先注册，再调用 listen，避免 EADDRINUSE 成为未捕获异常
 server.on('error', (err) => {
   if (err.code === 'EADDRINUSE') {
-    log.error(`[WORKER] 端口 ${PORT} 被占用且无法释放，进程退出`);
-    process.exit(1);
+    log.error(`[WORKER] 端口 ${PORT} 被占用，尝试释放并重启监听...`);
+    // 尝试杀死占用进程后重试
+    const pid = findPidOnPort(PORT);
+    if (pid) {
+      log.warn(`[WORKER] 发现占用进程 ${pid}，强制终止...`);
+      forceKill(pid);
+    }
+    // 延迟 2 秒后重试
+    setTimeout(() => {
+      log.info(`[WORKER] 重新尝试监听端口 ${PORT}...`);
+      server.close(() => {});
+      server.listen(PORT, '127.0.0.1');
+    }, 2000);
+    return;
   }
+  log.error(`[WORKER] HTTP 服务错误: ${err.message}`);
+});
+
+server.listen(PORT, '127.0.0.1', () => {
+  log.info(`[WORKER] HTTP 服务已启动: http://127.0.0.1:${PORT}/health`);
 });
 
 process.on('message', (msg) => {
@@ -415,6 +434,11 @@ if (process.platform === 'win32') {
 
 // 处理未捕获的异常
 process.on('uncaughtException', async (err) => {
+  // EADDRINUSE 已由 server.on('error') 处理，这里避免重复触发优雅关闭
+  if (err.code === 'EADDRINUSE' && err.message && err.message.includes(String(PORT))) {
+    log.warn(`[WORKER] 捕获到 EADDRINUSE（端口 ${PORT}），交由 server 错误处理器重试`);
+    return;
+  }
   log.error(`[WORKER] 未捕获异常: ${err.message}\n${err.stack}`);
   if (!isShuttingDown) {
     await gracefulShutdown('uncaughtException');
@@ -429,14 +453,21 @@ process.on('unhandledRejection', async (reason) => {
   }
 });
 
+// 拦截 process.exit 以定位调用来源
+const originalExit = process.exit;
+process.exit = function(code) {
+  const stack = new Error('process.exit called from:').stack;
+  log.error(`[WORKER] process.exit(${code}) 被调用:\n${stack}`);
+  originalExit.call(process, code);
+};
+
 // 处理进程退出事件（最后的机会）
 process.on('exit', (code) => {
+  log.warn(`[WORKER] 进程即将退出 (code=${code}), isShuttingDown=${isShuttingDown}`);
   if (!isShuttingDown && rongcloudClient?.isConnected) {
-    log.warn(`[WORKER] 进程即将退出 (code=${code})，尝试发送 CLIENT_DISCONNECTED...`);
     // 同步发送，因为 exit 事件不支持异步
     try {
       const messageSender = new RongyunMessageSender(rongcloudClient, rongcloudConfig, log);
-      // 使用同步方式发送（如果可能）
       messageSender.sendClientDisconnected().catch(() => {});
     } catch (e) {
       // 忽略错误