claw-subagent-service 0.0.17 → 0.0.18

package/cli.js

@@ -50,31 +50,39 @@ function installService() {
   const execPath = process.execPath;
 
   if (platform === 'win32') {
-    // Windows: 使用 sc 命令直接创建服务，避免 node-windows 在包目录生成被锁定的 wrapper
-    console.log('[CLI] 使用 sc.exe 命令安装服务...');
-    // sc.exe binPath 格式：外层引号包裹整个值，内层路径用转义引号
-    const binPath = process.pkg
-      ? `\\"${execPath}\\" --run`
-      : `\\"${execPath}\\" \\"${DAEMON_PATH}\\"`;
-
-    // 先停止并删除旧服务（避免文件锁）
-    exec(`net stop "${SERVICE_NAME}" 2>nul & sc.exe delete "${SERVICE_NAME}" 2>nul`, () => {
-      const createCmd = `sc.exe create "${SERVICE_NAME}" binPath= "${binPath}" start= auto displayname= "OpenClaw Guard"`;
-      console.log(`[CLI] 执行: ${createCmd}`);
-      exec(createCmd, { windowsHide: true }, (err2, stdout, stderr) => {
-        if (err2) {
-          console.error(`[CLI] 服务安装失败: ${err2.message}`);
-          console.error(`[CLI] stdout: ${stdout}`);
-          console.error(`[CLI] stderr: ${stderr}`);
-          return;
-        }
-        console.log(`[CLI] 注册服务输出: ${stdout}`);
+    // Windows: 使用 node-windows 注册服务（正确处理路径引号）
+    console.log('[CLI] 使用 node-windows 安装服务...');
+    try {
+      const Service = require('node-windows').Service;
+      const svc = new Service({
+        name: SERVICE_NAME,
+        description: 'OpenClaw Guard',
+        script: DAEMON_PATH,
+        nodeOptions: ['--harmony', '--max_old_space_size=4096']
+      });
+
+      svc.on('install', () => {
         console.log('[CLI] 服务安装成功');
-        exec(`net start "${SERVICE_NAME}"`, (err3) => {
-          if (err3) console.error(`[CLI] 启动服务失败: ${err3.message}`);
-        });
+        svc.start();
       });
-    });
+
+      svc.on('start', () => {
+        console.log('[CLI] 服务已启动');
+      });
+
+      svc.on('error', (err) => {
+        console.error(`[CLI] 服务安装失败: ${err.message}`);
+      });
+
+      svc.on('alreadyinstalled', () => {
+        console.log('[CLI] 服务已存在，尝试启动...');
+        svc.start();
+      });
+
+      svc.install();
+    } catch (err) {
+      console.error(`[CLI] 安装服务异常: ${err.message}`);
+    }
   } else if (platform === 'linux') {
     // Linux: systemd
     const execStart = `/usr/bin/node ${DAEMON_PATH}`;
@@ -145,19 +153,15 @@ function uninstallService() {
   const platform = process.platform;
 
   if (platform === 'win32') {
-    // Windows: 优先使用 node-windows，失败回退 sc 命令
+    // Windows: 使用 node-windows 卸载服务
     try {
-      if (process.pkg) throw new Error('pkg 环境');
       const Service = require('node-windows').Service;
       const svc = new Service({ name: SERVICE_NAME, script: DAEMON_PATH });
       svc.on('uninstall', () => console.log('[CLI] 服务卸载成功'));
+      svc.on('error', (err) => console.error(`[CLI] 卸载失败: ${err.message}`));
       svc.uninstall();
     } catch (err) {
-      console.log('[CLI] 使用 sc.exe 命令卸载服务...');
-      exec(`sc.exe stop ${SERVICE_NAME} 2>nul & sc.exe delete ${SERVICE_NAME}`, (err2) => {
-        if (err2) console.error(`[CLI] 卸载失败: ${err2.message}`);
-        else console.log('[CLI] 服务卸载成功');
-      });
+      console.error(`[CLI] 卸载服务异常: ${err.message}`);
     }
   } else if (platform === 'linux') {
     exec(`systemctl stop ${SERVICE_NAME} && systemctl disable ${SERVICE_NAME} && rm -f /etc/systemd/system/${SERVICE_NAME}.service && systemctl daemon-reload`, (err) => {

package/package.json

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

package/scripts/install-silent.js

@@ -44,45 +44,55 @@ if (platform === 'win32') {
     // 兜底超时
     setTimeout(() => finish(1, '安装操作超时'), 60000);
 
-    // 先停止并删除旧服务（避免文件锁导致更新失败）
-    exec(`net stop "${SERVICE_NAME}" 2>nul & sc.exe delete "${SERVICE_NAME}" 2>nul`, () => {
-      // sc.exe binPath 格式：外层引号包裹整个值，内层路径用转义引号
-      const binPath = `\\"${process.execPath}\\" \\"${DAEMON_PATH}\\"`;
-
-      const createCmd = `sc.exe create "${SERVICE_NAME}" binPath= "${binPath}" start= auto displayname= "Node.js 静默后台服务"`;
-      log(`执行命令: ${createCmd}`);
-      exec(createCmd, { windowsHide: true }, (err, stdout, stderr) => {
-        if (err) {
-          log(`创建服务失败: ${err.message}`);
-          return finish(1, `创建服务失败: ${err.message}`);
-        }
-        log('服务注册成功');
-
-        // 设置恢复策略：崩溃后自动重启
-        const recoveryCmd = `sc.exe failure "${SERVICE_NAME}" reset= 0 actions= restart/0/restart/0/restart/0`;
-        exec(recoveryCmd, (err) => {
+    // 使用 node-windows 注册服务（正确处理路径引号）
+    try {
+      const Service = require('node-windows').Service;
+      const svc = new Service({
+        name: SERVICE_NAME,
+        description: 'Node.js 静默后台服务（开机自启/崩溃自动恢复/自动更新）',
+        script: DAEMON_PATH,
+        wait: 2,
+        grow: 0.5,
+        abortOnError: false
+      });
+
+      svc.on('install', () => {
+        log('服务安装成功，正在启动...');
+        svc.start();
+
+        const cmd = `sc.exe failure "${SERVICE_NAME}" reset= 0 actions= restart/0/restart/0/restart/0`;
+        exec(cmd, (err) => {
           if (err) log(`设置恢复策略失败: ${err.message}`);
           else log('恢复策略已设置：服务崩溃后系统自动无限重启');
         });
 
-        // 设置自动启动
         exec(`sc.exe config "${SERVICE_NAME}" start= auto`, (err) => {
           if (err) log(`设置自动启动失败: ${err.message}`);
           else log('启动类型已设为：自动');
         });
+      });
 
-        // 启动服务
-        exec(`net start "${SERVICE_NAME}"`, (err) => {
-          if (err) {
-            log(`启动服务失败: ${err.message}`);
-            finish(1, `启动服务失败: ${err.message}`);
-          } else {
-            log('服务已启动');
-            finish(0, '服务安装成功并已启动');
-          }
-        });
+      svc.on('alreadyinstalled', () => {
+        log('服务已存在，尝试启动...');
+        svc.start();
       });
-    });
+
+      svc.on('start', () => {
+        log('服务已启动');
+        finish(0);
+      });
+
+      svc.on('error', (err) => {
+        log(`安装错误: ${err.message}`);
+        finish(1);
+      });
+
+      log('开始安装服务...');
+      svc.install();
+    } catch (err) {
+      log(`安装异常: ${err.message}`);
+      finish(1);
+    }
   });
 } else if (platform === 'linux') {
   const serviceFile = `/etc/systemd/system/${SERVICE_NAME}.service`;

package/scripts/post-install.js

@@ -2,28 +2,26 @@
  * npm postinstall 钩子
  * 全局安装完成后自动注册并启动 Windows 服务
  */
-const { exec, execSync } = require('child_process');
+const { execSync } = require('child_process');
 const path = require('path');
 
 const SERVICE_NAME = 'claw-subagent-service';
 const DAEMON_PATH = path.join(__dirname, '..', 'service', 'daemon.js');
 
 function isGlobalInstall() {
-  // 方法1: 检查 __dirname 是否在 node_modules 下且不在当前工作目录下
   const pkgPath = path.normalize(__dirname).toLowerCase();
   const cwd = process.cwd().toLowerCase();
   const inNodeModules = pkgPath.includes('node_modules');
   const notInCwd = !pkgPath.startsWith(cwd);
 
-  console.log(`[postinstall] 安装检测: pkgPath=${pkgPath}, cwd=${cwd}`);
   console.log(`[postinstall] 安装检测: inNodeModules=${inNodeModules}, notInCwd=${notInCwd}`);
 
   if (inNodeModules && notInCwd) {
-    console.log('[postinstall] 检测到全局安装（包在 node_modules 下且不在当前工作目录）');
+    console.log('[postinstall] 检测到全局安装');
     return true;
   }
 
-  // 方法2: 兜底 - 默认按全局安装处理（postinstall 只在安装时触发）
+  // 兜底 - postinstall 只在安装时触发，默认按全局安装处理
   console.log('[postinstall] 兜底检测通过，默认按全局安装处理');
   return true;
 }
@@ -40,56 +38,50 @@ function isWindowsAdmin() {
 
 function installAndStartService() {
   if (process.platform !== 'win32') {
-    console.log(`[postinstall] 跳过自动注册服务（非 Windows 平台: ${process.platform}）`);
+    console.log(`[postinstall] 跳过（非 Windows: ${process.platform}）`);
     return;
   }
 
   if (!isWindowsAdmin()) {
-    console.log('[postinstall] 当前非管理员权限，跳过自动注册服务');
-    console.log('[postinstall] 如需注册服务，请以管理员身份运行: claw-subagent-service --install');
+    console.log('[postinstall] 非管理员权限，跳过自动注册');
+    console.log('[postinstall] 请运行: claw-subagent-service --install');
     return;
   }
 
   console.log('[postinstall] 正在注册系统服务...');
 
-  // sc.exe binPath 格式：外层引号包裹整个值，内层路径用转义引号
-  // 这样 sc.exe 会把整个字符串作为 binPath 的单一值
-  const binPath = `\\"${process.execPath}\\" \\"${DAEMON_PATH}\\"`;
-
-  // 先停止并删除旧服务（避免冲突）
-  try { execSync(`net stop "${SERVICE_NAME}" 2>nul`, { stdio: 'ignore', timeout: 10000 }); } catch (e) {}
-  try { execSync(`sc.exe delete "${SERVICE_NAME}" 2>nul`, { stdio: 'ignore', timeout: 10000 }); } catch (e) {}
-
-  // sc.exe create 命令：binPath= 后面的值用引号包裹，内部路径用转义引号
-  const createCmd = `sc.exe create "${SERVICE_NAME}" binPath= "${binPath}" start= auto displayname= "OpenClaw Guard"`;
-  console.log(`[postinstall] 执行: ${createCmd}`);
-
-  exec(createCmd, { windowsHide: true }, (err, stdout, stderr) => {
-    if (err) {
-      console.error(`[postinstall] 注册服务失败: ${err.message}`);
-      console.error(`[postinstall] stdout: ${stdout}`);
-      console.error(`[postinstall] stderr: ${stderr}`);
-      return;
-    }
-    console.log(`[postinstall] 注册服务输出: ${stdout}`);
-    console.log('[postinstall] 服务注册成功');
-
-    // 设置恢复策略
-    exec(`sc.exe failure "${SERVICE_NAME}" reset= 0 actions= restart/0/restart/0/restart/0`, (err) => {
-      if (!err) console.log('[postinstall] 恢复策略已设置');
+  try {
+    // 使用 node-windows 注册服务（正确处理路径引号）
+    const Service = require('node-windows').Service;
+    const svc = new Service({
+      name: SERVICE_NAME,
+      description: 'OpenClaw Guard',
+      script: DAEMON_PATH,
+      nodeOptions: ['--harmony', '--max_old_space_size=4096']
+    });
+
+    svc.on('install', () => {
+      console.log('[postinstall] 服务注册成功，正在启动...');
+      svc.start();
+    });
+
+    svc.on('start', () => {
+      console.log('[postinstall] 服务已启动');
     });
 
-    // 启动服务
-    exec(`net start "${SERVICE_NAME}"`, (err, stdout, stderr) => {
-      if (err) {
-        console.error(`[postinstall] 启动服务失败: ${err.message}`);
-        console.error(`[postinstall] stdout: ${stdout}`);
-        console.error(`[postinstall] stderr: ${stderr}`);
-      } else {
-        console.log('[postinstall] 服务已启动');
-      }
+    svc.on('error', (err) => {
+      console.error(`[postinstall] 服务错误: ${err.message}`);
     });
-  });
+
+    svc.on('alreadyinstalled', () => {
+      console.log('[postinstall] 服务已存在，尝试启动...');
+      svc.start();
+    });
+
+    svc.install();
+  } catch (err) {
+    console.error(`[postinstall] 注册服务异常: ${err.message}`);
+  }
 }
 
 // 主逻辑
@@ -99,5 +91,5 @@ if (isGlobalInstall()) {
   console.log('[postinstall] 准备自动注册服务...');
   installAndStartService();
 } else {
-  console.log('[postinstall] 本地安装模式，跳过自动注册服务');
+  console.log('[postinstall] 本地安装模式，跳过自动注册');
 }

package/scripts/pre-uninstall.js

@@ -2,15 +2,26 @@
  * npm preuninstall 钩子
  * 在卸载旧版本前停止并删除 Windows 服务，释放文件锁
  */
+const path = require('path');
 const { execSync } = require('child_process');
 
 const SERVICES = ['SilentNodeService', 'claw-subagent-service'];
+const DAEMON_PATH = path.join(__dirname, '..', 'service', 'daemon.js');
 
 if (process.platform === 'win32') {
   for (const name of SERVICES) {
     try {
       execSync(`net stop "${name}" 2>nul`, { stdio: 'ignore', timeout: 10000 });
     } catch (e) {}
+
+    // 使用 node-windows 卸载服务（删除 wrapper 文件，释放文件锁）
+    try {
+      const Service = require('node-windows').Service;
+      const svc = new Service({ name, script: DAEMON_PATH });
+      svc.uninstall();
+    } catch (e) {}
+
+    // 兜底 - 使用 sc.exe 删除服务
     try {
       execSync(`sc.exe delete "${name}" 2>nul`, { stdio: 'ignore', timeout: 10000 });
     } catch (e) {}

package/service/modules/service-manager.js

@@ -155,25 +155,44 @@ class ServiceManager {
     }
   }
 
-  // Windows 服务安装（使用 sc 命令，避免 node-windows 在包目录生成被锁定的 wrapper）
+  // Windows 服务安装（使用 node-windows，正确处理路径引号）
   async installWindows() {
-    // sc.exe binPath 格式：外层引号包裹整个值，内层路径用转义引号
-    const binPath = `\\"${process.execPath}\\" \\"${this.scriptPath}\\"`;
+    return new Promise((resolve, reject) => {
+      try {
+        const Service = require('node-windows').Service;
+        const svc = new Service({
+          name: this.serviceName,
+          description: this.serviceDesc,
+          script: this.scriptPath,
+          nodeOptions: ['--harmony', '--max_old_space_size=4096']
+        });
 
-    // 先停止并删除旧服务（避免文件锁导致更新失败）
-    try { await this.execCommand(`net stop "${this.serviceName}" 2>nul`); } catch (e) {}
-    try { await this.execCommand(`sc.exe delete "${this.serviceName}" 2>nul`); } catch (e) {}
+        svc.on('install', () => {
+          this.log?.info('[ServiceManager] Windows 服务注册成功');
+          svc.start();
+        });
 
-    const createCmd = `sc.exe create "${this.serviceName}" binPath= "${binPath}" start= auto displayname= "${this.serviceDesc}"`;
-    this.log?.info(`[ServiceManager] 执行: ${createCmd}`);
-    await this.execCommand(createCmd);
-    this.log?.info('[ServiceManager] Windows 服务注册成功');
+        svc.on('start', () => {
+          this.log?.info('[ServiceManager] Windows 服务已启动');
+          resolve(true);
+        });
 
-    // 启动服务
-    await this.execCommand(`net start "${this.serviceName}"`);
-    this.log?.info('[ServiceManager] Windows 服务已启动');
+        svc.on('error', (err) => {
+          this.log?.error(`[ServiceManager] Windows 服务安装失败: ${err.message}`);
+          reject(err);
+        });
 
-    return true;
+        svc.on('alreadyinstalled', () => {
+          this.log?.info('[ServiceManager] 服务已存在，尝试启动...');
+          svc.start();
+        });
+
+        svc.install();
+      } catch (err) {
+        this.log?.error(`[ServiceManager] 安装异常: ${err.message}`);
+        reject(err);
+      }
+    });
   }
 
   // Linux 服务安装 (systemd)

package/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.0.17",
-  "updatedAt": "2026-04-30T06:30:00.000Z"
+  "version": "0.0.18",
+  "updatedAt": "2026-04-30T07:00:00.000Z"
 }