ellm-proxy 0.0.6 → 0.0.8

package/utils/pm2.js

@@ -1,130 +0,0 @@
-// pm2 JS API 封装：连接包裹/回调转 promise/应用查询/探活轮询/安全 dump/包内 pm2 CLI 定位/env 白名单。
-import { rmSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { createRequire } from "node:module";
-import pm2 from "pm2";
-import { APP_NAME, MANAGER_APP_NAME } from "./paths.js";
-import { dot, endOk, endFail } from "./ui.js";
-
-/** pm2.connect 包裹：fn 内可调 pm2.xxx（回调式），结束后自动 disconnect */
-export function withPm2(fn) {
-  return new Promise((resolvePromise, reject) => {
-    pm2.connect((connectErr) => {
-      if (connectErr) return reject(connectErr);
-      Promise.resolve(fn(pm2)).then(
-        (value) => pm2.disconnect(() => resolvePromise(value)),
-        (err) => {
-          try {
-            pm2.disconnect();
-          } catch {
-            /* 已断开 */
-          }
-          reject(err);
-        },
-      );
-    });
-  });
-}
-
-/** pm2 回调式方法转 promise */
-export function pm2cb(method, ...args) {
-  return new Promise((resolvePromise, reject) => {
-    pm2[method](...args, (err, ...out) => (err ? reject(err) : resolvePromise(...out)));
-  });
-}
-
-/** 查询应用当前进程记录（list 中按 name 匹配；不存在返回 undefined）。
- *  name 缺省 = 主服务 ellm-proxy；管理服务传 MANAGER_APP_NAME */
-export async function findApp(name = APP_NAME) {
-  const list = (await pm2cb("list")) || [];
-  return list.find((p) => p.name === name);
-}
-
-/** 启动探活：轮询 status 至 online（每 pollMs 一次，全程打进度点）——比固定等待更快成功
- *  （online 即返回），也能容忍慢启动（默认 15s 上限，固定 1.5s 在慢机器上会误报）；errored/stopped
- *  提前失败（脚本秒崩不必等满超时）。failHint 是失败文案的线索部分（文案是契约的一部分）。
- *  quiet = 静默轮询不打点（多服务并行等待时输出由调用方合并，避免多组进度点交错）。 */
-export async function waitOnline(name, failHint, { timeoutMs = 15000, pollMs = 300, quiet = false } = {}) {
-  const deadline = Date.now() + timeoutMs;
-  let last = null;
-  for (;;) {
-    last = await findApp(name);
-    const status = last?.pm2_env?.status;
-    if (status === "online") {
-      if (!quiet) endOk();
-      return last;
-    }
-    if (status === "errored" || status === "stopped" || Date.now() >= deadline) {
-      if (!quiet) endFail();
-      throw new Error(`${name} 启动后状态异常（${status ?? "已退出"}）。${failHint}`);
-    }
-    if (!quiet) dot();
-    await new Promise((r) => setTimeout(r, pollMs));
-  }
-}
-
-/** 安全 dump（start/stop 成功后调用）：pm2 不允许 dump 空列表会报错——此时说明全部进程已删，
- *  清掉旧 dump.pm2 与滚动备份 dump.pm2.bak（resurrect 无 dump.pm2 时会回落 .bak），防止开机
- *  resurrect 把已停止的服务拉起来 */
-export async function safeDump() {
-  try {
-    await pm2cb("dump");
-  } catch {
-    try {
-      rmSync(join(homedir(), ".pm2", "dump.pm2"), { force: true });
-      rmSync(join(homedir(), ".pm2", "dump.pm2.bak"), { force: true });
-    } catch {
-      /* 清理失败不影响 stop 语义 */
-    }
-  }
-}
-
-/** 当前包内 pm2 CLI 入口绝对路径（autostart cmd 用；resolve 兼容 npm 全局平铺与 pnpm 布局） */
-export function pm2BinJs() {
-  const pm2PkgRoot = dirname(createRequire(import.meta.url).resolve("pm2/package.json"));
-  return join(pm2PkgRoot, "bin", "pm2");
-}
-
-/** 清洗 pm2 子进程透传的 env：pm2 托管的进程自身 env 带 pm_id/pm2_env/unique_id 等
- *  内部变量与 bash 注入的 `_`，原样传回 pm2.start 会污染新进程注册——实测主服务
- *  （name=ellm-proxy）被注册成管理服务的名字，导致探活误判「已退出」。
- *  黑名单清洗实测仍有漏网（多键组合触发），故改用白名单：
- *  只透传主服务必需的业务键（ELLM_* 前缀，含 ELLM_PORT / ELLM_MANAGER_PORT）与 Windows node 运行所需的系统键。
- *  PM2_HOME 保留（pm2 API 连接 daemon 需要，主服务自身不用）。 */
-const PM2_ENV_WHITELIST = new Set([
-  "PATH",
-  "SYSTEMROOT",
-  "WINDIR",
-  "SYSTEMDRIVE",
-  "COMSPEC",
-  "PATHEXT",
-  "OS",
-  "TEMP",
-  "TMP",
-  "USERPROFILE",
-  "HOMEDRIVE",
-  "HOMEPATH",
-  "APPDATA",
-  "LOCALAPPDATA",
-  "PROGRAMDATA",
-  "PROGRAMFILES",
-  "ALLUSERSPROFILE",
-  "PUBLIC",
-  "USERNAME",
-  "USERDOMAIN",
-  "COMPUTERNAME",
-  "NUMBER_OF_PROCESSORS",
-  "HTTP_PROXY",
-  "HTTPS_PROXY",
-  "NO_PROXY",
-]);
-
-export function sanitizePm2Env(env) {
-  const out = {};
-  for (const [key, value] of Object.entries(env)) {
-    if (key === "PM2_HOME" || key.startsWith("ELLM_")) out[key] = value;
-    else if (PM2_ENV_WHITELIST.has(key.toUpperCase())) out[key] = value;
-  }
-  return out;
-}

package/utils/port.js

@@ -1,35 +0,0 @@
-// 端口可用性探测：试绑 listen（全部成功=空闲，任一 EADDRINUSE 等错误=占用），供 service.js 启动前预算端口。
-// Windows 的 wildcard/specific 共存语义（bind 0.0.0.0 与 bind 127.0.0.1 可同端口并存，实测）会让单维度
-// 探测漏报"bind 成功但 IPv4 流量被占用者抢走"的假活，故主服务探测 0.0.0.0 + 127.0.0.1 双维度；
-// IPv6-only 占用极罕见（漏报由 pm2 探活失败兜底）。管理服务固定监听 127.0.0.1 → 探测 ["127.0.0.1"]。
-// 探测与实际 bind 之间存在毫秒级竞态窗口（TOCTOU），极端时被抢占 → 仍由 pm2 探活失败兜底。
-import { createServer } from "node:net";
-
-/** 单 host 试绑：成功=空闲（等 close 回调 socket 释放后才返回 true，避免误占探测端口） */
-function isHostFree(port, host) {
-  return new Promise((resolve) => {
-    const srv = createServer();
-    srv.once("error", () => resolve(false)); // EADDRINUSE / EACCES 等一律视为不可用
-    srv.once("listening", () => srv.close(() => resolve(true)));
-    srv.listen(port, host);
-  });
-}
-
-/** 端口是否空闲：逐个 host 试绑，全部成功才空闲（hosts 传数组多维探测，传字符串退化为单 host） */
-export function isPortFree(port, hosts = ["0.0.0.0", "127.0.0.1"]) {
-  const list = Array.isArray(hosts) ? hosts : [hosts];
-  return (async () => {
-    for (const host of list) {
-      if (!(await isHostFree(port, host))) return false;
-    }
-    return true;
-  })();
-}
-
-/** 从 start 起向上找第一个空闲端口（含 start；maxTry 个内全占返回 0，由调用方决定兜底行为） */
-export async function findFreePort(start, hosts = ["0.0.0.0", "127.0.0.1"], maxTry = 100) {
-  for (let p = start; p < start + maxTry; p++) {
-    if (await isPortFree(p, hosts)) return p;
-  }
-  return 0;
-}

package/utils/service.js

@@ -1,205 +0,0 @@
-// 服务进程管理核心：start/stop（restart = stop + start 由调用方组合，保证最新参数生效）。
-// 被 CLI（bin/commands/service.js）与管理服务（manager/index.js）复用。
-// 本模块只做进程编排并返回数据，人读文案/摘要由调用方输出；错误以 throw 抛出（文案是契约的一部分）。
-// start 流程：配置自愈 → env 注入（含端口预算：主服务 ELLM_PORT / 管理服务 ELLM_MANAGER_PORT = 主端口+1，
-//   占用时自动顺延空闲端口）→ 两个服务一并提交 pm2（数组形式）→ 并行轮询探活 → dump；
-//   管理服务已在线（部分恢复场景）则只补启主服务。
-// 全程分步输出进度（「→ 启动 ...」+ 探活进度点），等待期间不留静默空窗。
-import { readFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import { APP_NAME, MANAGER_APP_NAME, pkgRoot, defaultAppDir, ensureConfig, configPath } from "./paths.js";
-import { withPm2, pm2cb, findApp, waitOnline, safeDump, sanitizePm2Env } from "./pm2.js";
-import { resolveInterpreter } from "./interpreter.js";
-import { isPortFree, findFreePort } from "./port.js";
-import { ensureAutostartOnStart } from "./autostart.js";
-import { ICONS, say, warn, begin, endOk, endFail } from "./ui.js";
-
-/** 管理服务脚本（随包分发，start 时随主服务一并 pm2 托管） */
-const MANAGER_INDEX_JS = join(pkgRoot, "manager", "index.js");
-const DEFAULT_MANAGER_PORT = 29771; // 主端口无法解析时 manager 的最终兜底（默认网关 29770 + 1，与 manager/index.js 缺省一致）
-
-/** 端口解析口径：portEnv（ELLM_PORT env）> 配置文件 port 字段 */
-export function resolvePort(portEnv, configFile) {
-  let port = Number(portEnv) || 0;
-  if (!port) {
-    try {
-      port = JSON.parse(readFileSync(configFile, "utf-8")).port || 0;
-    } catch {
-      port = 0;
-    }
-  }
-  return port;
-}
-
-/** 网关地址与配置文件定位（harness 代理指向目标）：ELLM_PORT env / 配置文件 port，与 start 命令端口口径一致 */
-export function resolveGatewayBase(configOverride) {
-  const configFile = configPath(configOverride);
-  const port = resolvePort(process.env.ELLM_PORT, configFile);
-  return { base: `http://127.0.0.1:${port}`, configFile };
-}
-
-/** 启动服务（CLI restart 与管理服务 restart 复用）：
- *  配置自愈 → env 注入 → 两服务一并提交 pm2（数组形式）→ 并行轮询探活 → dump，
- *  管理服务已在线则只补启主服务。全程分步进度输出。返回 { proc, managerProc, appDir, config } 供调用方输出摘要。 */
-export async function doStart(opts) {
-  say(`正在启动 ${APP_NAME}（pm2 后台守护）...`, ICONS.rocket);
-  const config = ensureConfig(opts.config);
-  const appDir = opts.workingDir || defaultAppDir;
-  mkdirSync(join(appDir, "logs"), { recursive: true });
-
-  // server 端读取的路径基变量：显式值优先（CLI 参数 > 会话已有 > 默认推导）
-  process.env.ELLM_APP_DIR = process.env.ELLM_APP_DIR ?? appDir;
-  process.env.ELLM_CONFIG = config;
-  if (opts.dataDir) process.env.ELLM_DATA_DIR = opts.dataDir;
-
-  // 端口基准预算：主服务 = --port > ELLM_PORT env > 配置文件 port 字段（与 server 端读取口径一致）。
-  // 占用探测与注入在 withPm2 内做（管理服务是否在线影响其端口预算，findApp 需要 pm2 连接）。
-  const port = resolvePort(opts.port ?? process.env.ELLM_PORT, config);
-
-  const interpreter = await resolveInterpreter();
-  const script = opts.serverJs || join(pkgRoot, "dist", "server.js");
-  // ELLM_SERVER_JS：管理服务 restart 主服务时按同一路径重启，保证 --server-js 等参数不漂移
-  process.env.ELLM_SERVER_JS = script;
-
-  return withPm2(async () => {
-    if (await findApp()) {
-      throw new Error(`${APP_NAME} 已在运行。请先停止: ellm-proxy stop`);
-    }
-
-    // 主服务端口：基准被占（其他应用 / 孤儿进程）则自动顺延到空闲端口（默认 0.0.0.0 + 127.0.0.1 双维度，
-    // 见 utils/port.js），避免把注定冲突的端口交给 pm2 后陷入崩溃循环；顺延仅本次运行生效，不改配置文件。
-    let mainPort = port;
-    if (mainPort && !(await isPortFree(mainPort))) {
-      const wanted = mainPort;
-      mainPort = (await findFreePort(mainPort + 1)) || mainPort;
-      warn(
-        mainPort === wanted
-          ? `端口 ${wanted} 已被占用且未找到空闲端口，仍按原端口启动（可能失败，请释放端口或修改配置）`
-          : `端口 ${wanted} 已被占用，主服务自动改用空闲端口 ${mainPort}（仅本次运行生效，不改配置文件）`,
-      );
-    }
-    if (mainPort) process.env.ELLM_PORT = String(mainPort);
-
-    // 管理服务随主服务一并托管（活在外面：主服务被 stop/重启后由它执行拉起；resurrect 时一并恢复）。
-    // 已在线则跳过启动（部分恢复场景幂等），并保持其现有端口（重新预算换端口会造成访问地址漂移）。
-    const existingManager = await findApp(MANAGER_APP_NAME);
-    let managerPort = 0;
-    if (existingManager) {
-      const runningPort = Number(existingManager.pm2_env?.env?.ELLM_MANAGER_PORT);
-      if (runningPort) process.env.ELLM_MANAGER_PORT = String(runningPort);
-      managerPort = Number(process.env.ELLM_MANAGER_PORT) || 0;
-      say(`管理服务 ${MANAGER_APP_NAME} 已在线（端口 ${managerPort || "?"}），跳过启动`, ICONS.skip);
-    } else {
-      // 管理服务端口 = 主服务端口 + 1（用户显式设置过 ELLM_MANAGER_PORT 则尊重）；
-      // 被占则自动顺延（固定监听 127.0.0.1，单维度探测）。探测注入必须在 pm2 start 前，env 随之透传。
-      managerPort = Number(process.env.ELLM_MANAGER_PORT) || (mainPort ? mainPort + 1 : 0);
-      if (managerPort && !(await isPortFree(managerPort, ["127.0.0.1"]))) {
-        const wanted = managerPort;
-        managerPort = (await findFreePort(managerPort + 1, ["127.0.0.1"])) || managerPort;
-        warn(
-          managerPort === wanted
-            ? `管理服务端口 ${wanted} 已被占用且未找到空闲端口，仍按原端口启动（可能失败，可用 ELLM_MANAGER_PORT 调整）`
-            : `管理服务端口 ${wanted} 已被占用，自动改用空闲端口 ${managerPort}（仅本次运行生效）`,
-        );
-      }
-      if (managerPort) process.env.ELLM_MANAGER_PORT = String(managerPort);
-    }
-
-    // 两份 pm2 start 配置（单启主服务 / 双启一并提交两条路径共用）；env 在端口注入后快照
-    const mainOpts = {
-      name: APP_NAME,
-      script,
-      interpreter,
-      cwd: appDir,
-      // 崩溃自动重启但封顶，防端口占用/配置损坏陷入无限重启
-      autorestart: true,
-      max_restarts: 10,
-      restart_delay: 3000,
-      merge_logs: true,
-      out_file: join(appDir, "logs", "ellm-out.log"),
-      error_file: join(appDir, "logs", "ellm-err.log"),
-      env: sanitizePm2Env(process.env),
-    };
-    const managerOpts = {
-      name: MANAGER_APP_NAME,
-      script: MANAGER_INDEX_JS,
-      interpreter,
-      cwd: appDir,
-      autorestart: true,
-      max_restarts: 10,
-      restart_delay: 3000,
-      merge_logs: true,
-      out_file: join(appDir, "logs", "manager-out.log"),
-      error_file: join(appDir, "logs", "manager-err.log"),
-      env: sanitizePm2Env(process.env),
-    };
-
-    if (existingManager) {
-      // 仅补启主服务（单服务，保持打点进度样式）
-      begin(`启动主服务 ${APP_NAME}${mainPort ? ` (端口 ${mainPort})` : ""} `);
-      await pm2cb("start", mainOpts);
-      const proc = await waitOnline(
-        APP_NAME,
-        `最可能是端口被占用或配置无效，请查看日志: ${join(appDir, "logs", "ellm-err.log")}`,
-      );
-      await safeDump();
-      return { proc, managerProc: existingManager, appDir, config };
-    }
-
-    // 双启：两个服务一并提交 pm2（数组形式，daemon 逐个拉起），等待期并行轮询、输出合并为一行。
-    // 主服务失败时管理服务往往已在线——其职责正是远程拉起主服务，故失败后不回收进程，文案给出重试路径。
-    begin(
-      `启动 ${APP_NAME}${mainPort ? ` (端口 ${mainPort})` : ""} + ${MANAGER_APP_NAME}${managerPort ? ` (端口 ${managerPort})` : ""} ...`,
-    );
-    await pm2cb("start", [mainOpts, managerOpts]);
-    const [mainRes, managerRes] = await Promise.allSettled([
-      waitOnline(APP_NAME, `最可能是端口被占用或配置无效，请查看日志: ${join(appDir, "logs", "ellm-err.log")}`, {
-        quiet: true,
-      }),
-      waitOnline(
-        MANAGER_APP_NAME,
-        `最可能是管理服务端口被占用（端口 ${process.env.ELLM_MANAGER_PORT || DEFAULT_MANAGER_PORT}，可用 ELLM_MANAGER_PORT 调整），请查看日志: ${join(appDir, "logs", "manager-err.log")}`,
-        { quiet: true },
-      ),
-    ]);
-    const failures = [mainRes, managerRes].filter((r) => r.status === "rejected");
-    if (failures.length) {
-      endFail();
-      throw new Error(failures.map((f) => f.reason?.message ?? String(f.reason)).join("；"));
-    }
-    endOk();
-
-    // dump 进程列表（~/.pm2/dump.pm2），供开机自启 pm2 resurrect 恢复（主服务 + 管理服务一并恢复）
-    await safeDump();
-    // 首启自愈：从未注册过自启项且用户未显式关闭过 → 静默注册（opt-out 标记尊重用户选择）
-    await ensureAutostartOnStart();
-    return { proc: mainRes.value, managerProc: managerRes.value, appDir, config };
-  });
-}
-
-/** 停止服务：主服务与管理服务一并删除（幂等）。返回 { main, manager } 表示各自此前是否在运行。 */
-export async function doStop() {
-  return withPm2(async () => {
-    const proc = await findApp();
-    const managerProc = await findApp(MANAGER_APP_NAME);
-    if (!proc && !managerProc) return { main: false, manager: false };
-    // 先删管理服务（避免它在主服务停止后仍对外提供启停接口造成状态误判），再删主服务
-    if (managerProc) await pm2cb("delete", MANAGER_APP_NAME);
-    if (proc) await pm2cb("delete", APP_NAME);
-    await safeDump();
-    return { main: !!proc, manager: !!managerProc };
-  });
-}
-
-/** 仅停止主服务（管理服务保持存活；幂等）。管理服务仍在 dump 列表中，resurrect 后它会先起来
- *  继续提供远程启停。管理服务的 stop 语义与 CLI 全停不同——管理服务若自杀，再无人能远程拉起主服务。
- *  被 manager /stop 与 updater（更新前停主服务，manager 自身保持存活执行后续流程）复用。 */
-export async function stopMainOnly() {
-  return withPm2(async () => {
-    const proc = await findApp();
-    if (!proc) return "already-stopped";
-    await pm2cb("delete", APP_NAME);
-    await safeDump();
-    return "stopped";
-  });
-}

package/utils/ui.js

@@ -1,59 +0,0 @@
-// 统一输出工具：emoji 图标 + 进度点 + 摘要字段行，CLI（bin/）与管理服务（manager/）共用。
-// 图标约定：一律选无 VS16（变体选择符）的码点——🖥️/🛠️ 等带 VS16 的在不同终端宽度不稳，实测弃用。
-// 摘要字段行按「两空格缩进 + 图标 + 四字标签 + 三空格 + 内容」对齐。
-export const ICONS = {
-  rocket: "🚀", // 开始
-  pending: "⏳", // 进行中（探活等待等）
-  success: "✅", // 成功完成
-  warn: "❗", // 警告（端口顺延等降级提示）
-  skip: "⏭️", // 已在线跳过
-  running: "🟢", // 服务运行中
-  stopped: "🛑", // 已停止
-  idle: "💤", // 未在运行
-  error: "❌", // 失败
-  gateway: "🌐", // 网关端点
-  webui: "💻", // 管理界面
-  api: "🔧", // 管理服务接口
-  folder: "📂", // 应用目录
-  status: "📋", // 运行状态
-  question: "❓", // 未知（端口未知等兜底展示）
-};
-
-/** 一行信息（icon 省略 = 纯文本行） */
-export function say(text, icon) {
-  console.log(icon ? `${icon} ${text}` : text);
-}
-
-/** 警告行 */
-export function warn(text) {
-  say(text, ICONS.warn);
-}
-
-/** 错误行（stderr，供 CLI 统一错误出口） */
-export function error(text) {
-  console.error(`${ICONS.error} ${text}`);
-}
-
-/** 行内片段（不换行）：⏳ 前缀 + 文本，供后续追加进度点 / 行尾状态；text 需自带尾部空格或省略号 */
-export function begin(text) {
-  process.stdout.write(`${ICONS.pending} ${text}`);
-}
-
-/** 进度点（探活轮询期间追加） */
-export function dot() {
-  process.stdout.write(".");
-}
-
-/** 行尾成功 / 失败标记并换行（与 begin/dot 配套） */
-export function endOk() {
-  process.stdout.write(" ✓\n");
-}
-
-export function endFail() {
-  process.stdout.write(" ✗\n");
-}
-
-/** 摘要字段行：缩进 + 图标 + 标签 + 内容 */
-export function field(icon, label, value) {
-  console.log(`  ${icon} ${label}   ${value}`);
-}

package/utils/updater.js

@@ -1,210 +0,0 @@
-// 自动更新核心：npm 全局包的检查 / 安装 / 看门狗轮询。
-// 被 manager（manager/api/service-settings.js 挂载 + startUpdateWatchdog 常驻轮询）复用。
-// 检查源 = npm 官方 registry（ELLM_UPDATE_REGISTRY 可覆盖）；包名取 pkg.name（ellm-proxy）。
-// 更新流程：stopMainOnly（停主服务释放文件句柄，manager 保持存活）→ npm i -g <pkg>@latest →
-//   doStart(startOpts)（主服务即新代码）→ 延迟 3s pm2 restart manager 自身（daemon 负责拉起，不依赖自身存活）。
-// 开关状态 <appDir>/updater.json：{ enabled?, lastCheck?, lastApply? }；文件缺失 = 默认开启。
-// 仓库 dev 模式防护：pkgRoot 父目录不是 node_modules（源码运行）时更新域 unsupported，看门狗不启动。
-import { spawn } from "node:child_process";
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { pkg, pkgRoot, defaultAppDir, MANAGER_APP_NAME } from "./paths.js";
-import { doStart, stopMainOnly } from "./service.js";
-import { pm2cb, withPm2 } from "./pm2.js";
-
-const UPDATER_SETTINGS_FILE = "updater.json";
-const DEFAULT_REGISTRY = "https://registry.npmjs.org/";
-const CHECK_INTERVAL_MS = 60 * 60 * 1000; // 每小时检查
-const FIRST_CHECK_DELAY_MS = 30 * 1000; // 启动后 30s 首查（错开启动高峰）
-
-/** 更新开关配置路径 */
-function settingsPath() {
-  return join(defaultAppDir, UPDATER_SETTINGS_FILE);
-}
-
-/** 读取开关设置（文件缺失/损坏 = 默认开启）；enabled 显式 false 才视为关闭 */
-export function readUpdaterSettings() {
-  try {
-    const raw = JSON.parse(readFileSync(settingsPath(), "utf-8"));
-    return { enabled: raw.enabled !== false, lastCheck: raw.lastCheck ?? null, lastApply: raw.lastApply ?? null };
-  } catch {
-    return { enabled: true, lastCheck: null, lastApply: null };
-  }
-}
-
-/** 合并写回开关设置（patch 浅合并；写盘失败不 throw——检查结果落盘失败不影响主流程） */
-export function writeUpdaterSettings(patch) {
-  const next = { ...readUpdaterSettings(), ...patch };
-  try {
-    mkdirSync(defaultAppDir, { recursive: true });
-    writeFileSync(settingsPath(), JSON.stringify(next, null, 2) + "\n", "utf-8");
-  } catch {
-    /* 只读盘等场景容忍：内存态仍可用 */
-  }
-  return next;
-}
-
-/** 仓库 dev 模式判定：包根（或 scoped 包的上一级 @scope 目录）不在 node_modules 下 = 源码运行，
- *  更新域不可用（防 dev 会话误更新全局包）。全局安装路径形如 <prefix>/node_modules/<pkg>，
- *  scoped 包为 <prefix>/node_modules/@scope/<pkg>，故向上最多探两层。 */
-export function isUpdateSupported() {
-  const parent = dirname(pkgRoot);
-  return basename(parent) === "node_modules" || basename(dirname(parent)) === "node_modules";
-}
-
-/** x.y.z 逐段数字比较（prerelease/脏串按 0 段处理：私有源版本号由 release.mjs 保证三段式） */
-export function isNewerVersion(latest, current) {
-  const parse = (v) => String(v || "").split(".").map((n) => Number(n) || 0);
-  const a = parse(latest);
-  const b = parse(current);
-  for (let i = 0; i < 3; i++) {
-    if ((a[i] ?? 0) !== (b[i] ?? 0)) return (a[i] ?? 0) > (b[i] ?? 0);
-  }
-  return false;
-}
-
-/** 更新源 registry（env ELLM_UPDATE_REGISTRY 可覆盖，默认私有 group 源） */
-export function updateRegistry() {
-  return process.env["ELLM_UPDATE_REGISTRY"] || DEFAULT_REGISTRY;
-}
-
-/** spawn 执行 npm 命令并收集 stdout（shell:true 兼容 Windows npm.cmd；先例 scripts/release.mjs） */
-function runNpm(args, timeoutMs) {
-  return new Promise((resolvePromise, reject) => {
-    // windowsHide: true 必须带——manager 是无控制台的 pm2 后台进程，shell:true 经 cmd.exe 跑 npm.cmd
-    // 时 Windows 会给命令链分配新控制台（web-ui 点更新/看门狗 tick 都会弹 cmd 黑窗），此选项全程隐藏
-    const child = spawn(`npm ${args.join(" ")}`, { shell: true, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
-    let stdout = "";
-    let stderr = "";
-    const timer = setTimeout(() => {
-      child.kill();
-      reject(new Error(`npm ${args[0]} 超时（${Math.round(timeoutMs / 1000)}s）`));
-    }, timeoutMs);
-    child.stdout.on("data", (d) => (stdout += d));
-    child.stderr.on("data", (d) => (stderr += d));
-    child.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-    child.on("exit", (code) => {
-      clearTimeout(timer);
-      if (code === 0) resolvePromise(stdout.trim());
-      else reject(new Error(`npm ${args[0]} 失败（exit ${code}）：${stderr.trim().slice(-400) || "无错误输出"}`));
-    });
-  });
-}
-
-/** 查询 registry 上该包的最新版本（npm view） */
-async function fetchLatestVersion() {
-  const out = await runNpm(["view", pkg.name, "version", "--registry", updateRegistry()], 60 * 1000);
-  const version = out.split("\n").filter(Boolean).pop()?.trim();
-  if (!version || !/^\d+\.\d+\.\d+/.test(version)) {
-    throw new Error(`无法解析 npm view 输出版本号: ${out.slice(0, 200)}`);
-  }
-  return version;
-}
-
-/** 检查更新：查询最新版本并与当前比较，结果落 lastCheck。返回 { hasUpdate, currentVersion, latestVersion, checkedAt } */
-export async function checkForUpdate() {
-  const latestVersion = await fetchLatestVersion();
-  const result = {
-    hasUpdate: isNewerVersion(latestVersion, pkg.version),
-    currentVersion: pkg.version,
-    latestVersion,
-    checkedAt: Date.now(),
-  };
-  writeUpdaterSettings({ lastCheck: result });
-  return result;
-}
-
-// —— 安装与重启 ————————————————————————————————————————————————————————
-
-/** 更新执行互斥锁：手动触发与看门狗 tick 并发时只放行一个（其余收到明确报错） */
-let updating = false;
-
-export function isUpdating() {
-  return updating;
-}
-
-/** 执行更新（内部先查版本，无新版直接返回 updated:false）：停主服务 → npm i -g →
- *  重启主服务（新代码）→ 3s 后重启 manager 自身换新代码。安装失败 → 回滚为主服务旧版本继续服务。
- *  startOpts = 主服务启动参数（与 manager/index.js 的 startOpts 同源，保证重启后参数不漂移）。
- *  返回 { fromVersion, toVersion, updated }。 */
-export async function performUpdate(startOpts) {
-  if (updating) throw new Error("已有更新在执行中，请稍后再试。");
-  updating = true;
-  const fromVersion = pkg.version;
-  try {
-    const latest = await fetchLatestVersion();
-    if (!isNewerVersion(latest, fromVersion)) {
-      const result = { hasUpdate: false, currentVersion: fromVersion, latestVersion: latest, checkedAt: Date.now() };
-      writeUpdaterSettings({ lastCheck: result });
-      return { fromVersion, toVersion: fromVersion, updated: false };
-    }
-    // 停主服务释放 dist 文件句柄（Windows 上 npm 替换全局目录时句柄占用会致安装失败）；
-    // manager 保持存活执行后续流程
-    await stopMainOnly();
-    try {
-      await runNpm(["install", "-g", `${pkg.name}@latest`, "--registry", updateRegistry()], 10 * 60 * 1000);
-    } catch (err) {
-      // 安装失败：旧版本继续服务（doStart 用的仍是当前包代码）
-      await doStart(startOpts).catch(() => {});
-      throw new Error(`安装新版本失败，已恢复旧版本 ${fromVersion} 继续服务。${err?.message ?? err}`);
-    }
-    writeUpdaterSettings({ lastApply: { fromVersion, toVersion: latest, appliedAt: Date.now() } });
-    await doStart(startOpts);
-    // 延迟重启 manager 自身：让本次 HTTP 响应先送达，pm2 daemon 负责拉起新代码
-    setTimeout(() => {
-      withPm2(() => pm2cb("restart", MANAGER_APP_NAME)).catch(() => {});
-    }, 3000);
-    return { fromVersion, toVersion: latest, updated: true };
-  } finally {
-    updating = false;
-  }
-}
-
-/** 检查到新版后的一步式自动处理（看门狗 tick 用）：返回是否执行了更新 */
-async function autoUpdateIfNeeded(startOpts) {
-  const check = await checkForUpdate();
-  if (!check.hasUpdate) return false;
-  console.log(`[updater] 发现新版本 ${check.latestVersion}（当前 ${check.currentVersion}），开始自动更新...`);
-  const result = await performUpdate(startOpts);
-  if (result.updated) {
-    console.log(`[updater] 已更新 ${result.fromVersion} → ${result.toVersion}，主服务已重启，manager 将延迟自重启`);
-  }
-  return result.updated;
-}
-
-// —— 看门狗 ————————————————————————————————————————————————————————
-
-let watchdogTimer = null;
-
-/** 启动更新看门狗（manager 启动时调用）：更新域受支持且开关开启时，
- *  启动后 30s 首查 + 每小时轮询；每次 tick 重读开关，已关闭则停表（下次 manager 启动再评估）。
- *  tick 内检查/更新失败只记日志（下个周期再试），绝不 throw——看门狗不能把 manager 打崩。
- *  startOpts = 主服务启动参数（透传 performUpdate → doStart，与 manager/index.js 同源）。 */
-export async function startUpdateWatchdog(startOpts) {
-  if (!isUpdateSupported()) return; // 源码运行：不轮询不检查
-  const { enabled } = readUpdaterSettings();
-  if (!enabled) return;
-  if (watchdogTimer) return; // 已在跑（幂等）
-
-  const tick = async () => {
-    const { enabled: nowEnabled } = readUpdaterSettings();
-    if (!nowEnabled) {
-      clearInterval(watchdogTimer);
-      watchdogTimer = null;
-      console.log("[updater] 自动更新已关闭，看门狗停止");
-      return;
-    }
-    try {
-      await autoUpdateIfNeeded(startOpts);
-    } catch (err) {
-      console.warn(`[updater] 自动检查/更新失败（下个周期重试）: ${err?.message ?? err}`);
-    }
-  };
-
-  setTimeout(tick, FIRST_CHECK_DELAY_MS).unref?.();
-  watchdogTimer = setInterval(tick, CHECK_INTERVAL_MS);
-  console.log(`[updater] 更新看门狗已启动（每 ${CHECK_INTERVAL_MS / 60000} 分钟检查，源 ${updateRegistry()}）`);
-}