ellm-proxy 0.0.7 → 0.0.8

package/manager/api/harness/dsh.js

@@ -1,175 +0,0 @@
-// DeepSeek Harness（dsh）代理开关：~/.dsh/settings.yaml 的 llm-deepseek.baseURL 指向本机网关，
-// 密钥写入官方托管凭据库 ~/.dsh/.credentials.yaml（refs.DEEPSEEK_API_KEY）。
-// dsh 解析口径（0.1.x developer preview）：llm-deepseek 适配器拼 {baseURL}/chat/completions，
-// 故 baseURL 需带 /v1；密钥解析优先级 = 进程环境变量 > .credentials.yaml > .env（进程已设
-// DEEPSEEK_API_KEY 时本开关写入的值不生效，需用户自行调整）。DSH_HOME env 可重定向 ~/.dsh。
-// YAML 解析/校验用 yaml 库 Document API（保留用户注释），不手写解析器；写盘前经库回读校验。
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join, dirname } from "node:path";
-import { parseDocument, isMap } from "yaml";
-import { backupOnce, restoreFromBackup } from "./backup.js";
-
-/** dsh 密钥引用名（llm-deepseek 的 apiKeyEnv 默认值） */
-const KEY_REF = "DEEPSEEK_API_KEY";
-/** 凭据文档 schema 版本（dsh credentials-local 的 version: 1） */
-const CREDENTIALS_VERSION = 1;
-/** 网关未配 masterKey 时写入的占位密钥（值任意：网关未设 masterKey 时放行，但 dsh 本地要求非空） */
-const PLACEHOLDER_KEY = "ellm-proxy";
-
-const dshHome = () => process.env.DSH_HOME || join(homedir(), ".dsh");
-const settingsFile = () => join(dshHome(), "settings.yaml");
-const credentialsFile = () => join(dshHome(), ".credentials.yaml");
-
-/** 去尾斜杠比较，容忍 http://x:1/ 与 http://x:1 视为同一地址 */
-function sameUrl(a, b) {
-  return String(a || "").replace(/\/+$/, "") === String(b || "").replace(/\/+$/, "");
-}
-
-function readTextIfExists(file) {
-  if (!existsSync(file)) return null;
-  const text = readFileSync(file, "utf-8");
-  return text.trim() === "" ? null : text; // 空文件按不存在处理（dsh：absent = empty store）
-}
-
-/** 解析 YAML 文档（不合法抛错，保留原文件语义同 claude-code 的 JSON 处理） */
-function parseYamlDoc(text, file) {
-  const doc = parseDocument(text);
-  if (doc.errors.length > 0) {
-    throw new Error(`${file} 不是合法 YAML，拒绝修改（请先手工修复）: ${doc.errors[0].message}`);
-  }
-  return doc;
-}
-
-/** 开关目标端点：dsh 适配器在 baseURL 后拼 /chat/completions，故带 /v1 走网关正式路由 */
-function targetBase(gatewayBase) {
-  return `${gatewayBase}/v1`;
-}
-
-/** dsh 开关状态：settings.yaml 的 llm-deepseek.baseURL 是否已指向网关（文件缺失/不合法按未开启） */
-export function dshStatus(gatewayBase) {
-  const text = readTextIfExists(settingsFile());
-  if (!text) return false;
-  try {
-    const data = parseYamlDoc(text, settingsFile()).toJS();
-    return sameUrl(data?.["llm-deepseek"]?.baseURL, targetBase(gatewayBase));
-  } catch {
-    return false;
-  }
-}
-
-/**
- * 开启 dsh 代理：备份 → settings.yaml 写 llm-deepseek.baseURL（幂等刷新）→
- * .credentials.yaml 写 refs.DEEPSEEK_API_KEY（masterKey 缺省时写占位值）。
- * 原文件不合法时直接报错（不覆盖坏文件）；凭据文档仅支持 version:1 与旧版扁平两种形态。
- */
-export function dshEnable({ gatewayBase, masterKey }) {
-  const target = targetBase(gatewayBase);
-
-  // 1) settings.yaml：先解析校验，后备份写入
-  mkdirSync(dshHome(), { recursive: true });
-  const settingsPath = settingsFile();
-  const origSettings = readTextIfExists(settingsPath);
-  const doc = origSettings === null ? parseYamlDoc("", settingsPath) : parseYamlDoc(origSettings, settingsPath);
-  const settingsData = doc.toJS();
-  if (settingsData && typeof settingsData["llm-deepseek"] !== "undefined" && typeof settingsData["llm-deepseek"] !== "object") {
-    throw new Error(`${settingsPath} 的 llm-deepseek 不是映射结构，拒绝修改`);
-  }
-  backupOnce(settingsPath);
-  doc.setIn(["llm-deepseek", "baseURL"], target);
-  writeValidatedYaml(settingsPath, doc);
-
-  // 2) .credentials.yaml：官方托管凭据库（优先级低于进程环境变量，高于 .env 两层）
-  const credPath = credentialsFile();
-  const key = masterKey || PLACEHOLDER_KEY;
-  const origCred = readTextIfExists(credPath);
-  backupOnce(credPath);
-  if (origCred === null) {
-    const credDoc = parseYamlDoc("", credPath);
-    credDoc.set("version", CREDENTIALS_VERSION);
-    credDoc.setIn(["refs", KEY_REF], key);
-    writeValidatedYaml(credPath, credDoc);
-    return;
-  }
-  const credDoc = parseYamlDoc(origCred, credPath);
-  const credData = credDoc.toJS();
-  if (!isMap(credDoc.contents)) throw new Error(`${credPath} 根节点不是映射结构，拒绝修改`);
-  if (typeof credData.version !== "undefined" && credData.version !== CREDENTIALS_VERSION) {
-    throw new Error(`${credPath} 的 version 为 ${credData.version}，本开关仅支持 version: ${CREDENTIALS_VERSION}`);
-  }
-  if (typeof credData.version === "undefined") {
-    // 旧版扁平文档（dsh 启动时会自行迁移为 version:1）：保持扁平形态写入
-    const flat = Object.values(credData).every((v) => typeof v === "string" && v.length > 0);
-    if (!flat) throw new Error(`${credPath} 既非 version:1 也非旧版扁平结构，请手工整理后重试`);
-    credDoc.set(KEY_REF, key);
-  } else {
-    if (typeof credData.refs !== "undefined" && (typeof credData.refs !== "object" || credData.refs === null)) {
-      throw new Error(`${credPath} 的 refs 不是映射结构，拒绝修改`);
-    }
-    credDoc.setIn(["refs", KEY_REF], key);
-  }
-  writeValidatedYaml(credPath, credDoc);
-}
-
-/**
- * 关闭 dsh 代理：优先从备份还原两个文件（各自独立备份）；无备份时移除本开关写入的字段——
- * settings.yaml 仅在 baseURL 仍指向网关时移除（连带清理空 llm-deepseek 段）；
- * 凭据库仅在 DEEPSEEK_API_KEY 取值为本开关写入值（masterKey 或占位值）时移除，避免误删用户自己的官方 key。
- * 返回是否实际发生了还原/移除。
- */
-export function dshDisable(gatewayBase, masterKey) {
-  const settingsPath = settingsFile();
-  const credPath = credentialsFile();
-  let changed = false;
-
-  if (restoreFromBackup(settingsPath)) {
-    changed = true;
-  } else {
-    const text = readTextIfExists(settingsPath);
-    if (text) {
-      const doc = parseYamlDoc(text, settingsPath);
-      const data = doc.toJS();
-      if (sameUrl(data?.["llm-deepseek"]?.baseURL, targetBase(gatewayBase))) {
-        doc.deleteIn(["llm-deepseek", "baseURL"]);
-        const rest = doc.toJS()?.["llm-deepseek"];
-        if (!rest || typeof rest !== "object" || Object.keys(rest).length === 0) doc.deleteIn(["llm-deepseek"]);
-        writeValidatedYaml(settingsPath, doc);
-        changed = true;
-      }
-    }
-  }
-
-  if (restoreFromBackup(credPath)) {
-    changed = true;
-  } else {
-    const text = readTextIfExists(credPath);
-    if (text) {
-      const doc = parseYamlDoc(text, credPath);
-      const data = doc.toJS();
-      const ours = (v) => v === masterKey || v === PLACEHOLDER_KEY;
-      if (data?.version === CREDENTIALS_VERSION && ours(data?.refs?.[KEY_REF])) {
-        doc.deleteIn(["refs", KEY_REF]);
-        if (Object.keys(doc.toJS()?.refs ?? {}).length === 0) doc.deleteIn(["refs"]);
-        writeValidatedYaml(credPath, doc);
-        changed = true;
-      } else if (typeof data?.version === "undefined" && ours(data?.[KEY_REF])) {
-        doc.deleteIn([KEY_REF]);
-        writeValidatedYaml(credPath, doc);
-        changed = true;
-      }
-    }
-  }
-  return changed;
-}
-
-/** 写盘前经库回读校验（结果必须可解析），失败保留原文件 */
-function writeValidatedYaml(file, doc) {
-  const text = doc.toString();
-  try {
-    parseDocument(text);
-  } catch (err) {
-    throw new Error(`编辑后的 ${file} 不是合法 YAML，已保留原文件: ${err.message}`);
-  }
-  mkdirSync(dirname(file), { recursive: true });
-  writeFileSync(file, text, "utf-8");
-}

package/manager/api/harness/index.js

@@ -1,118 +0,0 @@
-// harness 代理开关聚合：Claude Code / Codex CLI / DeepSeek Harness 流量指向本机 ellm-proxy 网关。
-//   纯开关实现：claude-code.js（~/.claude/settings.json）/ codex.js（~/.codex/config.toml）/
-//   dsh.js（~/.dsh/settings.yaml + ~/.dsh/.credentials.yaml）/ backup.js（共用备份还原）
-//   createHarnessApp = HTTP 路由子应用（挂载于 /harness）：状态查询 + 开关切换（含 masterKey 校验与提示文案）
-import { Hono } from "hono";
-import { readFileSync } from "node:fs";
-import { resolveGatewayBase } from "../../../utils/service.js";
-import { claudeCodeStatus, claudeCodeEnable, claudeCodeDisable } from "./claude-code.js";
-import { codexStatus, codexEnable, codexDisable } from "./codex.js";
-import { dshStatus, dshEnable, dshDisable } from "./dsh.js";
-
-/** 配置文件顶层 masterKey（Claude Code 代理的 AUTH_TOKEN 取值；网关侧用它做鉴权） */
-function readMasterKey(configFile) {
-  try {
-    return JSON.parse(readFileSync(configFile, "utf-8")).masterKey || "";
-  } catch {
-    return "";
-  }
-}
-
-/** harness 开关子应用（挂载于 /harness）：GET / · POST /claude-code · POST /codex · POST /dsh（body {enabled}） */
-export function createHarnessApp({ startOpts }) {
-  const app = new Hono();
-
-  // GET /harness：三个开关状态
-  app.get("/", (c) => {
-    const { base } = resolveGatewayBase(startOpts.config);
-    return c.json({ ok: true, claudeCode: claudeCodeStatus(base), codex: codexStatus(), dsh: dshStatus(base), gatewayBase: base });
-  });
-
-  /** 读 body 并校验 enabled；合法返回 boolean，非法返回 400 Response（调用方直接 return 该响应） */
-  const requireEnabled = async (c) => {
-    let enabled;
-    try {
-      enabled = (await c.req.json())?.enabled;
-    } catch {
-      return c.json({ ok: false, error: "请求体不是合法 JSON" }, 400);
-    }
-    if (typeof enabled !== "boolean") {
-      return c.json({ ok: false, error: 'body 需为 {"enabled": true|false}' }, 400);
-    }
-    return enabled;
-  };
-
-  app.post("/claude-code", async (c) => {
-    const enabled = await requireEnabled(c);
-    if (enabled instanceof Response) return enabled;
-    const { base, configFile } = resolveGatewayBase(startOpts.config);
-    if (enabled) {
-      const masterKey = readMasterKey(configFile);
-      if (!masterKey) {
-        return c.json(
-          {
-            ok: false,
-            error: `配置未设置 masterKey，Claude Code 代理无法鉴权。请先在配置文件中设置 masterKey: ${configFile}`,
-          },
-          400,
-        );
-      }
-      claudeCodeEnable({ gatewayBase: base, token: masterKey });
-      return c.json({
-        ok: true,
-        claudeCode: true,
-        file: "~/.claude/settings.json",
-        note: "已备份原文件为 settings.json.ellm-bak，重启 Claude Code 会话后生效",
-      });
-    }
-    const changed = claudeCodeDisable(base);
-    return c.json({ ok: true, claudeCode: false, changed, note: changed ? "已从备份还原" : "原本未开启，无操作" });
-  });
-
-  app.post("/codex", async (c) => {
-    const enabled = await requireEnabled(c);
-    if (enabled instanceof Response) return enabled;
-    const { base, configFile } = resolveGatewayBase(startOpts.config);
-    if (enabled) {
-      codexEnable({ gatewayBase: base });
-      const masterKey = readMasterKey(configFile);
-      return c.json({
-        ok: true,
-        codex: true,
-        file: "~/.codex/config.toml",
-        note: masterKey
-          ? `已备份原文件为 config.toml.ellm-bak；请设置环境变量 ELLM_PROXY_API_KEY=${masterKey}（Codex 以 env_key 读取鉴权）`
-          : "已备份原文件为 config.toml.ellm-bak；请设置环境变量 ELLM_PROXY_API_KEY（网关未配 masterKey 时取值任意）",
-      });
-    }
-    const changed = codexDisable();
-    return c.json({ ok: true, codex: false, changed, note: changed ? "已从备份还原" : "原本未开启，无操作" });
-  });
-
-  app.post("/dsh", async (c) => {
-    const enabled = await requireEnabled(c);
-    if (enabled instanceof Response) return enabled;
-    const { base, configFile } = resolveGatewayBase(startOpts.config);
-    const masterKey = readMasterKey(configFile);
-    if (enabled) {
-      dshEnable({ gatewayBase: base, masterKey });
-      return c.json({
-        ok: true,
-        dsh: true,
-        file: "~/.dsh/settings.yaml",
-        note: masterKey
-          ? "已写入 settings.yaml（llm-deepseek.baseURL）与 .credentials.yaml（refs.DEEPSEEK_API_KEY），原文件备份为 *.ellm-bak。注意：进程环境里已设 DEEPSEEK_API_KEY 时其优先级更高，需自行改用网关 masterKey；模型请在 dsh 内选择与网关部署名一致的模型"
-          : "已写入 settings.yaml 与 .credentials.yaml（网关未配 masterKey，密钥为占位值即可放行），原文件备份为 *.ellm-bak。模型请在 dsh 内选择与网关部署名一致的模型",
-      });
-    }
-    const changed = dshDisable(base, masterKey);
-    return c.json({ ok: true, dsh: false, changed, note: changed ? "已从备份还原（或移除本开关写入的字段）" : "原本未开启，无操作" });
-  });
-
-  return app;
-}
-
-// 纯开关函数同时聚合导出（供不经过 HTTP 的调用方直接使用）
-export * from "./claude-code.js";
-export * from "./codex.js";
-export * from "./dsh.js";

package/manager/api/service-settings.js

@@ -1,98 +0,0 @@
-// 服务设置 api 子应用：开机自启开关 + 自动更新（检查/开关/手动触发）。
-// 与 api/service.js（进程控制）、api/harness/（代理开关）平级的第三域，路由形状/响应约定一致
-// （{ok,...} 或 {ok:false,error}）；实现在 utils/autostart.js 与 utils/updater.js（CLI 侧复用）。
-import { Hono } from "hono";
-import { autostartStatus, enableAutostart, disableAutostart } from "../../utils/autostart.js";
-import {
-  readUpdaterSettings,
-  writeUpdaterSettings,
-  checkForUpdate,
-  performUpdate,
-  isUpdateSupported,
-  isUpdating,
-} from "../../utils/updater.js";
-
-/** 读 body 并校验 enabled；合法返回 boolean，非法返回 400 Response（调用方直接 return 该响应） */
-async function requireEnabled(c) {
-  let enabled;
-  try {
-    enabled = (await c.req.json())?.enabled;
-  } catch {
-    return c.json({ ok: false, error: "请求体不是合法 JSON" }, 400);
-  }
-  if (typeof enabled !== "boolean") {
-    return c.json({ ok: false, error: 'body 需为 {"enabled": true|false}' }, 400);
-  }
-  return enabled;
-}
-
-/** 服务设置子应用：GET/POST /autostart · GET /update · POST /update/enabled|check|apply */
-export function createServiceSettingsApp({ startOpts }) {
-  const app = new Hono();
-
-  // —— 开机自启 ——————————————————————————————————————————————
-  app.get("/autostart", async (c) => c.json({ ok: true, ...(await autostartStatus()) }));
-
-  app.post("/autostart", async (c) => {
-    const enabled = await requireEnabled(c);
-    if (enabled instanceof Response) return enabled;
-    if (enabled) {
-      const { itemPath } = await enableAutostart();
-      return c.json({ ok: true, enabled: true, itemPath, note: "已注册自启项，下次登录时 pm2 resurrect 恢复服务" });
-    }
-    const { removed } = await disableAutostart();
-    return c.json({
-      ok: true,
-      enabled: false,
-      removed,
-      note: removed ? "已移除自启项，且首次启动不再自动注册（重新开启即可解除）" : "原本未开启，无操作",
-    });
-  });
-
-  // —— 自动更新 ——————————————————————————————————————————————
-  app.get("/update", (c) => {
-    const settings = readUpdaterSettings();
-    return c.json({
-      ok: true,
-      enabled: settings.enabled,
-      lastCheck: settings.lastCheck,
-      lastApply: settings.lastApply,
-      supported: isUpdateSupported(),
-      updating: isUpdating(),
-    });
-  });
-
-  app.post("/update/enabled", async (c) => {
-    const enabled = await requireEnabled(c);
-    if (enabled instanceof Response) return enabled;
-    writeUpdaterSettings({ enabled });
-    return c.json({
-      ok: true,
-      enabled,
-      note: enabled
-        ? "自动更新已开启（看门狗随下次 manager 启动生效；当前周期内手动检查不受影响）"
-        : "自动更新已关闭（看门狗在下次 tick 时停止）",
-    });
-  });
-
-  app.post("/update/check", async (c) => {
-    const result = await checkForUpdate();
-    return c.json({ ok: true, ...result });
-  });
-
-  app.post("/update/apply", async (c) => {
-    if (!isUpdateSupported()) {
-      return c.json({ ok: false, error: "当前为源码运行模式，更新功能不可用（仅 npm 全局安装的包支持自动更新）" }, 400);
-    }
-    const result = await performUpdate(startOpts);
-    return c.json({
-      ok: true,
-      ...result,
-      note: result.updated
-        ? `已更新 ${result.fromVersion} → ${result.toVersion}：主服务已重启，管理服务将在数秒后自重启（期间界面请求可能瞬时失败）`
-        : `已是最新版本 ${result.toVersion}`,
-    });
-  });
-
-  return app;
-}

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;
-}