ellm-proxy 0.0.2 → 0.0.6

package/utils/service.js

@@ -1,189 +1,205 @@
-// 服务进程管理核心：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 { 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();
-    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 };
-  });
-}
+// 服务进程管理核心：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/updater.js

@@ -0,0 +1,210 @@
+// 自动更新核心：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()}）`);
+}

package/dist/web-ui/assets/DashboardView-qrQrkgLA.css

@@ -1 +0,0 @@
-.copy-text[data-v-a652207c]{color:#409eff;cursor:pointer}.copy-text[data-v-a652207c]:hover{text-decoration:underline}

package/dist/web-ui/assets/LayoutView-BaY4Pz9W.js

@@ -1 +0,0 @@
-import{d as C,c as y,a as t,w as o,b as l,r as s,o as V,e as r,t as W,u as B,f as D,g as L,h as N}from"./index-DFlUx18F.js";const S={class:"layout"},A={class:"header-nav"},E={class:"header-actions"},I={class:"main"},R={class:"page"},M=C({__name:"LayoutView",setup(T){const d=N(),i=L(),u=(()=>{const n=localStorage.getItem("webui_token")||"";try{return atob(n).split(":")[0]||"用户"}catch{return"用户"}})(),_=D(()=>{const n=d.path;return n==="/"?"/":n.startsWith("/providers")?"/providers":n.startsWith("/settings")?"/settings":n.startsWith("/logs")?"/logs":n.startsWith("/process")?"/process":"/"}),c=()=>{localStorage.removeItem("webui_token"),i.push("/login")},m=n=>{n==="logout"&&c()};return(n,e)=>{const a=s("el-menu-item"),p=s("el-menu"),f=s("ArrowDown"),g=s("el-icon"),w=s("el-button"),v=s("el-dropdown-item"),h=s("el-dropdown-menu"),x=s("el-dropdown"),b=s("el-header"),k=s("router-view");return V(),y("div",S,[t(b,{class:"header"},{default:o(()=>[e[6]||(e[6]=l("h1",null,[l("span",null,"E"),r("LLM")],-1)),l("nav",A,[t(p,{mode:"horizontal","default-active":_.value,ellipsis:!1,router:"",class:"header-menu"},{default:o(()=>[t(a,{index:"/"},{default:o(()=>[...e[0]||(e[0]=[r("首页",-1)])]),_:1}),t(a,{index:"/providers"},{default:o(()=>[...e[1]||(e[1]=[r("供应商管理",-1)])]),_:1}),t(a,{index:"/logs"},{default:o(()=>[...e[2]||(e[2]=[r("日志",-1)])]),_:1}),t(a,{index:"/settings"},{default:o(()=>[...e[3]||(e[3]=[r("设置",-1)])]),_:1}),t(a,{index:"/process"},{default:o(()=>[...e[4]||(e[4]=[r("进程管理",-1)])]),_:1})]),_:1},8,["default-active"])]),l("div",E,[t(x,{trigger:"click",onCommand:m,class:"ml-12"},{dropdown:o(()=>[t(h,null,{default:o(()=>[t(v,{command:"logout"},{default:o(()=>[...e[5]||(e[5]=[r("退出",-1)])]),_:1})]),_:1})]),default:o(()=>[t(w,null,{default:o(()=>[r(W(B(u))+" ",1),t(g,{class:"el-icon--right"},{default:o(()=>[t(f)]),_:1})]),_:1})]),_:1})])]),_:1}),l("main",I,[l("div",R,[t(k)])])])}}});export{M as default};

package/dist/web-ui/assets/LoginView-CPvz1Ylx.js

@@ -1 +0,0 @@
-import{d as b,c as h,a as o,w as l,r as a,o as _,b as k,Z as x,X as f,j as C,k as L,e as B,l as i,g as N,_ as I}from"./index-DFlUx18F.js";import{A as K}from"./useApi-BRPinb_2.js";const A={class:"login-wrap"},E=b({__name:"LoginView",setup(M){const v=N(),n=i(""),s=i(""),t=i(""),d=i(!1);async function r(){if(!n.value){t.value="请输入用户名";return}if(!s.value){t.value="请输入密码";return}d.value=!0,t.value="";try{const u=await K.post("/api/auth/login",{username:n.value.trim(),password:s.value});localStorage.setItem("webui_token",u.token),v.push("/")}catch(u){t.value=u.message||"登录失败"}finally{d.value=!1}}return(u,e)=>{const c=a("el-input"),m=a("el-form-item"),w=a("el-alert"),g=a("el-button"),V=a("el-form"),y=a("el-card");return _(),h("div",A,[o(y,{shadow:"hover",class:"login-card"},{default:l(()=>[e[3]||(e[3]=k("h2",{class:"login-title"},"ELLM",-1)),o(V,{"label-position":"top",onSubmit:x(r,["prevent"])},{default:l(()=>[o(m,{label:"用户名"},{default:l(()=>[o(c,{modelValue:n.value,"onUpdate:modelValue":e[0]||(e[0]=p=>n.value=p),placeholder:"请输入用户名",onKeyup:f(r,["enter"])},null,8,["modelValue"])]),_:1}),o(m,{label:"密码"},{default:l(()=>[o(c,{modelValue:s.value,"onUpdate:modelValue":e[1]||(e[1]=p=>s.value=p),type:"password",placeholder:"请输入密码","show-password":"",onKeyup:f(r,["enter"])},null,8,["modelValue"])]),_:1}),t.value?(_(),C(w,{key:0,title:t.value,type:"error","show-icon":"",class:"mb-16"},null,8,["title"])):L("",!0),o(g,{type:"primary",class:"full-width",loading:d.value,onClick:r},{default:l(()=>[...e[2]||(e[2]=[B(" 登录 ",-1)])]),_:1},8,["loading"])]),_:1})]),_:1})])}}}),j=I(E,[["__scopeId","data-v-d5b6a90c"]]);export{j as default};