hunter-mate 0.1.8 → 0.1.11

package/dist/commands/server.js

@@ -11,6 +11,61 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 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();
@@ -88,8 +143,8 @@ export function findServerRoot() {
     }
     return null;
 }
-/** 探活:server /health 是否可访问(短超时,永不 throw) */
-async function probeServerHealth(url, timeoutMs = 1500) {
+/** 探活: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;
@@ -111,6 +166,42 @@ export async function runStart(opts) {
     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 可能被系统中其他进程复用
@@ -127,9 +218,42 @@ export async function runStart(opts) {
             }
             return { started: false, pid: existing, url, msg: `server already running (pid=${existing})` };
         }
-        // stale pid:进程号存活但不是我们的 server(或 server 已僵死)。清理后继续启动,
-        // 不 kill —— 那个进程可能属于别的程序(误杀 foreign 进程红线)。
-        notes.push(`⚠ 检测到 stale server.pid (pid=${existing}):该进程存活但 ${url}/health 无响应,` +
+        // 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());
     }
@@ -211,8 +335,9 @@ export async function runStart(opts) {
         windowsHide: true,
     });
     wd.unref();
-    if (wd.pid)
-        fs.writeFileSync(WATCHDOG_PID_FILE(), String(wd.pid));
+    // 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 会保活,误报只会误导用户)。
@@ -229,8 +354,8 @@ export async function runStart(opts) {
             }
         }
         catch { /* server 尚未监听,继续轮询 */ }
-        // watchdog 自身退出说明启动参数/入口有问题
-        if (!tryReadPidFile(WATCHDOG_PID_FILE()))
+        // watchdog 自身退出说明启动参数/入口有问题(含单例锁被占,另一 watchdog 在保活)
+        if (!watchdogAlive(wd.pid ?? null))
             break;
     }
     if (!ready) {
@@ -278,14 +403,15 @@ export async function runStop() {
     const wdPid = tryReadPidFile(WATCHDOG_PID_FILE());
     if (wdPid) {
         if (!healthy) {
-            // server 不响应时不杀 watchdog pid(可能已被其他进程复用),只清理 pid 文件
-            cleanPidFile(WATCHDOG_PID_FILE());
-            cleanPidFile(PID_FILE());
+            // 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`,
+                    `可能已被其他进程复用)。pid 文件保留以便复探;如确认是僵死进程请手工 kill`,
             };
         }
         const ok = killGracefullySync(wdPid);
@@ -308,13 +434,13 @@ export async function runStop() {
     if (!pid)
         return { stopped: false, pid: null, msg: 'no server.pid found or process dead' };
     if (!healthy) {
-        // pid 存活但 server 不响应:不 kill(可能复用了别人的 pid),只清 pid 文件
-        cleanPidFile(PID_FILE());
+        // pid 存活但 server 不响应:不 kill(可能复用了别人的 pid)红线不动;
+        // FID-093:同样保留 pid 文件(进程可能还活着,清了会孤儿化注册表)
         return {
             stopped: false,
             pid,
             msg: `✗ pid=${pid} 存活但 server 无响应,未发送 kill 信号(疑似 stale pid,` +
-                `可能属于其他进程)。已清理 pid 文件;如确认是僵死 server 请手工 kill`,
+                `可能属于其他进程)。pid 文件保留以便复探;如确认是僵死 server 请手工 kill`,
         };
     }
     const ok = killGracefullySync(pid);

package/dist/extension-sync.d.ts

@@ -0,0 +1,35 @@
+/** 定位 CLI 内置 extension dist(npm 包 assets 优先,monorepo 并列路径兜底) */
+export declare function resolveBuiltinExtensionDist(): string | null;
+export interface ExtensionArtifactsCompare {
+    /** 上游 = CLI 包内置产物目录;npm 包缺资产时为 null */
+    source: string | null;
+    /** 下游 = ~/.hunter-mate/extension */
+    target: string;
+    sourceChecksum: string | null;
+    targetChecksum: string | null;
+    sourceVersion: string | null;
+    targetVersion: string | null;
+    /** source 存在且 target 存在且 checksum 不同(上游升级了/下游被改过) */
+    stale: boolean;
+}
+export declare function compareExtensionArtifacts(targetDir?: string): ExtensionArtifactsCompare;
+export interface ExtensionSyncResult {
+    synced: boolean;
+    reason: string;
+    copied: number;
+    removed: number;
+    fromVersion?: string;
+    toVersion?: string;
+}
+/**
+ * 同步内置扩展产物到目标目录。
+ * - source 缺失(monorepo 未构建/npm 包缺资产)→ no-op
+ * - target 缺失 → 默认 no-op(首次安装走 hunter-mate install 引导);
+ *   install 命令传 ensureTarget=true 创建
+ * - target 是软链(dev 模式)→ no-op,保护开发链
+ * - checksum 一致 → no-op;不一致 → 剪枝(删目标多余文件)+复制
+ */
+export declare function syncExtensionArtifacts(opts?: {
+    target?: string;
+    ensureTarget?: boolean;
+}): ExtensionSyncResult;

package/dist/extension-sync.js

@@ -0,0 +1,159 @@
+// extension-sync.ts — CLI 内置扩展产物 ↔ ~/.hunter-mate/extension 同步(Issue #23)
+//
+// 背景:npm 升级 CLI 后,~/.hunter-mate/extension 仍是旧版构建(update 一致性
+// 检查只看"运行中扩展 vs 磁盘",二者同为旧版所以误判"无需 reload")。本模块以
+// CLI 包内置产物(dist/assets/extension)为上游 SSOT,按目录 checksum 比对,
+// 不一致则剪枝+复制,三处接线:
+//   1) npm postinstall(升级 CLI 即自动同步,postinstall.ts)
+//   2) update --apply / 一致性兜底(ensureRuntimeConsistency,先同步再广播 reload)
+//   3) hunter-mate install(复用同一同步逻辑,替代旧的只增不剪 copy)
+//
+// 约束:永不抛异常(调用方含 postinstall,绝不能让 npm install 失败);
+// 目标目录是软链(dev 开发模式)时跳过,不往里写。
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'node:url';
+import { findBundledAssets } from './bundled-assets.js';
+import { dirChecksum } from './utils/artifact-checksum.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/** 定位 CLI 内置 extension dist(npm 包 assets 优先,monorepo 并列路径兜底) */
+export function resolveBuiltinExtensionDist() {
+    // 显式覆盖(测试夹具/应急指定),优先于一切自动探测;
+    // 设为空字符串 = 强制禁用自动探测(测试 no-bundled-assets 路径)
+    const override = process.env.HM_BUNDLED_EXTENSION_DIR;
+    if (override !== undefined)
+        return override && fs.existsSync(override) ? override : null;
+    // 优先 bundled-assets(npm 安装模式:dist/assets/extension 已存在)
+    const bundled = findBundledAssets();
+    if (bundled)
+        return bundled.extensionDir;
+    // fallback:monorepo 并列路径(老 hunter-mate 开发模式)
+    const candidates = [
+        path.resolve(__dirname, '../../extension/dist'), // src 布局: src -> packages/extension/dist
+        path.resolve(__dirname, '../../../extension/dist'), // dist 布局: dist/commands -> packages/extension/dist
+        path.resolve(__dirname, '../bundled-extension'), // bundled
+    ];
+    for (const c of candidates)
+        if (fs.existsSync(c))
+            return c;
+    return null;
+}
+/** build-info.json(FID-092 起构建注入)优先,manifest.json version 兜底 */
+function readArtifactVersion(dir) {
+    try {
+        const info = JSON.parse(fs.readFileSync(path.join(dir, 'build-info.json'), 'utf-8'));
+        if (info && typeof info.version === 'string' && info.version)
+            return info.version;
+    }
+    catch { /* 无 build-info */ }
+    try {
+        const manifest = JSON.parse(fs.readFileSync(path.join(dir, 'manifest.json'), 'utf-8'));
+        if (manifest && typeof manifest.version === 'string' && manifest.version)
+            return manifest.version;
+    }
+    catch { /* 无 manifest */ }
+    return '0.0.0';
+}
+export function compareExtensionArtifacts(targetDir) {
+    const target = targetDir ?? defaultTargetDir();
+    const source = resolveBuiltinExtensionDist();
+    const sourceChecksum = source ? dirChecksum(source).checksum : null;
+    const targetChecksum = fs.existsSync(target) && !isSymlink(target) ? dirChecksum(target).checksum : null;
+    return {
+        source,
+        target,
+        sourceChecksum,
+        targetChecksum,
+        sourceVersion: source ? readArtifactVersion(source) : null,
+        targetVersion: targetChecksum ? readArtifactVersion(target) : null,
+        stale: !!source && !!sourceChecksum && !!targetChecksum && sourceChecksum !== targetChecksum,
+    };
+}
+/**
+ * 同步内置扩展产物到目标目录。
+ * - source 缺失(monorepo 未构建/npm 包缺资产)→ no-op
+ * - target 缺失 → 默认 no-op(首次安装走 hunter-mate install 引导);
+ *   install 命令传 ensureTarget=true 创建
+ * - target 是软链(dev 模式)→ no-op,保护开发链
+ * - checksum 一致 → no-op;不一致 → 剪枝(删目标多余文件)+复制
+ */
+export function syncExtensionArtifacts(opts = {}) {
+    const nil = (reason) => ({ synced: false, reason, copied: 0, removed: 0 });
+    try {
+        const target = opts.target ?? defaultTargetDir();
+        const source = resolveBuiltinExtensionDist();
+        if (!source)
+            return nil('no-bundled-assets');
+        if (isSymlink(target))
+            return nil('target-is-symlink');
+        if (!fs.existsSync(target)) {
+            if (!opts.ensureTarget)
+                return nil('target-missing');
+            fs.mkdirSync(target, { recursive: true });
+        }
+        const cmp = compareExtensionArtifacts(target);
+        if (!cmp.stale) {
+            return { synced: false, reason: 'identical', copied: 0, removed: 0, fromVersion: cmp.targetVersion ?? undefined, toVersion: cmp.sourceVersion ?? undefined };
+        }
+        // 剪枝:目标中上游不存在的文件/空目录删除(纯复制会留下改名后的尸体文件)
+        let removed = 0;
+        const prune = (dst, src) => {
+            if (!fs.existsSync(dst))
+                return;
+            for (const name of fs.readdirSync(dst)) {
+                const d = path.join(dst, name);
+                const s = path.join(src, name);
+                if (!fs.existsSync(s)) {
+                    fs.rmSync(d, { recursive: true, force: true });
+                    removed++;
+                }
+                else if (fs.statSync(d).isDirectory()) {
+                    prune(d, s);
+                    if (fs.existsSync(d) && fs.readdirSync(d).length === 0)
+                        fs.rmdirSync(d);
+                }
+            }
+        };
+        prune(target, source);
+        // 复制(覆盖)
+        let copied = 0;
+        const copy = (src, dst) => {
+            const st = fs.statSync(src);
+            if (st.isDirectory()) {
+                if (!fs.existsSync(dst))
+                    fs.mkdirSync(dst, { recursive: true });
+                for (const f of fs.readdirSync(src))
+                    copy(path.join(src, f), path.join(dst, f));
+            }
+            else {
+                fs.copyFileSync(src, dst);
+                copied++;
+            }
+        };
+        copy(source, target);
+        return {
+            synced: true,
+            reason: 'stale',
+            copied,
+            removed,
+            fromVersion: cmp.targetVersion ?? undefined,
+            toVersion: cmp.sourceVersion ?? undefined,
+        };
+    }
+    catch (err) {
+        // 永不抛出(postinstall 场景绝不能让 npm install 失败)
+        return { synced: false, reason: `error: ${err.message}`, copied: 0, removed: 0 };
+    }
+}
+function defaultTargetDir() {
+    const home = process.env.HUNTER_MATE_HOME || process.env.HOME || process.env.USERPROFILE || '.';
+    return path.join(home, '.hunter-mate', 'extension');
+}
+function isSymlink(dir) {
+    try {
+        return fs.lstatSync(dir).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/index.js

@@ -30,8 +30,11 @@ import { caseCommand } from './commands/case.js';
 import { issueEnvCommand } from './commands/issue-env.js';
 import { i18n } from './i18n/index.js';
 import { initCliLogger, flushCliLogger, getCliLogger } from './logger.js';
+import { installLocalProxyBypass } from './utils/local-http.js';
 import packageJson from '../package.json' with { type: 'json' };
 const CLI_VERSION = packageJson.version;
+// Issue #24:本地 server 探测强制绕过 http_proxy(仅 localhost/127.0.0.1,远程不动)
+installLocalProxyBypass();
 // 未捕获异常兜底(fix #27):任何命令抛出的未处理 Promise 统一友好提示 + exit 1,
 // 不再裸奔 stack 或以 exit code 0 静默结束。
 process.on('unhandledRejection', (reason) => {

package/dist/postinstall.d.ts

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

package/dist/postinstall.js

@@ -0,0 +1,31 @@
+// postinstall.ts — npm install -g 后自动同步扩展产物到 ~/.hunter-mate/extension(Issue #23)
+//
+// 场景:用户 npm 升级 CLI(0.1.7 → 0.1.8+),~/.hunter-mate/extension 仍是旧版构建,
+// update 一致性检查(运行中扩展 vs 磁盘)二者同为旧版,误判"无需 reload",
+// 需手工 hunter-mate install 才刷新。postinstall 按 checksum 比对内置产物,
+// 不一致即自动同步(等价自动跑 install 的产物同步部分)。
+//
+// 红线:本脚本在 npm install 事务内执行,任何情况不得非零退出(阻断用户安装)。
+import * as fs from 'fs';
+import { syncExtensionArtifacts } from './extension-sync.js';
+function main() {
+    // 未初始化过(~/.hunter-mate/extension 不存在)→ 首次安装走 hunter-mate install 引导,不抢跑
+    const home = process.env.HUNTER_MATE_HOME || process.env.HOME || process.env.USERPROFILE;
+    if (!home)
+        return;
+    const target = `${home}/.hunter-mate/extension`;
+    if (!fs.existsSync(target))
+        return;
+    const r = syncExtensionArtifacts();
+    if (r.synced) {
+        process.stdout.write(`[hunter-mate] 扩展产物已自动同步: ${r.fromVersion ?? '?'} → ${r.toVersion ?? '?'}`
+            + `(copied=${r.copied}, removed=${r.removed})\n`);
+        process.stdout.write('[hunter-mate] 若扩展正在运行,请执行 hunter-mate reload 或在 chrome://extensions 刷新\n');
+    }
+}
+try {
+    main();
+}
+catch {
+    // 永不阻断 npm install
+}

package/dist/utils/artifact-checksum.d.ts

@@ -0,0 +1,4 @@
+export declare function dirChecksum(dir: string): {
+    checksum: string;
+    latestMtimeMs: number;
+};

package/dist/utils/artifact-checksum.js

@@ -0,0 +1,40 @@
+// utils/artifact-checksum.ts — 构建产物目录指纹(sha1 + 最新 mtime)
+// 从 version.ts 抽出:postinstall/extension-sync 等轻量入口也要用,
+// 不能反向依赖 version.ts(它拉 axios/nestjs 一整条重链)。
+import * as fs from 'fs';
+import * as path from 'path';
+import { createHash } from 'crypto';
+export 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 };
+}

package/dist/utils/local-http.d.ts

@@ -0,0 +1,7 @@
+export declare function isLocalServerUrl(url: string | undefined): boolean;
+/**
+ * 全局 axios 请求拦截器:调用方未显式指定 proxy 且目标是本地地址时强制 proxy:false。
+ * 在 CLI 入口(index.ts)注册一次,覆盖 status/doctor/extension 等所有探测路径;
+ * 显式传了 proxy(含已有的 proxy:false)的请求不覆盖,尊重调用方意图。
+ */
+export declare function installLocalProxyBypass(): void;

package/dist/utils/local-http.js

@@ -0,0 +1,30 @@
+// utils/local-http.ts — 本地 server 探测的代理绕过(Issue #24 P1)
+//
+// 事故:用户 shell 带 http_proxy=http://127.0.0.1:1087 时,CLI 探测
+// localhost:34570 被代理拦截(500)→ 误判 "server not running" → 自动启动
+// 与 start 的 "already running" 形成死循环。Node/axios 默认读 http_proxy 环境变量,
+// 只对 localhost/127.0.0.1/[::1] 禁用代理;远程 serverUrl(如 SaaS)保留代理行为。
+import axios from 'axios';
+const LOCAL_HOST_RE = /^(?:https?:)?\/\/(?:localhost|127\.0\.0\.1|\[::1\]|0\.0\.0\.0)(?::|\/|$)/i;
+export function isLocalServerUrl(url) {
+    if (!url)
+        return false;
+    return LOCAL_HOST_RE.test(url);
+}
+/**
+ * 全局 axios 请求拦截器:调用方未显式指定 proxy 且目标是本地地址时强制 proxy:false。
+ * 在 CLI 入口(index.ts)注册一次,覆盖 status/doctor/extension 等所有探测路径;
+ * 显式传了 proxy(含已有的 proxy:false)的请求不覆盖,尊重调用方意图。
+ */
+export function installLocalProxyBypass() {
+    axios.interceptors.request.use((config) => {
+        if (config.proxy === undefined) {
+            const url = config.baseURL
+                ? new URL(config.url ?? '', config.baseURL).toString()
+                : (config.url ?? '');
+            if (isLocalServerUrl(url))
+                config.proxy = false;
+        }
+        return config;
+    });
+}