hunter-mate 0.1.15 → 0.1.17

package/dist/commands/record.js

@@ -1,56 +0,0 @@
-import { Command } from 'commander';
-import * as fs from 'fs';
-import axios from 'axios';
-import { v4 as uuidv4 } from 'uuid';
-import { loadConfig } from '../config.js';
-import { getToken } from '../keychain.js';
-import { ensureCacheDir } from '../cache/db.js';
-import { printCommandError } from '../utils/command-error.js';
-export async function runRecordTranscript(filePath, options) {
-    const config = loadConfig();
-    const token = await getToken();
-    const headers = token ? { Authorization: `UTOKEN ${token}` } : {};
-    if (!fs.existsSync(filePath)) {
-        throw new Error(`文件不存在: ${filePath}`);
-    }
-    const transcript = fs.readFileSync(filePath, 'utf-8');
-    ensureCacheDir();
-    const res = await axios.post(`${config.serverUrl}/communication-records`, {
-        externalId: uuidv4(),
-        type: options.type || 'call',
-        transcript,
-        personId: options.personId ? parseInt(options.personId, 10) : undefined,
-        jobCaseId: options.jobCaseId ? parseInt(options.jobCaseId, 10) : undefined,
-    }, { headers, proxy: false });
-    return res.data;
-}
-export function runRecordCall(audioFile) {
-    return { audioFile, note: 'STT 处理待接入（本地 faster-whisper 或云端 Whisper API）。' };
-}
-export const recordCommand = new Command('record')
-    .description('沟通记录/录音归档');
-recordCommand
-    .command('transcript <file>')
-    .description('上传转写文本并生成沟通记录草稿')
-    .option('--type <type>', '记录类型(call/wechat/email/audio/meeting)', 'call')
-    .option('--personId <id>', '关联人才 ID')
-    .option('--jobCaseId <id>', '关联 JobCase ID')
-    .action(async (filePath, options) => {
-    try {
-        const data = await runRecordTranscript(filePath, options);
-        console.log(`已创建沟通记录草稿: ${data.id} (${data.externalId})`);
-        console.log('请使用本地 LLM 对转写文本做 NER/摘要/实体链接后确认归档。');
-    }
-    catch (err) {
-        await printCommandError('record:upload-failed', err);
-        process.exit(1);
-    }
-});
-recordCommand
-    .command('call <audioFile>')
-    .description('上传音频文件（MVP 阶段仅保存路径，STT 由本地或云端后续处理）')
-    .action((audioFile) => {
-    const result = runRecordCall(audioFile);
-    console.log(`音频文件已记录: ${result.audioFile}`);
-    console.log(result.note);
-});

package/dist/commands/report.d.ts

@@ -1,7 +0,0 @@
-import { Command } from 'commander';
-export interface ReportSalesOptions {
-    name?: string;
-    industry?: string;
-}
-export declare function runReportSales(customerId: string, options: ReportSalesOptions): Promise<any>;
-export declare const reportCommand: Command;

package/dist/commands/report.js

@@ -1,48 +0,0 @@
-import { Command } from 'commander';
-import axios from 'axios';
-import { loadConfig } from '../config.js';
-import { getToken } from '../keychain.js';
-import { printCommandError } from '../utils/command-error.js';
-export async function runReportSales(customerId, options) {
-    const config = loadConfig();
-    const token = await getToken();
-    const headers = token ? { Authorization: `UTOKEN ${token}` } : {};
-    const res = await axios.get(`${config.serverUrl}/reports/sales/${encodeURIComponent(customerId)}`, {
-        headers,
-        params: { name: options.name, industry: options.industry },
-        proxy: false,
-    });
-    return res.data;
-}
-export const reportCommand = new Command('report')
-    .description('生成报告');
-reportCommand
-    .command('sales <customerId>')
-    .description('生成 BD 销售方案报告')
-    .option('--name <name>', '客户名称')
-    .option('--industry <industry>', '行业')
-    .action(async (customerId, options) => {
-    try {
-        const data = await runReportSales(customerId, options);
-        console.log(`# BD 销售方案报告：${data.customerName}`);
-        console.log(`\n## 客户信息`);
-        console.log(`- 客户 ID: ${data.customerId}`);
-        console.log(`- 行业: ${data.industry || '未指定'}`);
-        console.log(`\n## 历史相似客户案例`);
-        for (const c of data.similarCustomers || []) {
-            console.log(`- ${c.name}（${c.industry}）成单数：${c.dealCount} — ${c.notes}`);
-        }
-        console.log(`\n## 可匹配人才池`);
-        const pool = data.talentPool || {};
-        console.log(`- 总数：${pool.count || 0}`);
-        if (pool.error) {
-            console.log(`- 人才数据获取失败：${pool.error}`);
-        }
-        console.log(`\n## 推荐方案`);
-        console.log('> 请使用本地 LLM 基于以上原始数据生成最终销售方案与交付节奏。');
-    }
-    catch (err) {
-        await printCommandError('report:generate-failed', err);
-        process.exit(1);
-    }
-});

package/dist/commands/search.d.ts

@@ -1,14 +0,0 @@
-import { Command } from 'commander';
-export interface SearchOptions {
-    filter?: string;
-    keyword?: string;
-    areaId?: string;
-    postId?: string;
-    nationalityId?: string;
-    page?: string;
-    limit?: string;
-    source?: string;
-    top?: string;
-}
-export declare function runSearch(options: SearchOptions): Promise<any>;
-export declare const searchCommand: Command;

package/dist/commands/search.js

@@ -1,46 +0,0 @@
-import { Command } from 'commander';
-import axios from 'axios';
-import { loadConfig } from '../config.js';
-import { getToken } from '../keychain.js';
-import { i18n } from '../i18n/index.js';
-import { printCommandError } from '../utils/command-error.js';
-export async function runSearch(options) {
-    const config = loadConfig();
-    const token = await getToken();
-    const params = {
-        keyword: options.keyword || options.filter,
-        areaId: options.areaId,
-        postId: options.postId,
-        nationalityId: options.nationalityId,
-        page: options.page,
-        limit: options.limit || options.top,
-        source: options.source,
-    };
-    const res = await axios.get(`${config.serverUrl}/search/talent`, {
-        headers: token ? { Authorization: `UTOKEN ${token}` } : {},
-        params,
-        proxy: false,
-    });
-    return res.data;
-}
-export const searchCommand = new Command('search')
-    .description(i18n.t('search.description'))
-    .option('--filter <filter>', i18n.t('search.filter'))
-    .option('--keyword <keyword>', '搜索关键词')
-    .option('--areaId <areaId>', '现居地 ID')
-    .option('--postId <postId>', '职位 ID')
-    .option('--nationalityId <nationalityId>', '国籍 ID')
-    .option('--page <n>', '页码', '1')
-    .option('--limit <n>', '每页数量', '10')
-    .option('--source <sources>', i18n.t('search.source'), 'u_person')
-    .option('--top <n>', i18n.t('search.top'), '10')
-    .action(async (options) => {
-    try {
-        const data = await runSearch(options);
-        console.log(JSON.stringify(data, null, 2));
-    }
-    catch (err) {
-        await printCommandError('search:failed', err);
-        process.exit(1);
-    }
-});

package/dist/commands/server.d.ts

@@ -1,35 +0,0 @@
-import { Command } from 'commander';
-type StartLock = 'acquired' | 'busy' | 'stolen';
-/** FID-093:导出供单测覆盖竞态/残留锁语义 */
-export declare function acquireStartLock(): StartLock;
-/**
- * server.log 无界增长曾达 800M+ 挤占用户磁盘(FID-068)。
- * 后台 daemon 启动前按大小轮转:超过 HM_LOG_MAX_BYTES(默认 50MB)时
- * server.log → server.log.1 → …保留最近 LOG_KEEP_FILES 份,最旧丢弃。
- * 纯 fs 实现,Windows 兼容(rename 前先清目标,Windows 不允许覆盖已有文件)。
- */
-export declare function rotateLogIfNeeded(logFile: string, maxBytes?: number, keep?: number): boolean;
-declare function tryReadPid(): number | null;
-export { tryReadPid };
-/** 定位 server 包根（dist 优先，ts-node 开发模式兜底）；找不到返回 null */
-export declare function findServerRoot(): string | null;
-/** 探活:server /health 是否可访问(短超时,永不 throw)。导出供 version.ts 重启编排复核 */
-export declare function probeServerHealth(url: string, timeoutMs?: number): Promise<boolean>;
-/** 对应 ChromePilot start: 启动本地 NestJS Server（提供 REST + WebSocket + SPA） */
-export declare function runStart(opts: {
-    port?: number;
-    host?: string;
-    foreground?: boolean;
-}): Promise<{
-    started: boolean;
-    pid: number | null;
-    url: string;
-    msg: string;
-}>;
-export declare function runStop(): Promise<{
-    stopped: boolean;
-    pid: number | null;
-    msg: string;
-}>;
-export declare const startCommand: Command;
-export declare const stopCommand: Command;

package/dist/commands/server.js

@@ -1,471 +0,0 @@
-import { Command } from 'commander';
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'node:url';
-import { spawn } from 'child_process';
-import { loadConfig, saveConfig, resolveDataDir } from '../config.js';
-import { killGracefullySync } from '../utils/proc.js';
-import { findBundledAssets } from '../bundled-assets.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-/** server.pid 等运行时文件随数据目录走(FID-071:dataDir 可配置后 server 状态文件一并迁移) */
-const PID_FILE = () => path.join(resolveDataDir(), 'server.pid');
-const LOG_FILE = () => PID_FILE().replace(/server\.pid$/, 'server.log');
-const WATCHDOG_PID_FILE = () => PID_FILE().replace(/server\.pid$/, 'watchdog.pid');
-/**
- * FID-093:启动单飞锁。N 个 CLI 进程并发 auto-start(如多个 agent 同时跑
- * extension 命令)时,旧逻辑各自 spawn watchdog——即便 watchdog 单例加固后
- * 多实例会被拒,也会留下一地被误写的 pid 文件与误导性的"启动失败"输出。
- * 持锁者完成 spawn + health 探测期间,其他进程改为等待并复用结果。
- * 锁残留(持锁进程崩溃)按 mtime 判 stale 抢占。
- */
-const START_LOCK_FILE = () => path.join(resolveDataDir(), 'server-start.lock');
-const START_LOCK_STALE_MS = 90_000;
-/** FID-093:导出供单测覆盖竞态/残留锁语义 */
-export function acquireStartLock() {
-    const write = () => {
-        try {
-            const fd = fs.openSync(START_LOCK_FILE(), 'wx'); // 原子 O_CREAT|O_EXCL
-            try {
-                fs.writeFileSync(fd, String(process.pid));
-            }
-            finally {
-                fs.closeSync(fd);
-            }
-            return true;
-        }
-        catch {
-            return false;
-        }
-    };
-    if (write())
-        return 'acquired';
-    try {
-        if (Date.now() - fs.statSync(START_LOCK_FILE()).mtimeMs > START_LOCK_STALE_MS) {
-            fs.unlinkSync(START_LOCK_FILE());
-            if (write())
-                return 'stolen';
-        }
-    }
-    catch { /* 竞态:他人同时清理/占用,让出 */ }
-    return 'busy';
-}
-function releaseStartLock() {
-    try {
-        fs.unlinkSync(START_LOCK_FILE());
-    }
-    catch { /* ignore */ }
-}
-function watchdogAlive(pid) {
-    if (!pid)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function tryReadPidFile(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 cleanPidFile(file) {
-    try {
-        fs.unlinkSync(file);
-    }
-    catch { /* ignore */ }
-}
-const LOG_MAX_BYTES = () => Number(process.env.HM_LOG_MAX_BYTES || 50 * 1024 * 1024);
-const LOG_KEEP_FILES = 3;
-/**
- * server.log 无界增长曾达 800M+ 挤占用户磁盘(FID-068)。
- * 后台 daemon 启动前按大小轮转:超过 HM_LOG_MAX_BYTES(默认 50MB)时
- * server.log → server.log.1 → …保留最近 LOG_KEEP_FILES 份,最旧丢弃。
- * 纯 fs 实现,Windows 兼容(rename 前先清目标,Windows 不允许覆盖已有文件)。
- */
-export function rotateLogIfNeeded(logFile, maxBytes = LOG_MAX_BYTES(), keep = LOG_KEEP_FILES) {
-    try {
-        if (!fs.existsSync(logFile))
-            return false;
-        if (fs.statSync(logFile).size <= maxBytes)
-            return false;
-        for (let i = keep - 1; i >= 1; i--) {
-            const src = `${logFile}.${i}`;
-            const dest = `${logFile}.${i + 1}`;
-            if (!fs.existsSync(src))
-                continue;
-            try {
-                fs.unlinkSync(dest);
-            }
-            catch { /* dest 不存在时忽略 */ }
-            fs.renameSync(src, dest);
-        }
-        fs.renameSync(logFile, `${logFile}.1`);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function tryReadPid() {
-    const pid = tryReadPidFile(PID_FILE());
-    if (pid)
-        return pid;
-    cleanPidFile(PID_FILE());
-    return null;
-}
-export { tryReadPid };
-/** 定位 server 包根（dist 优先，ts-node 开发模式兜底）；找不到返回 null */
-export function findServerRoot() {
-    // dev/monorepo 模式优先用原始 packages/server，避免复制到 assets 后因 node_modules 解析失败
-    const monorepoCandidates = [
-        path.resolve(__dirname, '../../../server/dist/main.js'),
-        path.resolve(__dirname, '../../../server/src/main.ts'),
-    ];
-    for (const c of monorepoCandidates) {
-        if (fs.existsSync(c))
-            return path.dirname(path.dirname(c));
-    }
-    // fallback:bundled-assets(npm 安装模式:dist/assets/server/main.js 已存在)
-    const bundled = findBundledAssets();
-    if (bundled) {
-        return path.dirname(bundled.serverEntry);
-    }
-    return null;
-}
-/** 探活:server /health 是否可访问(短超时,永不 throw)。导出供 version.ts 重启编排复核 */
-export async function probeServerHealth(url, timeoutMs = 1500) {
-    try {
-        const res = await fetch(`${url}/health`, { signal: AbortSignal.timeout(timeoutMs) });
-        return res.ok;
-    }
-    catch {
-        return false;
-    }
-}
-/** 从 config.serverUrl 解析默认端口(与 runStart 逻辑一致) */
-function defaultPortFromConfig(serverUrl) {
-    return new URL(serverUrl).port ? Number(new URL(serverUrl).port) : 34570;
-}
-/** 对应 ChromePilot start: 启动本地 NestJS Server（提供 REST + WebSocket + SPA） */
-export async function runStart(opts) {
-    const config = loadConfig();
-    const defaultPort = defaultPortFromConfig(config.serverUrl);
-    const port = opts.port ?? defaultPort;
-    const host = opts.host ?? '127.0.0.1';
-    const url = `http://${host}:${port}`;
-    // 启动过程中的告警说明(会拼进最终返回 msg,保证用户看得见)
-    const notes = [];
-    // FID-093 单飞:另一进程正在启动时等待复用,不再并发起 watchdog
-    const lock = acquireStartLock();
-    if (lock === 'busy') {
-        const deadline = Date.now() + 35_000;
-        while (Date.now() < deadline) {
-            await new Promise((r) => setTimeout(r, 1000));
-            if (await probeServerHealth(url)) {
-                return {
-                    started: true,
-                    pid: null,
-                    url,
-                    msg: 'server 已由另一个 hunter-mate 进程启动完成(启动锁被持有,本次复用其结果)',
-                };
-            }
-        }
-        return {
-            started: false,
-            pid: null,
-            url,
-            msg: '另一个 hunter-mate 进程持有 server 启动锁,且 35s 内 /health 未就绪。请执行 hunter-mate doctor 排查。',
-        };
-    }
-    if (lock === 'stolen') {
-        notes.push('⚠ 检测到残留的 server-start.lock(持有进程疑似崩溃),已按 stale 抢占继续启动');
-    }
-    try {
-        return await runStartLocked(opts, { url, port, host, notes });
-    }
-    finally {
-        releaseStartLock();
-    }
-}
-/** 单飞锁内的实际启动逻辑(锁外逻辑见 runStart) */
-async function runStartLocked(opts, ctx) {
-    const { url, port, host, notes } = ctx;
-    const config = loadConfig();
-    const existing = tryReadPid();
-    if (existing) {
-        // pid 文件存在 ≠ server 存活。pid 可能被系统中其他进程复用
-        // (Windows 现场:残留 node.exe 复用了 pid → 误判 already running,
-        //  server 实际从未被拉起,日志停在旧时间戳,用户无任何感知)。
-        // 因此必须先 /health 探活再决定是否走"已在运行"分支。
-        if (await probeServerHealth(url)) {
-            // 已在运行: 先做版本一致性检测（磁盘版本 vs 运行版本，server 不一致则自动重启）
-            // 动态 import 避免与 version.ts 的循环依赖（version.ts 静态引入本文件的 runStart/runStop）
-            const { ensureRuntimeConsistency } = await import('../version.js');
-            const report = await ensureRuntimeConsistency({ force: true });
-            if (report.actions.serverRestart && report.performed.length) {
-                return { started: true, pid: null, url, msg: report.performed.join('; ') };
-            }
-            return { started: false, pid: existing, url, msg: `server already running (pid=${existing})` };
-        }
-        // FID-093:探活失败≠server 死了。机器抖动(构建/多实例抢 CPU)会让单次
-        // /health 超时,旧逻辑直接当 stale 清文件重拉 → 活 server 被孤儿化,
-        // 新实例 EADDRINUSE 崩溃循环(2026-09-10 23:13 实机复现)。先给 grace 窗口
-        // 复探:进程仍存活且 /health 恢复 → 按已运行处理,绝不双实例。
-        let recovered = false;
-        const graceDeadline = Date.now() + 10_000;
-        while (Date.now() < graceDeadline) {
-            await new Promise((r) => setTimeout(r, 1000));
-            const pidAlive = (() => {
-                try {
-                    process.kill(existing, 0);
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            })();
-            if (!pidAlive)
-                break; // 真死了,走正常启动
-            if (await probeServerHealth(url)) {
-                recovered = true;
-                break;
-            }
-        }
-        if (recovered) {
-            return {
-                started: false,
-                pid: existing,
-                url,
-                msg: `server already running (pid=${existing}; /health 曾短暂无响应,grace 窗口内恢复,未拉起新实例)`,
-            };
-        }
-        // stale pid:进程号存活但 grace 后仍无响应(疑似僵死或被其他进程复用)。清理后继续启动,
-        // 不 kill —— 那个进程可能属于别的程序(误杀 foreign 进程红线);
-        // 若它其实占了 34570 端口,新实例会因 EADDRINUSE 显式崩溃退出,不静默。
-        notes.push(`⚠ 检测到 stale server.pid (pid=${existing}):该进程存活但 ${url}/health 在 10s grace 窗口内持续无响应,` +
-            `疑似 pid 被其他进程复用,已忽略并继续启动`);
-        cleanPidFile(PID_FILE());
-    }
-    // server 入口: bundled 模式下 <cli>/dist/assets/server/main.js；monorepo 下 packages/server/dist/main.js 或 src/main.ts(开发模式 ts-node)
-    const serverRoot = findServerRoot();
-    let entry = null;
-    if (serverRoot) {
-        const candidates = [
-            path.join(serverRoot, 'main.js'),
-            path.join(serverRoot, 'dist', 'main.js'),
-            path.join(serverRoot, 'src', 'main.ts'),
-        ];
-        for (const c of candidates) {
-            if (fs.existsSync(c)) {
-                entry = c;
-                break;
-            }
-        }
-    }
-    if (!entry) {
-        return {
-            started: false,
-            pid: null,
-            url,
-            msg: `✗ hunter-mate 启动失败:本 npm 包未包含 server 资产。\n` +
-                `  - 若你正在 monorepo 开发,先执行 pnpm --filter @hunter-mate/server build 让 server dist 进入 packages/cli/dist/assets/server/。\n` +
-                `  - 若你已 npm install -g hunter-mate,完整终端分发包需联系 Hiredchina IT 索要(含 server + Chrome 扩展)。\n` +
-                `  - 临时绕过:单独启动 NestJS server,把 serverUrl 指向它(hunter-mate config serverUrl ${url})。`,
-        };
-    }
-    const env = {
-        ...process.env,
-        PORT: String(port),
-        HOST: host,
-        // FID-071: server 所有数据落点(db/备份/runtime.json/artifacts)由 CLI 的数据目录决定
-        HM_DATA_DIR: resolveDataDir(),
-    };
-    const nodeArgs = [];
-    if (entry.endsWith('.ts')) {
-        // ts-node 模式
-        nodeArgs.push('--require', 'ts-node/register');
-    }
-    let child;
-    if (opts.foreground) {
-        child = spawn(process.execPath, [...nodeArgs, entry], {
-            stdio: 'inherit',
-            env,
-        });
-        return { started: true, pid: child.pid ?? null, url, msg: `server running in foreground (pid=${child.pid}) on ${url}` };
-    }
-    const logDir = path.dirname(LOG_FILE());
-    if (!fs.existsSync(logDir))
-        fs.mkdirSync(logDir, { recursive: true });
-    // 后台 daemon 启动前轮转 server.log(超 50MB 保留 3 份),防止无界增长挤占磁盘
-    rotateLogIfNeeded(LOG_FILE());
-    // 后台模式由独立 watchdog 进程托管 server,实现崩溃后自动重启
-    const watchdogEntry = path.resolve(__dirname, '../watchdog.js');
-    if (!fs.existsSync(watchdogEntry)) {
-        return {
-            started: false,
-            pid: null,
-            url,
-            msg: `✗ 启动失败:找不到 watchdog 入口 ${watchdogEntry},请先执行 pnpm --filter @hunter-mate/cli build`,
-        };
-    }
-    const watchdogEnv = {
-        ...process.env,
-        HM_SERVER_ENTRY: entry,
-        HM_SERVER_LOG: LOG_FILE(),
-        HM_SERVER_NODE_ARGS: nodeArgs.join(','),
-        HM_DATA_DIR: resolveDataDir(),
-        PORT: String(port),
-        HOST: host,
-    };
-    const wd = spawn(process.execPath, [watchdogEntry], {
-        stdio: 'ignore',
-        env: watchdogEnv,
-        detached: true,
-        windowsHide: true,
-    });
-    wd.unref();
-    // FID-093:不再由 CLI 覆写 watchdog.pid——watchdog 进程原子自注册(acquireWatchdogLock),
-    // 并发启动的败者若覆写会把胜者 pid 覆盖成将死进程,runStop 从此找不到活 watchdog。
-    // 就绪探测改为直接探 spawn 出的 watchdog 进程是否存活(比 pid 文件更直接)。
-    // 等待 server health 就绪。窗口给足:NestJS 全量路由映射 + TypeORM schema 同步
-    // 在慢机/Windows 上实测 10-15s,原 8s 会在 route mapping 阶段误报"未就绪"
-    // (server 实际 3 秒后就绪,watchdog 会保活,误报只会误导用户)。
-    const probeDeadlineMs = 30_000;
-    const deadline = Date.now() + probeDeadlineMs;
-    let ready = false;
-    while (Date.now() < deadline) {
-        await new Promise((r) => setTimeout(r, 500));
-        try {
-            const res = await fetch(`${url}/health`, { signal: AbortSignal.timeout(800) });
-            if (res.ok) {
-                ready = true;
-                break;
-            }
-        }
-        catch { /* server 尚未监听,继续轮询 */ }
-        // watchdog 自身退出说明启动参数/入口有问题(含单例锁被占,另一 watchdog 在保活)
-        if (!watchdogAlive(wd.pid ?? null))
-            break;
-    }
-    if (!ready) {
-        let tail = '';
-        try {
-            const log = fs.readFileSync(LOG_FILE(), 'utf-8');
-            tail = log.split('\n').slice(-30).join('\n').trim();
-        }
-        catch { /* ignore */ }
-        cleanPidFile(WATCHDOG_PID_FILE());
-        return {
-            started: false,
-            pid: wd.pid ?? null,
-            url,
-            msg: (notes.length ? notes.join('\n') + '\n' : '') +
-                `✗ server watchdog 启动后 ${probeDeadlineMs / 1000}s 内未就绪(pid=${wd.pid}),日志尾部:\n${tail || '(server.log 为空)'}\n` +
-                `排障: hunter-mate doctor 或 TROUBLESHOOTING.md#server-启动即崩abi`,
-        };
-    }
-    // 持久化: 如果 port 变了就写回 config（避免下次 serverUrl 不对）
-    try {
-        const u = new URL(config.serverUrl);
-        if (Number(u.port) !== port) {
-            u.port = String(port);
-            u.hostname = host;
-            saveConfig({ serverUrl: u.origin });
-        }
-    }
-    catch { /* ignore */ }
-    return {
-        started: true,
-        pid: wd.pid ?? null,
-        url,
-        msg: (notes.length ? notes.join('\n') + '\n' : '') +
-            `server watchdog started (pid=${wd.pid}) on ${url} — logs: ${LOG_FILE()}`,
-    };
-}
-export async function runStop() {
-    const config = loadConfig();
-    const url = `http://127.0.0.1:${defaultPortFromConfig(config.serverUrl)}`;
-    // kill 任何进程前先 /health 确认它真的是我们的 server。
-    // pid 文件可能被复用(Windows 现场:残留 node.exe 占用 pid),误杀 foreign 进程不可接受。
-    const healthy = await probeServerHealth(url);
-    // 优先停止 watchdog,让它去停止子 server
-    const wdPid = tryReadPidFile(WATCHDOG_PID_FILE());
-    if (wdPid) {
-        if (!healthy) {
-            // server 不响应时不杀 watchdog pid(可能已被其他进程复用)——红线不动;
-            // FID-093:也不清 pid 文件——进程可能还活着,清了等于孤儿化注册表,
-            // 后续 auto-start 会再拉一个实例造成双 server(EADDRINUSE 崩溃循环)。
-            // 文件留在原地,runStart 的 grace 复探会正确处理。
-            return {
-                stopped: false,
-                pid: wdPid,
-                msg: `✗ server 无响应(${url}/health 不可达),watchdog pid=${wdPid} 未杀(疑似 stale pid,` +
-                    `可能已被其他进程复用)。pid 文件保留以便复探;如确认是僵死进程请手工 kill`,
-            };
-        }
-        const ok = killGracefullySync(wdPid);
-        cleanPidFile(WATCHDOG_PID_FILE());
-        if (ok) {
-            // 给 watchdog 一点时间清理 server.pid
-            try {
-                const pid = tryReadPid();
-                if (pid) {
-                    killGracefullySync(pid);
-                    cleanPidFile(PID_FILE());
-                }
-            }
-            catch { /* ignore */ }
-            return { stopped: true, pid: wdPid, msg: `server watchdog stopped (pid=${wdPid})` };
-        }
-    }
-    // fallback:直接停止 server
-    const pid = tryReadPid();
-    if (!pid)
-        return { stopped: false, pid: null, msg: 'no server.pid found or process dead' };
-    if (!healthy) {
-        // pid 存活但 server 不响应:不 kill(可能复用了别人的 pid)红线不动;
-        // FID-093:同样保留 pid 文件(进程可能还活着,清了会孤儿化注册表)
-        return {
-            stopped: false,
-            pid,
-            msg: `✗ pid=${pid} 存活但 server 无响应,未发送 kill 信号(疑似 stale pid,` +
-                `可能属于其他进程)。pid 文件保留以便复探;如确认是僵死 server 请手工 kill`,
-        };
-    }
-    const ok = killGracefullySync(pid);
-    if (!ok) {
-        return { stopped: false, pid, msg: `failed to signal ${pid}` };
-    }
-    cleanPidFile(PID_FILE());
-    return { stopped: true, pid, msg: `server stopped (pid=${pid})` };
-}
-export const startCommand = new Command('start')
-    .description('启动本地 NestJS server（REST + WebSocket + SPA），对应 chromepilot start')
-    .option('-p, --port <port>', 'server 端口，默认从 config.serverUrl 解析或 34570')
-    .option('-h, --host <host>', '绑定 host，默认 127.0.0.1', '127.0.0.1')
-    .option('-f, --foreground', '前台运行（默认后台 daemon，写 server.pid + server.log）')
-    .action(async (opts) => {
-    const r = await runStart({ port: opts.port ? Number(opts.port) : undefined, host: opts.host, foreground: opts.foreground });
-    console.log(r.msg);
-    if (!r.started && !r.pid)
-        process.exit(1);
-});
-export const stopCommand = new Command('stop')
-    .description('停止本地 server（读 ~/.hunter-mate/server.pid 并 SIGTERM）')
-    .action(async () => {
-    const r = await runStop();
-    console.log(r.msg);
-    if (!r.stopped && r.pid)
-        process.exit(1);
-});