ellm-proxy 0.0.6 → 0.0.8

package/manager/api/service.js

@@ -1,147 +0,0 @@
-// 主服务进程控制 api 子应用：状态查询与启停。
-// 注意 stop 语义 = 只停主服务（与 CLI ellm-proxy stop 的全停语义不同）——
-// 管理服务若自杀，再无人能远程拉起主服务。
-import { readFileSync, realpathSync, statSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createRequire } from "node:module";
-import { Hono } from "hono";
-import { APP_NAME, MANAGER_APP_NAME } from "../../utils/paths.js";
-import { withPm2, findApp, pm2cb, safeDump } from "../../utils/pm2.js";
-import { doStart, stopMainOnly, resolveGatewayBase, resolvePort } from "../../utils/service.js";
-
-// 本文件在 manager/api/ 下，包根为上两级
-const pkgRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
-
-/** ellm-proxy 进程状态（pm2 视角） */
-async function statusPayload(startOpts) {
-  const proc = await withPm2(() => findApp());
-  const { base } = resolveGatewayBase(startOpts.config);
-  return {
-    running: !!proc,
-    pid: proc?.pid ?? null,
-    pm2Status: proc?.pm2_env?.status ?? null,
-    uptime: proc?.pm2_env?.pm_uptime ?? null,
-    gatewayBase: base,
-  };
-}
-
-/** pm2 依赖树内的 pidusage（realpath 穿透 pnpm 符号链接）：pm2 守护进程自身的内存/CPU 采样 */
-function loadPidusage() {
-  const pm2PkgJson = realpathSync(join(pkgRoot, "node_modules", "pm2", "package.json"));
-  return createRequire(pm2PkgJson)("pidusage");
-}
-
-/** 统一行形状：role = daemon | manager | main（前端按 main 判定可操作行） */
-function row(role, { pid = null, status = "stopped", port = null, startedAt = null, memory = null, cpu = null, restarts = null }) {
-  return {
-    role,
-    pid,
-    status,
-    port,
-    address: port ? `http://127.0.0.1:${port}` : null,
-    startedAt,
-    memory,
-    cpu,
-    restarts,
-  };
-}
-
-/** pm2 守护进程行：PID 读 PM2_HOME/pm2.pid（文件只在 daemon 启动时写，mtime 即启动时刻）；
- *  内存/CPU 用 pidusage 采样（pm2 jlist 不含 daemon 自身） */
-async function daemonRow() {
-  const pm2Home = process.env.PM2_HOME || join(homedir(), ".pm2");
-  const pidFile = join(pm2Home, "pm2.pid");
-  let pid = null;
-  let startedAt = null;
-  try {
-    pid = Number(readFileSync(pidFile, "utf8").trim()) || null;
-    startedAt = statSync(pidFile).mtimeMs;
-  } catch {
-    /* 无 pm2.pid = daemon 未运行 */
-  }
-  if (!pid) return row("daemon");
-  let memory = null;
-  let cpu = null;
-  try {
-    const stat = await loadPidusage()(pid);
-    memory = stat.memory ?? null;
-    cpu = stat.cpu != null ? Math.round(stat.cpu * 10) / 10 : null;
-  } catch {
-    /* pid 文件存在但进程已死（采样 reject）：按未运行处理 */
-    pid = null;
-  }
-  return row("daemon", { pid, status: pid ? "online" : "stopped", port: null, startedAt, memory, cpu });
-}
-
-/** pm2 托管进程行：monit（内存/CPU，pm2 周期采样）+ pm_uptime（启动时刻）+ restart_time */
-function appRow(proc, role, { port }) {
-  if (!proc) return row(role);
-  const env = proc.pm2_env ?? {};
-  const monit = proc.monit ?? {};
-  return row(role, {
-    pid: proc.pid ?? null,
-    status: env.status ?? "unknown",
-    port: port ?? null,
-    startedAt: env.pm_uptime ?? null,
-    memory: monit.memory ?? null,
-    cpu: monit.cpu != null ? Math.round(monit.cpu * 10) / 10 : null,
-    restarts: env.restart_time ?? null,
-  });
-}
-
-/** 全进程列表：pm2 守护进程 / 管理服务 / 主服务。
- *  端口口径：主服务 = pm2 注入的 ELLM_PORT（含占用顺延后的实际值）> env > 配置文件；
- *  管理服务 = ELLM_MANAGER_PORT env > 主端口 + 1（与 manager/index.js 的预算口径一致）。 */
-async function processesPayload(startOpts) {
-  const list = (await withPm2(() => pm2cb("list"))) || [];
-  const main = list.find((p) => p.name === APP_NAME);
-  const manager = list.find((p) => p.name === MANAGER_APP_NAME);
-  const mainPort =
-    Number(main?.pm2_env?.env?.ELLM_PORT) || resolvePort(process.env.ELLM_PORT, startOpts.config) || null;
-  const managerPort = Number(process.env.ELLM_MANAGER_PORT) || (mainPort ? mainPort + 1 : null);
-  return [
-    await daemonRow(),
-    appRow(manager, "manager", { port: managerPort }),
-    appRow(main, "main", { port: mainPort }),
-  ];
-}
-
-/** pm2 启停：start / stop / restart（restart = 停主服务 + start，
- *  start 时管理服务已在线会被 doStart 的幂等检查跳过）。
- *  stopMainOnly 已抽到 utils/service.js（updater 更新前停主服务复用同语义）。 */
-async function runStartStop(action, startOpts) {
-  if (action === "stop") return stopMainOnly();
-  if (action === "start") return doStart(startOpts);
-  await stopMainOnly();
-  await doStart(startOpts);
-}
-
-/** 进程控制子应用（挂载于根路径）：GET /status · GET /processes · POST /start|stop|restart */
-export function createServiceApp({ startOpts }) {
-  const app = new Hono();
-
-  app.get("/status", async (c) => c.json({ ok: true, ...(await statusPayload(startOpts)) }));
-
-  // 全进程列表（三行固定：pm2 守护进程 / 管理服务 / 主服务）；启停操作仍只走
-  // /start|stop|restart 的主服务语义——daemon 与管理服务不允许被远程操控（自杀失联风险）
-  app.get("/processes", async (c) =>
-    c.json({ ok: true, processes: await processesPayload(startOpts) }),
-  );
-
-  app.post("/start", async (c) => {
-    await runStartStop("start", startOpts);
-    return c.json({ ok: true, action: "start" });
-  });
-  app.post("/stop", async (c) => {
-    await runStartStop("stop", startOpts);
-    return c.json({ ok: true, action: "stop" });
-  });
-  app.post("/restart", async (c) => {
-    await runStartStop("restart", startOpts);
-    return c.json({ ok: true, action: "restart" });
-  });
-
-  return app;
-}

package/manager/index.js

@@ -1,182 +0,0 @@
-// ellm-proxy 管理服务入口（独立常驻脚本）：随 `ellm-proxy start` 一并由 pm2 托管（name=ellm-proxy-manager）；
-// 也可手动 `node manager/index.js` 运行。本文件 = 创建 app（中间件 + api 聚合挂载）+ 启动 HTTP 服务；
-// 各 api 域实现在 api/ 下：service.js（进程控制，命名对齐 backend/src/api/service.ts）、harness/（代理开关域）。
-//
-// 为什么独立于 backend：ellm-proxy 与 backend 同进程，进程自杀后管理台与转发层同时失联，
-// 无法返回操作结果——启停必须由活在外面的本服务执行。
-//
-// 管理界面托管：本服务同进程托管 web-ui 构建产物（根路径 /，hash 路由），并反代 /api/* 到主服务——
-// web-ui 全部接口（/api/* 管理台 + /status /restart /harness 等进程/开关域）同源可达，config.js 留空零配置。
-//
-// 接口（CORS 全放开，均返回 {ok, ...} 或 {ok:false, error}）：
-//   GET  /                    web-ui 管理界面（静态托管，产物缺失时仅告警跳过）
-//   GET  /api/*               反代主服务管理台 API（端口 = ELLM_PORT env > 配置文件 port，每请求解析）
-//   GET  /status                ellm-proxy 运行状态（running/pid/status/uptime/网关端口）
-//   GET  /processes             全进程列表（pm2 守护进程/管理服务/主服务：状态/PID/端口/内存/CPU/运行时长）
-//   POST /start | /stop | /restart   pm2 启动/停止/重启 ellm-proxy（复用 utils/service.js，含探活）
-//   GET|POST /autostart        开机自启状态 / 开关（body {enabled}；utils/autostart.js，opt-out 尊重用户选择）
-//   GET  /update               自动更新状态（开关/上次检查/上次更新/supported）
-//   POST /update/enabled       body {enabled}；自动更新开关（<appDir>/updater.json）
-//   POST /update/check         手动检查更新（npm view 私有源）
-//   POST /update/apply         手动执行更新（停主服务 → npm i -g → 重启主服务 → manager 延迟自重启）
-//   GET  /harness               Claude Code / Codex / DeepSeek Harness 代理开关状态
-//   POST /harness/claude-code   body {enabled}；开 = 写 ~/.claude/settings.json（备份），关 = 还原备份
-//   POST /harness/codex         body {enabled}；开 = 写 ~/.codex/config.toml（备份），关 = 还原备份
-//   POST /harness/dsh           body {enabled}；开 = 写 ~/.dsh/settings.yaml + .credentials.yaml（备份），关 = 还原
-//
-// 配置来源（env 优先，argv 可覆盖，缺省兜底）：
-//   监听端口  ELLM_MANAGER_PORT（doStart 统一预算 = 主服务端口+1）> argv --port > 29771
-//   web-ui 产物 ELLM_WEBUI_DIR（可选覆盖）> 按本文件位置推导：包模式 <pkgRoot>/dist/web-ui → 仓库模式 <repoRoot>/web-ui/dist
-//   主服务参数 与 ellm-proxy start 注入的 env 同源：ELLM_CONFIG / ELLM_DATA_DIR / ELLM_APP_DIR / ELLM_PORT /
-//             ELLM_SERVER_JS（主服务 dist/server.js 路径，restart 重启主服务时使用，保证参数不漂移）
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import { proxy } from "hono/proxy";
-import { serve } from "@hono/node-server";
-import { serveStatic } from "@hono/node-server/serve-static";
-import { dirname, join, relative, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import mri from "mri";
-import { absolutize } from "../utils/paths.js";
-import { resolveGatewayBase } from "../utils/service.js";
-import { startUpdateWatchdog } from "../utils/updater.js";
-import { ICONS, say } from "../utils/ui.js";
-import { createServiceApp } from "./api/service.js";
-import { createServiceSettingsApp } from "./api/service-settings.js";
-import { createHarnessApp } from "./api/harness/index.js";
-
-const DEFAULT_SERVER_PORT = 29771; // 手动运行且无 env 时的兜底（默认网关 29770 + 1）
-// 本文件在 manager/ 下，包根为上一级
-const pkgRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-
-// web-ui 构建产物目录：ELLM_WEBUI_DIR 优先；缺省按本文件位置推导（包模式 dist/web-ui 与 server.js 同级，
-// 仓库模式落到 monorepo 的 web-ui/dist）。启动时判定一次，缺失则跳过静态托管（接口不受影响）。
-const WEBUI_DIST_DIR = process.env.ELLM_WEBUI_DIR
-  ? resolve(process.cwd(), process.env.ELLM_WEBUI_DIR)
-  : ([join(pkgRoot, "dist", "web-ui"), resolve(pkgRoot, "..", "web-ui", "dist")].find((p) =>
-      existsSync(join(p, "index.html")),
-    ) ?? join(pkgRoot, "dist", "web-ui"));
-const HAS_WEBUI = existsSync(join(WEBUI_DIST_DIR, "index.html"));
-
-/** web-ui 管理界面静态托管：/ 出 index.html（hash 路由唯一服务端入口），assets/ 补长缓存头。
- *  须在 api 聚合与 /api 反代之后注册——serve-static 未命中才放行，不会遮蔽接口。 */
-function registerWebUi(app) {
-  if (!HAS_WEBUI) return;
-  // serve-static 的 root 只接受相对 cwd 的路径：把绝对定位换算成当前 cwd 表达（仓库/发布包/任意 cwd 均成立）
-  const root = relative(process.cwd(), WEBUI_DIST_DIR);
-  app.get("/", async (c) => {
-    try {
-      const buf = await readFile(join(WEBUI_DIST_DIR, "index.html"));
-      return c.body(new Uint8Array(buf), 200, {
-        "Content-Type": "text/html; charset=utf-8",
-        "Cache-Control": "no-cache",
-      });
-    } catch {
-      return c.text("Not Found", 404);
-    }
-  });
-  app.use("/*", (c, next) => {
-    if (c.req.path === "/") return next(); // 根路径由上面的 serveIndex 处理
-    return serveStatic({
-      root,
-      onFound: (_p, ctx) => {
-        if (ctx.req.path.startsWith("/assets/")) ctx.header("Cache-Control", "public, max-age=31536000, immutable");
-      },
-    })(c, next);
-  });
-}
-
-/** 创建管理服务 app：CORS 全放开 + api 聚合挂载 + /api 反代主服务 + web-ui 静态托管 + 统一 404/500 */
-function createApp({ startOpts }) {
-  const app = new Hono();
-
-  // CORS 全放开（OPTIONS 预检由中间件自动处理）
-  app.use("*", cors());
-
-  // api 聚合：进程控制（GET /status · POST /start|stop|restart）、服务设置（autostart / update 域）
-  // 与 harness 开关（GET /harness · POST /harness/claude-code|codex|dsh）
-  app.route("/", createServiceApp({ startOpts }));
-  app.route("/", createServiceSettingsApp({ startOpts }));
-  app.route("/harness", createHarnessApp({ startOpts }));
-
-  // 反代主服务管理台 API（web-ui 同源访问的 /api/*）：端口与 start 口径一致（ELLM_PORT env > 配置文件），
-  // 每请求解析——主服务端口顺延漂移无感知
-  app.all("/api/*", (c) => {
-    const { base } = resolveGatewayBase();
-    const port = Number(new URL(base).port);
-    if (!port) {
-      return c.json(
-        { ok: false, error: "主服务端口无法解析（ELLM_PORT env 与配置文件 port 均缺失），无法转发 /api/*" },
-        502,
-      );
-    }
-    // 目标 URL 必须带上原始查询串：c.req.path 只有 pathname，漏拼 search 会把
-    // ?id=... / ?page=... 等查询参数全部丢掉（主服务按缺参返回 400 或默认分页）
-    const incoming = new URL(c.req.raw.url);
-    return proxy(new URL(incoming.pathname + incoming.search, base), {
-      method: c.req.method,
-      headers: c.req.raw.headers,
-      body: c.req.method === "GET" || c.req.method === "HEAD" ? undefined : c.req.raw.body,
-      duplex: "half", // body 为流时 undici 必需
-    });
-  });
-
-  registerWebUi(app);
-
-  app.notFound((c) =>
-    c.json(
-      {
-        ok: false,
-        error: `未知接口: ${c.req.method} ${c.req.path}（可用: GET /（管理界面）, GET /api/*（反代主服务）, GET /status, GET /processes, POST /start|stop|restart, GET|POST /autostart, GET /update, POST /update/enabled|check|apply, GET /harness, POST /harness/claude-code|codex|dsh）`,
-      },
-      404,
-    ),
-  );
-  app.onError((err, c) => {
-    console.error(`[ellm-proxy-manager] ${c.req.method} ${c.req.path} 失败:`, err?.message ?? err);
-    return c.json({ ok: false, error: err?.message ?? String(err) }, 500);
-  });
-
-  return app;
-}
-
-async function main() {
-  // argv 解析（mri）：仅 --port（其余主服务参数一律走 env，与 start 注入链同源）
-  const argv = mri(process.argv.slice(2));
-  const listenPort = Number(argv.port) || Number(process.env.ELLM_MANAGER_PORT) || DEFAULT_SERVER_PORT;
-  // 主服务启动参数（start/restart 时透传给 doStart）：ELLM_* env 与 CLI start 注入链同源
-  const startOpts = absolutize({
-    config: process.env.ELLM_CONFIG,
-    dataDir: process.env.ELLM_DATA_DIR,
-    workingDir: process.env.ELLM_APP_DIR,
-    serverJs: process.env.ELLM_SERVER_JS || join(pkgRoot, "dist", "server.js"),
-  });
-
-  const app = createApp({ startOpts });
-
-  const server = serve({ fetch: app.fetch, port: listenPort, hostname: "127.0.0.1" });
-  server.on("error", (err) => {
-    console.error(
-      `错误：管理服务监听 ${listenPort} 失败（${err.code ?? err.message}）${err.code === "EADDRINUSE" ? "，端口被占用" : ""}`,
-    );
-    process.exit(1);
-  });
-
-  say(`ellm-proxy 管理服务已启动: http://127.0.0.1:${listenPort}`, ICONS.rocket);
-  say(
-    HAS_WEBUI
-      ? `   管理界面: http://127.0.0.1:${listenPort}/（web-ui，/api/* 反代主服务）`
-      : `   管理界面未托管：web-ui 构建产物缺失（${WEBUI_DIST_DIR}），仓库根执行 pnpm build:web 后重启本服务`,
-  );
-  say(
-    "   接口: GET /status /processes · POST /start /stop /restart · GET|POST /autostart · GET /update · POST /update/enabled|check|apply · GET /harness · POST /harness/claude-code /harness/codex /harness/dsh",
-  );
-  say("   CORS 已全放开（仅监听 127.0.0.1，不对外）");
-
-  // 自动更新看门狗：源码运行时内部直接返回（不轮询）；开关默认开启，每小时检查私有源新版本
-  startUpdateWatchdog(startOpts);
-}
-
-main();

package/utils/autostart.js

@@ -1,219 +0,0 @@
-// 开机自启核心（跨平台，登录时触发，均无需管理员权限）：状态探测 / 注册 / 移除 / 首启自愈。
-// 被 CLI（bin/commands/autostart.js）与管理服务（manager/api/service-settings.js）复用。
-// 本模块只做平台操作并返回数据，人读文案由调用方输出；错误以 throw 抛出（文案是契约的一部分）。
-// 自启项内容三平台一致：登录时执行 <nodePath> <包内 pm2 bin> resurrect（恢复最后一次 pm2 dump）：
-//   Windows: 启动文件夹 ellm-proxy-autostart.cmd（shell:startup——schtasks onlogon 需管理员，实测被拒）
-//   macOS:   LaunchAgent ~/Library/LaunchAgents/com.ellm-proxy.autostart.plist（launchctl load）
-//   Linux:   systemd user unit ~/.config/systemd/user/ellm-proxy.service（systemctl --user enable）
-// opt-out 标记（<appDir>/autostart.opt-out）：用户显式关闭过自启后，首启自愈不再自动重开
-//   （尊重用户选择）；enableAutostart 成功时清除，disableAutostart 成功时写入。
-import { writeFileSync, rmSync, existsSync, mkdirSync } from "node:fs";
-import { homedir, platform } from "node:os";
-import { spawn } from "node:child_process";
-import { join } from "node:path";
-import { defaultAppDir } from "./paths.js";
-import { resolveInterpreter } from "./interpreter.js";
-import { pm2BinJs } from "./pm2.js";
-
-const AUTOSTART_CMD = "ellm-proxy-autostart.cmd"; // Windows
-const PLIST_LABEL = "com.ellm-proxy.autostart"; // macOS
-const LINUX_UNIT = "ellm-proxy.service"; // Linux
-const OPT_OUT_FILE = "autostart.opt-out"; // appDir 下的 opt-out 标记文件名
-
-/** opt-out 标记路径（用户显式关闭过自启的持久标记，首启自愈据此跳过） */
-function optOutPath() {
-  return join(defaultAppDir, OPT_OUT_FILE);
-}
-
-/** 用户启动文件夹（Windows shell:startup）：登录时自动执行其中的脚本 */
-function windowsStartupDir() {
-  const dir = process.env["APPDATA"];
-  if (!dir) throw new Error("无法定位启动文件夹（APPDATA 环境变量未设置）。");
-  return join(dir, "Microsoft", "Windows", "Start Menu", "Programs", "Startup");
-}
-
-/** spawn 执行外部命令，返回退出码；进程无法启动（ENOENT 等）返回 127 */
-function runExit(cmd, args) {
-  return new Promise((resolvePromise) => {
-    const child = spawn(cmd, args, { stdio: "ignore", shell: false });
-    child.on("error", () => resolvePromise(127));
-    child.on("exit", (code) => resolvePromise(code ?? 1));
-  });
-}
-
-/** 各平台自启项路径（探测用；未知平台为 null） */
-function platformItemPath() {
-  switch (platform()) {
-    case "win32":
-      return join(windowsStartupDir(), AUTOSTART_CMD);
-    case "darwin":
-      return join(homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-    case "linux":
-      return join(homedir(), ".config", "systemd", "user", LINUX_UNIT);
-    default:
-      return null;
-  }
-}
-
-// —— 注册（各平台） ————————————————————————————————————————————————
-
-async function windowsOn(nodePath, pm2Js) {
-  // cmd 内容全 ASCII（含中文的注释交给外部帮助输出，避免 cmd 在 GBK 代码页下乱码）
-  const body = [
-    "@echo off",
-    `rem Auto-generated by "ellm-proxy autostart on". Disable with "ellm-proxy autostart off".`,
-    `"${nodePath}" "${pm2Js}" resurrect >nul 2>&1`,
-    "",
-  ].join("\r\n");
-  const itemPath = join(windowsStartupDir(), AUTOSTART_CMD);
-  writeFileSync(itemPath, body, "utf-8");
-  return itemPath;
-}
-
-async function darwinOn(nodePath, pm2Js) {
-  const itemPath = join(homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-  const logPath = join(defaultAppDir, "logs", "autostart.log");
-  mkdirSync(join(defaultAppDir, "logs"), { recursive: true });
-  const body = [
-    '<?xml version="1.0" encoding="UTF-8"?>',
-    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
-    '<plist version="1.0">',
-    "<dict>",
-    `  <key>Label</key><string>${PLIST_LABEL}</string>`,
-    "  <key>ProgramArguments</key>",
-    "  <array>",
-    `    <string>${nodePath}</string>`,
-    `    <string>${pm2Js}</string>`,
-    "    <string>resurrect</string>",
-    "  </array>",
-    "  <key>RunAtLoad</key><true/>",
-    `  <key>StandardOutPath</key><string>${logPath}</string>`,
-    `  <key>StandardErrorPath</key><string>${logPath}</string>`,
-    "</dict>",
-    "</plist>",
-    "",
-  ].join("\n");
-  writeFileSync(itemPath, body, "utf-8");
-  // 先卸载旧定义再加载（幂等；未加载过时 unload 报错属正常）
-  await runExit("launchctl", ["unload", itemPath]);
-  const code = await runExit("launchctl", ["load", itemPath]);
-  if (code !== 0) {
-    throw new Error(`launchctl load 失败（退出码 ${code}）。请手动执行: launchctl load "${itemPath}"`);
-  }
-  return itemPath;
-}
-
-async function linuxOn(nodePath, pm2Js) {
-  const itemPath = join(homedir(), ".config", "systemd", "user", LINUX_UNIT);
-  mkdirSync(join(homedir(), ".config", "systemd", "user"), { recursive: true });
-  const body = [
-    "[Unit]",
-    "Description=ellm-proxy autostart (pm2 resurrect)",
-    "After=default.target",
-    "",
-    "[Service]",
-    "Type=oneshot",
-    `ExecStart="${nodePath}" "${pm2Js}" resurrect`,
-    "",
-    "[Install]",
-    "WantedBy=default.target",
-    "",
-  ].join("\n");
-  writeFileSync(itemPath, body, "utf-8");
-  const reload = await runExit("systemctl", ["--user", "daemon-reload"]);
-  if (reload !== 0) {
-    throw new Error(
-      `systemctl --user daemon-reload 失败（退出码 ${reload}）。当前环境可能无 systemd（WSL/容器），请手动启用或删除: ${itemPath}`,
-    );
-  }
-  const enable = await runExit("systemctl", ["--user", "enable", LINUX_UNIT]);
-  if (enable !== 0) {
-    throw new Error(
-      `systemctl --user enable 失败（退出码 ${enable}）。请手动执行: systemctl --user enable ${LINUX_UNIT}`,
-    );
-  }
-  return itemPath;
-}
-
-// —— 移除（各平台） ————————————————————————————————————————————————
-
-async function windowsOff() {
-  const itemPath = join(windowsStartupDir(), AUTOSTART_CMD);
-  if (!existsSync(itemPath)) return false;
-  rmSync(itemPath, { force: true });
-  return true;
-}
-
-async function darwinOff() {
-  const itemPath = join(homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-  if (!existsSync(itemPath)) return false;
-  await runExit("launchctl", ["unload", itemPath]);
-  rmSync(itemPath, { force: true });
-  return true;
-}
-
-async function linuxOff() {
-  const itemPath = join(homedir(), ".config", "systemd", "user", LINUX_UNIT);
-  if (!existsSync(itemPath)) return false;
-  await runExit("systemctl", ["--user", "disable", LINUX_UNIT]); // 容错：未启用过时报错不影响删除
-  rmSync(itemPath, { force: true });
-  await runExit("systemctl", ["--user", "daemon-reload"]);
-  return true;
-}
-
-// —— 对外 API ——————————————————————————————————————————————————————
-
-/** 自启状态：enabled = 平台自启项是否存在；itemPath 未知平台为 null */
-export async function autostartStatus() {
-  const itemPath = platformItemPath();
-  return {
-    platform: platform(),
-    enabled: itemPath ? existsSync(itemPath) : false,
-    itemPath,
-    /** 用户是否显式关闭过（首启自愈据此跳过） */
-    optOut: existsSync(optOutPath()),
-  };
-}
-
-/** 注册自启项（幂等：重复注册覆盖旧文件；macOS 先 unload 再 load）。成功返回 { itemPath } */
-export async function enableAutostart() {
-  const pf = platform();
-  if (pf !== "win32" && pf !== "darwin" && pf !== "linux") {
-    throw new Error(`暂不支持的平台: ${pf}。可改用 pm2 自带的 pm2 startup。`);
-  }
-  const nodePath = await resolveInterpreter();
-  const pm2Js = pm2BinJs();
-  const itemPath = await (pf === "win32" ? windowsOn : pf === "darwin" ? darwinOn : linuxOn)(nodePath, pm2Js);
-  rmSync(optOutPath(), { force: true }); // 显式开启 = 清除 opt-out，首启自愈不再被视为已关闭
-  return { itemPath };
-}
-
-/** 移除自启项。返回 removed（此前是否存在）；成功后写 opt-out 标记（首启自愈不再自动重开） */
-export async function disableAutostart() {
-  const pf = platform();
-  if (pf !== "win32" && pf !== "darwin" && pf !== "linux") {
-    throw new Error(`暂不支持的平台: ${pf}。可改用 pm2 自带的 pm2 startup。`);
-  }
-  const removed = await (pf === "win32" ? windowsOff : pf === "darwin" ? darwinOff : linuxOff)();
-  mkdirSync(defaultAppDir, { recursive: true });
-  writeFileSync(optOutPath(), new Date().toISOString(), "utf-8");
-  return { removed };
-}
-
-/** 首启自愈（doStart 末尾静默调用）：自启项已存在或用户 opt-out 过则跳过，否则注册并提示一句。
- *  失败不抛出（不阻塞启动，console.warn 提示手动路径）。 */
-export async function ensureAutostartOnStart() {
-  try {
-    const status = await autostartStatus();
-    if (!status.itemPath || status.enabled) return; // 未知平台 / 已注册
-    if (status.optOut) {
-      console.log("已按此前设置保持开机自启关闭（如需开启：ellm-proxy autostart on 或管理台设置页）。");
-      return;
-    }
-    const { itemPath } = await enableAutostart();
-    console.log(`已自动注册开机自启（登录时 pm2 resurrect）: ${itemPath}`);
-    console.log("禁用方式: ellm-proxy autostart off 或管理台设置页。");
-  } catch (err) {
-    console.warn(`开机自启注册失败（不影响本次启动）: ${err?.message ?? err}`);
-  }
-}

package/utils/interpreter.js

@@ -1,14 +0,0 @@
-// 服务解释器解析：保证 dist/server.js（node:sqlite）运行在 Node >= MIN_NODE 上。
-// CLI 自身 node 满足 → process.execPath；否则 get-node 解析（缺失时下载一次并缓存），
-// pm2 daemon 的 node 版本无关紧要（interpreter 由本模块保证）。
-import getNode from "get-node";
-import { MIN_NODE, FALLBACK_NODE } from "./paths.js";
-
-export async function resolveInterpreter() {
-  const [maj, min] = process.version.replace(/^v/, "").split(".").map(Number);
-  if (maj > 22 || (maj === 22 && min >= 13)) return process.execPath;
-  console.log(`当前 node ${process.version} 不满足 ${MIN_NODE}，正在解析可用版本（缺失时自动下载一次并缓存）...`);
-  const { path, version } = await getNode(FALLBACK_NODE, { progress: true });
-  console.log(`服务将使用 node ${version}: ${path}`);
-  return path;
-}

package/utils/paths.js

@@ -1,45 +0,0 @@
-// 共享常量与路径工具：包根/应用目录常量、配置查找链、首次配置自愈、选项绝对化。
-// 供 CLI（bin/）与管理服务（manager/）两侧复用；工具一律返回数据，人读文案由调用方输出。
-import { readFileSync, mkdirSync, existsSync, copyFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-/** 本文件在 utils/ 下，包根为上一级 */
-export const pkgRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-export const defaultAppDir = join(homedir(), ".ellm-proxy");
-export const pkg = JSON.parse(readFileSync(join(pkgRoot, "package.json"), "utf-8"));
-export const APP_NAME = "ellm-proxy"; // 主服务（dist/server.js）的 pm2 进程名
-export const MANAGER_APP_NAME = "ellm-proxy-manager"; // 管理服务（manager/index.js）的 pm2 进程名
-export const MIN_NODE = ">=22.13.0"; // node:sqlite 最低版（与包 engines 一致）
-export const FALLBACK_NODE = "22"; // 兜底解释器锁定的主版本（满足 MIN_NODE，与 nve 22 口径一致）
-
-/** 配置文件路径：--config > ELLM_CONFIG 环境变量 > ~/.ellm-proxy/ellm.config.json（与 server 端查找链一致） */
-export function configPath(override) {
-  if (override) return resolve(override);
-  return process.env["ELLM_CONFIG"] ? resolve(process.env["ELLM_CONFIG"]) : join(defaultAppDir, "ellm.config.json");
-}
-
-/** 首次配置自愈：不存在则从包内示例复制创建，并提示两种修改方式 */
-export function ensureConfig(override) {
-  const config = configPath(override);
-  if (existsSync(config)) return config;
-  const example = join(pkgRoot, "ellm.config.example.json");
-  if (!existsSync(example)) {
-    throw new Error(`缺少示例配置 ${example}，无法自动创建配置文件`);
-  }
-  mkdirSync(dirname(config), { recursive: true });
-  copyFileSync(example, config);
-  console.log(`已创建配置文件: ${config}`);
-  console.log("可直接编辑该文件（填入供应商 apiKey），或经管理台在线修改（实时热更新）。");
-  return config;
-}
-
-/** 路径类选项统一转绝对路径（相对按调用方当前目录展开；CLI cwd 与 node 进程工作目录基准不同，透传相对串会错位） */
-export function absolutize(opts) {
-  const out = { ...opts };
-  for (const key of ["config", "dataDir", "workingDir", "serverJs"]) {
-    if (out[key]) out[key] = resolve(out[key]);
-  }
-  return out;
-}