hunter-mate 0.1.2 → 0.1.4

package/dist/utils/proc.js

@@ -0,0 +1,81 @@
+import { spawnSync } from "node:child_process";
+/**
+ * Synchronous variant — useful for `stop` commands that cannot easily be
+ * turned into async functions. Returns `true` iff the first signal
+ * attempt appeared to succeed (status 0 from `taskkill`, or `SIGTERM`
+ * delivered without throwing on POSIX).
+ */
+export function killGracefullySync(pid) {
+    if (process.platform === "win32") {
+        return (spawnSync("taskkill", ["/pid", String(pid), "/T"], { encoding: "utf-8" })
+            .status === 0);
+    }
+    try {
+        process.kill(pid, "SIGTERM");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Async graceful termination.
+ *
+ * On Windows, `process.kill(pid, 'SIGTERM')` is a no-op (Node only supports
+ * `SIGKILL`/`SIGINT`/`SIGQUIT`/etc as process-group signals on POSIX).
+ * `taskkill /pid <pid> /T` without `/F` sends WM_CLOSE to GUI children and
+ * CTRL_BREAK to console children — which NestJS + Next.js turn into a
+ * graceful shutdown through `enableShutdownHooks()`. If the process is
+ * still alive after `graceMs`, we escalate to `/F` (force).
+ *
+ * On POSIX we send SIGTERM, wait `graceMs`, then SIGKILL as a last resort.
+ *
+ * The polling interval (200ms) is intentionally short so the function
+ * returns promptly when the child exits but does not busy-spin.
+ */
+export async function killGracefully(pid, graceMs = 5000) {
+    const deadline = Date.now() + graceMs;
+    const pollGone = async () => {
+        while (Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, 200));
+            try {
+                process.kill(pid, 0);
+            }
+            catch {
+                return true;
+            }
+        }
+        return false;
+    };
+    if (process.platform === "win32") {
+        const r1 = spawnSync("taskkill", ["/pid", String(pid), "/T"], {
+            encoding: "utf-8",
+        });
+        if (r1.status === 0)
+            return "graceful";
+        const out = `${r1.stdout ?? ""}${r1.stderr ?? ""}`;
+        if (/not found|找不到|0x.*找不到/i.test(out))
+            return "esrch";
+        if (await pollGone())
+            return "graceful";
+        const r2 = spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { encoding: "utf-8" });
+        return r2.status === 0 ? "forced" : "error";
+    }
+    // POSIX path
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch (err) {
+        const e = err;
+        return e.code === "ESRCH" ? "esrch" : "error";
+    }
+    if (await pollGone())
+        return "graceful";
+    try {
+        process.kill(pid, "SIGKILL");
+        return "forced";
+    }
+    catch {
+        return "error";
+    }
+}

package/dist/utils/spawn.d.ts

@@ -0,0 +1,19 @@
+import { spawn, spawnSync, type ChildProcess } from "node:child_process";
+type SpawnOptionsAny = Parameters<typeof spawn>[2] & Parameters<typeof spawnSync>[2];
+/**
+ * Cross-platform child_process wrapper.
+ *
+ * On Windows we set `shell: true` so that PATHEXT resolution and `.cmd` /
+ * `.bat` execution work without an explicit path. The `%%` escape keeps
+ * cmd.exe from interpreting `%FOO%` style variable expansions inside the
+ * arguments (Windows expands `%` even inside quoted strings).
+ *
+ * On POSIX we keep the original behavior: direct `execve`, no shell,
+ * no argument transformation — identical to a plain `spawn` call.
+ */
+export declare function spawnSafe(bin: string, args?: readonly string[], opts?: SpawnOptionsAny): ChildProcess;
+/**
+ * Synchronous variant. Same semantics as {@link spawnSafe}.
+ */
+export declare function spawnSyncSafe(bin: string, args?: readonly string[], opts?: SpawnOptionsAny): import("child_process").SpawnSyncReturns<string | NonSharedBuffer>;
+export {};

package/dist/utils/spawn.js

@@ -0,0 +1,60 @@
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * On Windows, PATHEXT is honored by `cmd.exe` but not by Node's `spawn`.
+ * Without this resolver, `spawn("npm", ...)` returns ENOENT because the
+ * real binary is `npm.cmd`. We walk PATH and pick the first extension that
+ * matches an existing file. POSIX behavior is unchanged: return as-is.
+ */
+function resolveBin(bin) {
+    if (process.platform !== "win32")
+        return bin;
+    if (/\.(cmd|bat|exe|com)$/i.test(bin))
+        return bin;
+    const pathEnv = process.env.PATH ?? "";
+    const exts = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";");
+    for (const dir of pathEnv.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const candidate = path.join(dir, bin + ext);
+            try {
+                if (fs.existsSync(candidate))
+                    return candidate;
+            }
+            catch {
+                /* FS errors fall through to the next candidate */
+            }
+        }
+    }
+    return bin;
+}
+/**
+ * Cross-platform child_process wrapper.
+ *
+ * On Windows we set `shell: true` so that PATHEXT resolution and `.cmd` /
+ * `.bat` execution work without an explicit path. The `%%` escape keeps
+ * cmd.exe from interpreting `%FOO%` style variable expansions inside the
+ * arguments (Windows expands `%` even inside quoted strings).
+ *
+ * On POSIX we keep the original behavior: direct `execve`, no shell,
+ * no argument transformation — identical to a plain `spawn` call.
+ */
+export function spawnSafe(bin, args = [], opts = {}) {
+    if (process.platform === "win32") {
+        const escaped = args.map((a) => a.replace(/%/g, "%%"));
+        return spawn(bin, escaped, { ...opts, shell: true });
+    }
+    return spawn(resolveBin(bin), [...args], opts);
+}
+/**
+ * Synchronous variant. Same semantics as {@link spawnSafe}.
+ */
+export function spawnSyncSafe(bin, args = [], opts = {}) {
+    if (process.platform === "win32") {
+        const escaped = args.map((a) => a.replace(/%/g, "%%"));
+        return spawnSync(bin, escaped, { ...opts, shell: true });
+    }
+    return spawnSync(resolveBin(bin), [...args], opts);
+}

package/dist/version.d.ts

@@ -1,6 +1,6 @@
 import { ConsistencyActions, InstalledVersions, SystemVersions } from '@hunter-mate/shared';
 export declare function readInstalledVersions(): InstalledVersions;
-export declare function readRuntimeStateFile(): any;
+export declare function readRuntimeStateFile(): unknown;
 export declare function fetchLiveVersions(timeoutMs?: number): Promise<SystemVersions | null>;
 export declare function decideConsistencyActions(installed: InstalledVersions, live: SystemVersions | null): ConsistencyActions;
 export interface ConsistencyReport {

package/dist/version.js

@@ -1,63 +1,24 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readInstalledVersions = readInstalledVersions;
-exports.readRuntimeStateFile = readRuntimeStateFile;
-exports.fetchLiveVersions = fetchLiveVersions;
-exports.decideConsistencyActions = decideConsistencyActions;
-exports.ensureRuntimeConsistency = ensureRuntimeConsistency;
-exports.shouldCheckNow = shouldCheckNow;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const axios_1 = __importDefault(require("axios"));
-const chalk_1 = __importDefault(require("chalk"));
-const config_1 = require("./config");
-const server_1 = require("./commands/server");
-const extras_1 = require("./commands/extras");
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'crypto';
+import axios from 'axios';
+import chalk from 'chalk';
+import { loadConfig } from './config.js';
+import { runStop, runStart, tryReadPid, findServerRoot } from './commands/server.js';
+import { runReload } from './commands/extras.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 const HOME = () => process.env.HUNTER_MATE_HOME || process.env.HOME || process.env.USERPROFILE || '.';
 const ROOT = () => path.join(HOME(), '.hunter-mate');
 const PLUGINS_DIR = () => path.join(ROOT(), 'plugins');
 const EXTENSION_MANIFEST = () => path.join(ROOT(), 'extension', 'manifest.json');
+const EXTENSION_DIR = () => path.join(ROOT(), 'extension');
 const RUNTIME_FILE = () => path.join(ROOT(), 'runtime.json');
 const LAST_CHECK_FILE = () => path.join(ROOT(), '.last-consistency-check');
 const CHECK_THROTTLE_MS = 60_000;
 // ---------------------------------------------------------------------------
-// 磁盘版本读取（SSOT）
+// 三层指纹工具（version + checksum + mtime/linked）— 与 chromepilot version-manager / server SystemService 算法完全等价
 // ---------------------------------------------------------------------------
 function readJson(file) {
     try {
@@ -67,13 +28,114 @@ function readJson(file) {
         return null;
     }
 }
-function readInstalledVersions() {
+/** 递归目录 SHA-1（文件名+内容）+ 最新 mtime — 与 server SystemService.dirChecksum 字节等价 */
+function dirChecksum(dir) {
+    const hash = createHash('sha1');
+    let latest = 0;
+    function walk(d, rel = '') {
+        try {
+            const entries = fs.readdirSync(d, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+            for (const entry of entries) {
+                const relPath = path.join(rel, entry.name);
+                const full = path.join(d, entry.name);
+                if (entry.isDirectory()) {
+                    walk(full, relPath);
+                }
+                else if (entry.isFile() || entry.isSymbolicLink()) {
+                    try {
+                        const stat = fs.statSync(full);
+                        if (stat.mtimeMs > latest)
+                            latest = stat.mtimeMs;
+                        hash.update(relPath + '\0');
+                        const buf = fs.readFileSync(full);
+                        hash.update(buf);
+                    }
+                    catch {
+                        /* ignore unreadable */
+                    }
+                }
+            }
+        }
+        catch {
+            /* dir missing → empty */
+        }
+    }
+    walk(dir);
+    return { checksum: hash.digest('hex'), latestMtimeMs: latest };
+}
+function inspectArtifact(dir, versionSource) {
+    if (!fs.existsSync(dir))
+        return null;
+    const { checksum, latestMtimeMs } = dirChecksum(dir);
+    let linked = false;
+    try {
+        linked = fs.lstatSync(dir).isSymbolicLink();
+    }
+    catch { /* ignore */ }
+    return {
+        version: versionSource?.version ?? '0.0.0',
+        checksum,
+        latestMtimeMs,
+        linked,
+        rootDir: dir,
+    };
+}
+function resolveLinked(extensionInstallDir, serverEntryPath) {
+    function resolve(target) {
+        if (!fs.existsSync(target))
+            return { linked: false, source: null, target };
+        try {
+            if (fs.lstatSync(target).isSymbolicLink()) {
+                return { linked: true, source: fs.realpathSync(target), target };
+            }
+        }
+        catch { /* ignore */ }
+        return { linked: false, source: null, target };
+    }
+    return {
+        extension: resolve(extensionInstallDir),
+        serverEntry: resolve(serverEntryPath),
+    };
+}
+/** 扫描 CLI 侧（磁盘 SSOT）的 server + extension 两份三层指纹 */
+function computeLocalArtifacts(cliInstalled) {
+    // Server 产物（dist 目录）: findServerRoot 返回 packages/server 包根，dist 是其子目录
+    let serverArtifact = null;
+    const serverRoot = findServerRoot();
+    if (serverRoot) {
+        const distCandidates = [path.join(serverRoot, 'dist'), serverRoot];
+        let serverDist = '';
+        for (const c of distCandidates) {
+            if (fs.existsSync(path.join(c, 'main.js')) || fs.existsSync(path.join(c, 'index.js'))) {
+                serverDist = c;
+                break;
+            }
+        }
+        if (serverDist) {
+            const pkg = readJson(path.join(serverRoot, 'package.json'));
+            serverArtifact = inspectArtifact(serverDist, pkg ?? { version: cliInstalled.server ?? '0.0.0' });
+        }
+    }
+    // Extension 产物（~/.hunter-mate/extension）
+    const extManifest = readJson(EXTENSION_MANIFEST());
+    const extensionArtifact = inspectArtifact(EXTENSION_DIR(), extManifest ?? { version: cliInstalled.extension ?? '0.0.0' });
+    // Linked 判断
+    const serverEntry = serverArtifact
+        ? (fs.existsSync(path.join(serverArtifact.rootDir, 'main.js')) ? path.join(serverArtifact.rootDir, 'main.js') : path.join(serverArtifact.rootDir, 'index.js'))
+        : __filename;
+    const linked = resolveLinked(EXTENSION_DIR(), serverEntry);
+    return { server: serverArtifact, extension: extensionArtifact, linked };
+}
+// ---------------------------------------------------------------------------
+// 磁盘版本读取（SSOT）
+// ---------------------------------------------------------------------------
+export function readInstalledVersions() {
     // CLI 自身: src/version.ts 与 dist/version.js 的上一级都是包根
     const cliPkg = readJson(path.join(__dirname, '..', 'package.json'));
     const cli = cliPkg?.version ?? '0.0.0';
     // Server: 定位 packages/server 包根（与 start 命令同一套候选逻辑）
     let server = null;
-    const serverRoot = (0, server_1.findServerRoot)();
+    const serverRoot = findServerRoot();
     if (serverRoot) {
         const pkg = readJson(path.join(serverRoot, 'package.json'));
         server = pkg?.version ?? null;
@@ -91,18 +153,21 @@ function readInstalledVersions() {
                 plugins[name] = pkg.version;
         }
     }
-    return { cli, server, extension, plugins };
+    const base = { cli, server, extension, plugins };
+    // 三层指纹（CLI 磁盘侧计算；对比时拿 live.bootArtifacts 比）
+    base.artifacts = computeLocalArtifacts({ server, extension });
+    return base;
 }
-function readRuntimeStateFile() {
+export function readRuntimeStateFile() {
     return readJson(RUNTIME_FILE());
 }
 // ---------------------------------------------------------------------------
 // live 运行中版本（来自 server /system/versions）
 // ---------------------------------------------------------------------------
-async function fetchLiveVersions(timeoutMs = 3000) {
-    const config = (0, config_1.loadConfig)();
+export async function fetchLiveVersions(timeoutMs = 3000) {
+    const config = loadConfig();
     try {
-        const res = await axios_1.default.get(`${config.serverUrl}/system/versions`, {
+        const res = await axios.get(`${config.serverUrl}/system/versions`, {
             timeout: timeoutMs,
             proxy: false,
         });
@@ -113,9 +178,9 @@ async function fetchLiveVersions(timeoutMs = 3000) {
     }
 }
 // ---------------------------------------------------------------------------
-// 一致性决策（纯函数，便于测试）
+// 一致性决策（纯函数，便于测试）— 三层指纹：version → checksum → linked_stale
 // ---------------------------------------------------------------------------
-function decideConsistencyActions(installed, live) {
+export function decideConsistencyActions(installed, live) {
     const actions = {
         serverRestart: false,
         pluginsReload: [],
@@ -123,17 +188,34 @@ function decideConsistencyActions(installed, live) {
     };
     if (!live)
         return actions;
-    // server: 磁盘版本 vs 运行版本（磁盘未知时不强制）
+    const local = installed.artifacts ?? null;
+    const boot = live.bootArtifacts ?? null;
+    // ==================== server: 三层 ====================
     if (installed.server !== null &&
         live.server.version !== installed.server) {
         actions.serverRestart = true;
-        actions.serverReason = `running=${live.server.version} disk=${installed.server}`;
+        actions.serverReason = `running=${live.server.version} disk=${installed.server} (version_mismatch)`;
     }
     else if (live.server.needsRestart) {
         actions.serverRestart = true;
         actions.serverReason = 'server self-check marked needsRestart';
     }
-    // 插件: 磁盘版本 vs 已加载版本
+    else if (!actions.serverRestart &&
+        local?.server?.checksum &&
+        boot?.server?.checksum &&
+        local.server.checksum !== boot.server.checksum) {
+        actions.serverRestart = true;
+        actions.serverReason = 'server 产物 checksum 与启动快照不一致（本地重新构建过）(checksum_mismatch)';
+    }
+    else if (!actions.serverRestart &&
+        boot?.linked?.serverEntry.linked === true &&
+        local?.server?.latestMtimeMs &&
+        live.server.latestMtimeMs &&
+        local.server.latestMtimeMs > live.server.latestMtimeMs) {
+        actions.serverRestart = true;
+        actions.serverReason = `server 软链模式下磁盘最新 mtime(${new Date(local.server.latestMtimeMs).toISOString()}) 新于启动快照(linked_stale)`;
+    }
+    // ==================== 插件: 磁盘版本 vs 已加载版本（保留单层逻辑） ====================
     const names = new Set([
         ...Object.keys(installed.plugins),
         ...Object.keys(live.plugins),
@@ -143,13 +225,35 @@ function decideConsistencyActions(installed, live) {
             actions.pluginsReload.push(name);
         }
     }
-    // 浏览器扩展: 磁盘 manifest 版本 vs WS handshake 上报版本
-    if (installed.extension) {
-        actions.extensionReload = live.extensions.some((e) => e.version !== installed.extension);
+    // ==================== extension: 三层 ====================
+    const extVerDiff = installed.extension
+        && live.extensions.length > 0
+        && live.extensions.some((e) => e.version !== installed.extension);
+    const anyExtConnected = live.extensions.length > 0;
+    if (extVerDiff) {
+        actions.extensionReload = true;
+        actions.extensionReason = `running extension versions=[${[...new Set(live.extensions.map((e) => e.version))].join('/')}] != disk=${installed.extension} (version_mismatch)`;
+    }
+    else if (!actions.extensionReload &&
+        anyExtConnected &&
+        local?.extension?.checksum &&
+        boot?.extension?.checksum &&
+        local.extension.checksum !== boot.extension.checksum) {
+        actions.extensionReload = true;
+        actions.extensionReason = 'extension 产物 checksum 与启动快照不一致（改了 manifest/TS/HTML 但未改 package.json 版本）(checksum_mismatch)';
+    }
+    else if (!actions.extensionReload &&
+        anyExtConnected &&
+        boot?.linked?.extension.linked === true &&
+        local?.extension?.latestMtimeMs &&
+        boot?.extension?.latestMtimeMs &&
+        local.extension.latestMtimeMs > boot.extension.latestMtimeMs) {
+        actions.extensionReload = true;
+        actions.extensionReason = `extension 软链模式下磁盘最新 mtime(${new Date(local.extension.latestMtimeMs).toISOString()}) 新于启动快照(linked_stale)`;
     }
     return actions;
 }
-async function ensureRuntimeConsistency(opts = {}) {
+export async function ensureRuntimeConsistency(opts = {}) {
     const performed = [];
     const noOp = (reason) => ({
         checked: false,
@@ -165,9 +269,9 @@ async function ensureRuntimeConsistency(opts = {}) {
     // 2) pid 缺失（用户手动 node dist/main.js 起的 / 旧版 CLI 起的）→
     //    本地地址做快速 HTTP 探测（ECONNREFUSED 即时返回，不拖慢命令）；远程地址维持 pid 闸门
     let live = null;
-    const config = (0, config_1.loadConfig)();
+    const config = loadConfig();
     const isLocal = /\/\/(localhost|127\.0\.0\.1|\[::1\])/i.test(config.serverUrl);
-    if ((0, server_1.tryReadPid)()) {
+    if (tryReadPid()) {
         live = await fetchLiveVersions();
     }
     else if (isLocal) {
@@ -185,7 +289,7 @@ async function ensureRuntimeConsistency(opts = {}) {
     // 1) 插件热重载
     if (actions.pluginsReload.length) {
         try {
-            await axios_1.default.post(`${config.serverUrl}/system/reload-plugins`, { reason: `cli-consistency: ${actions.pluginsReload.join(',')}` }, { timeout: 5000, proxy: false });
+            await axios.post(`${config.serverUrl}/system/reload-plugins`, { reason: `cli-consistency: ${actions.pluginsReload.join(',')}` }, { timeout: 5000, proxy: false });
             performed.push(`plugins reloaded: ${actions.pluginsReload
                 .map((n) => `${n} ${live.plugins[n] ?? '-'}→${installed.plugins[n] ?? '?'}`)
                 .join(', ')}`);
@@ -197,8 +301,8 @@ async function ensureRuntimeConsistency(opts = {}) {
     // 2) server 重启（stop + start）
     if (actions.serverRestart) {
         try {
-            (0, server_1.runStop)();
-            const r = await (0, server_1.runStart)({});
+            runStop();
+            const r = await runStart({});
             performed.push(r.started
                 ? `server restarted (${actions.serverReason}) — new pid=${r.pid}`
                 : `server restart FAILED: ${r.msg}`);
@@ -210,26 +314,24 @@ async function ensureRuntimeConsistency(opts = {}) {
     // 3) 浏览器扩展 reload 广播
     if (actions.extensionReload) {
         try {
-            await (0, extras_1.runReload)(3000);
-            performed.push(`extension reload broadcast (disk=${installed.extension}, running=${[
-                ...new Set(live.extensions.map((e) => e.version)),
-            ].join('/')})`);
+            const r = await runReload(3000);
+            performed.push(`extension reload broadcast: ${actions.extensionReason ?? 'version mismatch'} — broadcast=${r.broadcast}, msg=${r.msg}`);
         }
-        catch {
-            performed.push('extension reload broadcast skipped (no ws clients)');
+        catch (e) {
+            performed.push(`extension reload FAILED: ${e.message}. Tip: chrome://extensions → 点 HunterMate 卡片的刷新图标`);
         }
     }
     markChecked();
     if (opts.verbose && performed.length) {
         for (const line of performed)
-            console.log(chalk_1.default.gray(`  [auto-update] ${line}`));
+            console.log(chalk.gray(`  [auto-update] ${line}`));
     }
     return { checked: true, actions, performed };
 }
 // ---------------------------------------------------------------------------
 // 节流
 // ---------------------------------------------------------------------------
-function shouldCheckNow() {
+export function shouldCheckNow() {
     try {
         const stat = fs.statSync(LAST_CHECK_FILE());
         return Date.now() - stat.mtimeMs > CHECK_THROTTLE_MS;

package/dist/watchdog.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/watchdog.js

@@ -0,0 +1,128 @@
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+const HOME = () => process.env.HUNTER_MATE_HOME || process.env.HOME || process.env.USERPROFILE || '.';
+const ROOT = () => path.join(HOME(), '.hunter-mate');
+const SERVER_PID_FILE = () => path.join(ROOT(), 'server.pid');
+const WATCHDOG_PID_FILE = () => path.join(ROOT(), 'watchdog.pid');
+const CRASH_LOG_FILE = () => path.join(ROOT(), 'server-crash.log');
+function writePid(file, pid) {
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, String(pid));
+    }
+    catch { /* ignore */ }
+}
+function tryReadPid(file) {
+    try {
+        const raw = fs.readFileSync(file, 'utf-8').trim();
+        const pid = Number(raw);
+        if (!pid || !Number.isInteger(pid))
+            return null;
+        process.kill(pid, 0);
+        return pid;
+    }
+    catch {
+        return null;
+    }
+}
+function cleanPid(file) {
+    try {
+        fs.unlinkSync(file);
+    }
+    catch { /* ignore */ }
+}
+function logCrash(code, signal, restartCount) {
+    try {
+        fs.mkdirSync(ROOT(), { recursive: true });
+        const line = `[${new Date().toISOString()}] exit code=${code} signal=${signal} restartCount=${restartCount}\n`;
+        fs.appendFileSync(CRASH_LOG_FILE(), line);
+    }
+    catch { /* ignore */ }
+}
+function parseNodeArgs(raw) {
+    if (!raw)
+        return [];
+    return raw.split(',').filter(Boolean);
+}
+function runWatchdog() {
+    const entry = process.env.HM_SERVER_ENTRY;
+    const logFile = process.env.HM_SERVER_LOG;
+    const nodeArgs = parseNodeArgs(process.env.HM_SERVER_NODE_ARGS);
+    const maxRestartDelayMs = Number(process.env.HM_WATCHDOG_MAX_DELAY_MS || '30000');
+    if (!entry || !logFile) {
+        console.error('[HunterMate watchdog] HM_SERVER_ENTRY and HM_SERVER_LOG are required');
+        process.exit(1);
+    }
+    // 清理残留 pid
+    cleanPid(SERVER_PID_FILE());
+    const existingWatchdog = tryReadPid(WATCHDOG_PID_FILE());
+    if (existingWatchdog && existingWatchdog !== process.pid) {
+        console.error(`[HunterMate watchdog] another watchdog already running (pid=${existingWatchdog})`);
+        process.exit(1);
+    }
+    writePid(WATCHDOG_PID_FILE(), process.pid);
+    let child = null;
+    let restartCount = 0;
+    let restartTimer = null;
+    let stopping = false;
+    function startChild() {
+        if (stopping)
+            return;
+        try {
+            const logFd = fs.openSync(logFile, 'a');
+            const env = { ...process.env };
+            delete env.HM_SERVER_ENTRY;
+            delete env.HM_SERVER_LOG;
+            delete env.HM_SERVER_NODE_ARGS;
+            delete env.HM_WATCHDOG_MAX_DELAY_MS;
+            child = spawn(process.execPath, [...nodeArgs, entry], {
+                stdio: ['ignore', logFd, logFd],
+                env,
+                detached: false,
+                windowsHide: true,
+            });
+            if (child.pid)
+                writePid(SERVER_PID_FILE(), child.pid);
+            child.on('exit', (code, signal) => {
+                try {
+                    fs.closeSync(logFd);
+                }
+                catch { /* ignore */ }
+                if (stopping)
+                    return;
+                logCrash(code ?? null, signal, restartCount);
+                child = null;
+                restartCount++;
+                const delay = Math.min(1000 * Math.pow(2, restartCount), maxRestartDelayMs);
+                restartTimer = setTimeout(startChild, delay);
+            });
+        }
+        catch (err) {
+            console.error('[HunterMate watchdog] failed to start child', err);
+            restartCount++;
+            const delay = Math.min(1000 * Math.pow(2, restartCount), maxRestartDelayMs);
+            restartTimer = setTimeout(startChild, delay);
+        }
+    }
+    function stop() {
+        if (stopping)
+            return;
+        stopping = true;
+        if (restartTimer) {
+            clearTimeout(restartTimer);
+            restartTimer = null;
+        }
+        if (child && !child.killed) {
+            child.kill('SIGTERM');
+        }
+        cleanPid(WATCHDOG_PID_FILE());
+    }
+    process.on('SIGTERM', stop);
+    process.on('SIGINT', stop);
+    process.on('exit', () => {
+        cleanPid(WATCHDOG_PID_FILE());
+    });
+    startChild();
+}
+runWatchdog();