@lancewu602/mihomo-dash 0.0.0-stage → 0.6.1

package/server/src/http/kernel-admin.js

@@ -0,0 +1,522 @@
+/**
+ * 内核管理接口（面板「内核」页的后端）：状态 / 安装 / 升级 / 卸载 / 启停重启 / 日志。
+ *
+ * 2026-10 的决定：内核的装/升/卸/启停从 CLI 整体搬进面板（`mihomo-dash kernel` 已删除），
+ * 面板因此**不再对内核只读** —— 它会替换可执行文件。这个风险是明确接受的
+ * （面板仍只监听 127.0.0.1、无鉴权），要收紧就得先把 token 鉴权做出来。
+ *
+ * 三条自己给自己加的约束：
+ * - **只动面板自有落点** `MIHOMO_DASH_DIR/bin/mihomo`：主机上就当只有面板自己这一个内核，
+ *   既不去探测 PATH / brew / 包管理器里有没有别的 mihomo，也不会去覆盖别处的文件。
+ * - **不联网**（2026-11 改）：安装包必须由用户本机上传（浏览器 raw body 落成临时文件，
+ *   再走同一条安装流水线）。面板不去 GitHub 查版本、不去下载二进制，也不缓存 release ——
+ *   要新版本就自己去 release 页面下好，然后在页面上传。
+ * - 安装是**后台任务**：HTTP 只负责启动与轮询（拷包 / 解压 / 试跑不能让请求一直挂着），
+ *   进度 / 消息 / 结果都留在进程内的 job 状态里、**不落盘**（`install.log` 已在 2026-11 去掉：
+ *   任务重启就没了，想要持久化日志就用下面的内核日志），前端轮询 `GET /api/kernel-admin/install`。
+ *   装完**只把文件就位、不动正在跑的进程**：内核只在启动时加载二进制，所以新版本得用户
+ *   去侧栏点「重启内核」才生效（旧版本留一个 `.bak-<版本>` 备份，纯手工兜底，没有自动回滚）。
+ */
+import express from 'express';
+import fs from 'node:fs';
+import path from 'node:path';
+import {
+  CLI_DIR,
+  KERNEL_BIN,
+  KERNEL_CONFIG_DIR,
+  KERNEL_LOG_FILE,
+  KERNEL_META_FILE,
+  KERNEL_PID_FILE,
+  detectMihomoDir,
+  ensureCliDir,
+  resetMihomoDirCache,
+} from '../shared/paths.js';
+import { readKernelVersion } from '../kernel/binary.js';
+import { readTailLines } from '../shared/log-file.js';
+import {
+  archiveExt,
+  assetTarget,
+  assertBinaryArchive,
+  sniffArchiveExt,
+} from '../kernel/archive.js';
+import { currentInstall, performInstall, readLedger, removeInstalled } from '../kernel/install.js';
+import { resetControllerCache } from '../kernel/client.js';
+import { DEFAULT_CONFIG, writeDefaultConfig } from './default-config.js';
+
+export { DEFAULT_CONFIG, writeDefaultConfig };
+import {
+  disableSystemProxyIfOn as defaultDisableSystemProxy,
+  readSystemProxyState as defaultReadSystemProxy,
+} from './system-proxy.js';
+import {
+  kernelRestart,
+  kernelStart,
+  kernelStop,
+  ownKernelRunning,
+  probeKernel,
+} from '../kernel/lifecycle.js';
+
+/** 日志一次最多回显多少行 */
+const MAX_LOG_TAIL = 2000;
+/** 上传安装包的体积上限（官方 .gz 约 20 MB，给足余量） */
+const MAX_UPLOAD = '300mb';
+/** 启动失败原因码 → 人话；带动态信息的原因码（no-config-in-dir / no-controller / controller-changed / not-ready）由 startFailureText 拼文案 */
+const START_REASON = {
+  'no-binary': '面板自有内核没装：先在这个页面安装',
+  'already-running': '自有内核已在运行（要重启用侧栏的「重启内核」）',
+  'port-occupied':
+    '控制接口已被占用：先停掉占着那个端口的进程，或改 config.yaml 的 external-controller',
+};
+
+/**
+ * 启动 / 重启失败时的文案：带上前置检查里拿到的具体路径、地址，让用户能自己改。
+ * 尤其是「配置里没有 external-controller」这类情况：内核照样能跑，只是根本不开控制接口，
+ * 面板只会得到一句「控制接口不通」，看不出真正的原因。
+ * @param {{ reason?: string, dir?: string, configFile?: string, api?: string, panelUrl?: string }} res
+ */
+function startFailureText(res) {
+  switch (res.reason) {
+    case 'no-config-in-dir':
+      return (
+        `${res.dir} 里没有 config.yaml。内核只在配置文件里认 external-controller，` +
+        '所以它会自己生成一份只开 mixed-port 的初始配置（不监听控制接口），面板永远连不上它。\n' +
+        '把配置放进这个目录，或把这份内核配置目录改成面板探测到的那个（安装内核时面板会写一份最小默认配置进去）'
+      );
+    case 'no-controller':
+      return (
+        `${res.configFile} 里没有 external-controller，内核不会开控制接口，面板连不上它。\n` +
+        '在「配置文件」页给它加一行 external-controller: 127.0.0.1:8190（再用侧栏的「重启内核」生效）'
+      );
+    case 'controller-changed':
+      return (
+        `配置里的控制接口是 ${res.api}，面板记的还是 ${res.panelUrl}（启动面板时读的）：` +
+        'external-controller 改完要重启面板才生效'
+      );
+    case 'not-ready':
+      return `控制接口 ${res.api} 不通（内核配置目录 ${res.dir}），看下方日志`;
+    default:
+      return START_REASON[res.reason] || `启动失败：${res.reason}`;
+  }
+}
+
+/** 安装包文件名白名单（会被拼进临时文件名，所以卡严一点） */
+const ASSET_RE = /^[0-9A-Za-z][0-9A-Za-z._-]*$/;
+
+function formatSize(bytes) {
+  if (!bytes) return '';
+  return `${(bytes / 1048576).toFixed(1)} MB`;
+}
+
+/**
+ * 安装的前置校验：上传的临时文件必须存在、是普通文件、且**按内容**确实是 .gz / .zip 压缩包
+ * （浏览器给的文件名可能被改过，内容说了算；.deb / .dmg / 纯可执行文件这类一律拒）。
+ * @param {string} file
+ * @returns {'gz'|'zip'}
+ */
+function assertLocalArchive(file) {
+  let st;
+  try {
+    st = fs.statSync(file);
+  } catch {
+    throw new Error(`本地文件不存在：${file}`);
+  }
+  if (!st.isFile()) throw new Error(`不是一个文件：${file}`);
+  if (st.size < 1024) throw new Error(`文件太小（${st.size} 字节），不像是官方 release 的压缩包`);
+  const ext = sniffArchiveExt(file);
+  if (!ext) {
+    throw new Error(
+      `认不出这个压缩包：${file}\n` +
+        '只支持官方 release 的 .gz（darwin / linux）或 .zip（Windows），里面是单个 mihomo 可执行文件',
+    );
+  }
+  return ext;
+}
+
+/**
+ * **首次安装**的收尾：把面板自有内核的配置写成最小默认配置（`data/config.yaml`）。
+ * 只在落点原本没有内核二进制时调用 —— **升级不动配置**（见安装任务里那一段），这条路才走。
+ *
+ * **不管原来那份是什么，一律覆盖**（2026-11 定为这样）：内核自己生成的 16 字节初始配置、
+ * 手写的裸配置、甚至带着订阅的配置，都换成面板这份最小配置（全直连、`external-controller:
+ * 127.0.0.1:8190`），所以**不做备份、不做回滚**；升级内核也会重写它（订阅需要重新加）。
+ * 别处的配置目录（brew / 系统包管理）一概不碰。
+ * @param {(text: string, level?: string) => void} say
+ * @returns {{ dir: string }}
+ */
+function ensureConfig(say) {
+  const dir = KERNEL_CONFIG_DIR;
+  if (fs.existsSync(path.join(dir, 'config.yaml'))) {
+    say('面板配置目录里已有一份 config.yaml：直接覆盖它（不备份）', 'warn');
+  }
+  say(`已写入最小默认配置：${writeDefaultConfig(dir)}`);
+  say('这份配置全是直连（没有节点）：要节点去「节点」页添加订阅', 'warn');
+
+  // 内核实际会用哪个目录？写盘后重新探测一次（常量 KERNEL_CONFIG_DIR 通常就是它，但 MIHOMO_DIR 优先级更高）
+  const used = detectMihomoDir();
+  if (used && path.resolve(used) !== path.resolve(dir)) {
+    say(
+      `注意：内核实际会用 ${used} 那份配置（环境变量 MIHOMO_DIR 优先于状态目录的 data/），` +
+        '要在面板里改配置得把它清掉或改成 data/',
+      'warn',
+    );
+  }
+  return { dir };
+}
+
+/** 面板自有内核的静态信息（不联网、会跑一次 `-v`） */
+async function describeOwn() {
+  const entry = currentInstall();
+  const exists = fs.existsSync(KERNEL_BIN);
+  return {
+    path: KERNEL_BIN,
+    installed: exists,
+    version: exists ? entry?.version || (await readKernelVersion(KERNEL_BIN)) : null,
+    entry: entry || null,
+  };
+}
+
+/**
+ * 内核管理（一个实例持有自己的安装任务状态，测试可以各起一份）。
+ */
+export function createKernelAdmin(opts = {}) {
+  /** 停内核前「如果系统代理开着就先关掉」；测试注入桩，避免碰真实本机设置 */
+  const disableSystemProxy = opts.disableSystemProxy || defaultDisableSystemProxy;
+  /** 只读探测系统代理（卸载的前置检查用）；测试同样注入桩 */
+  const readSystemProxy = opts.readSystemProxy || defaultReadSystemProxy;
+  /** 内存里的安装任务（单例：同时只跑一个） */
+  let installJob = null;
+
+  /** 内核页首屏数据：自有内核 + 台账 + 运行状态 */
+  async function overview() {
+    const running = ownKernelRunning();
+    const probe = await probeKernel();
+    return {
+      own: await describeOwn(),
+      ledger: readLedger().installed,
+      running: { running: running.running, pid: running.pid, meta: running.meta, probe },
+      configDir: detectMihomoDir(),
+      platform: process.platform,
+      arch: process.arch,
+      // 本机该下哪个资产（纯字符串拼出来的提示，不联网）：页面告诉用户去 release 页面拿哪一个
+      assetTarget: assetTarget(),
+      archiveExt: archiveExt(),
+      job: jobView(),
+    };
+  }
+
+  /** job 快照（含「有没有在跑」与产出的台账条目） */
+  function jobView() {
+    if (!installJob) {
+      return {
+        running: false,
+        phase: 'idle',
+        messages: [],
+        progress: { written: 0, total: 0 },
+        result: null,
+        config: null,
+      };
+    }
+    return {
+      id: installJob.id,
+      running: installJob.running,
+      phase: installJob.phase,
+      startedAt: installJob.startedAt,
+      finishedAt: installJob.finishedAt,
+      progress: installJob.progress,
+      messages: installJob.messages,
+      result: installJob.result,
+      config: installJob.config,
+      error: installJob.error,
+    };
+  }
+
+  /**
+   * 安装 / 升级：立刻返回，真正的活在后台跑（拷包 / 解压 / 试跑 / 替换），前端轮询 jobView()。
+   * 只接受**本机已存在的安装包**：浏览器上传时它是状态目录下的临时文件（`cleanupFile` 为真时
+   * 任务结束就删），版本号由安装包自己（`mihomo -v`）决定，不需要外部告诉我们。
+   * @param {{ file?: string, name?: string, sha256?: string, cleanupFile?: boolean }} [input]
+   */
+  function startInstall(input = {}) {
+    if (installJob?.running) throw new Error('已有安装任务在进行中，等它结束');
+    const localFile =
+      typeof input.file === 'string' && input.file.trim() ? path.resolve(input.file) : null;
+    if (!localFile) throw new Error('没有收到安装包：请选择官方 release 的 .gz / .zip 压缩包');
+    const name = assertBinaryArchive(
+      typeof input.name === 'string' && input.name.trim()
+        ? input.name.trim()
+        : path.basename(localFile),
+    );
+    if (!ASSET_RE.test(name)) throw new Error(`安装包文件名不合法：${name}`);
+    const localExt = assertLocalArchive(localFile);
+    const sha256 =
+      typeof input.sha256 === 'string' && input.sha256.trim() ? input.sha256.trim() : undefined;
+    if (sha256 && !/^[0-9a-fA-F]{64}$/.test(sha256)) throw new Error('sha256 应为 64 位十六进制');
+
+    installJob = {
+      id: `${Date.now()}`,
+      running: true,
+      phase: 'checking',
+      startedAt: Date.now(),
+      finishedAt: null,
+      progress: { written: 0, total: 0 },
+      messages: [],
+      result: null,
+      config: null,
+      error: null,
+    };
+    const job = installJob;
+    /** 一条消息：只留在内存里给页面轮询（不写文件，见文件头「安装是后台任务」） */
+    const say = (text, level = 'info') => {
+      job.messages.push({ at: Date.now(), level, text });
+    };
+
+    (async () => {
+      try {
+        // 落点原本有没有内核 = 这次是「升级」还是「首次安装」，后面写不写配置就看它
+        const upgrade = fs.existsSync(KERNEL_BIN);
+        say(`安装包: ${name}（${formatSize(fs.statSync(localFile).size)}）`);
+        say(
+          `落点: ${KERNEL_BIN}` +
+            (upgrade ? `（现有 v${(await readKernelVersion(KERNEL_BIN)) || '未知'}，会备份）` : ''),
+        );
+        say('来源: 本地上传的安装包');
+
+        job.phase = 'installing';
+        const entry = await performInstall({
+          localFile,
+          ext: localExt,
+          asset: name,
+          target: KERNEL_BIN,
+          sha256,
+          onProgress: (written, total) => {
+            job.progress = { written, total };
+          },
+        });
+        say(`已安装: v${entry.version} → ${entry.path}`);
+        say(`sha256: ${entry.sha256}`);
+        if (entry.backup) say(`备份: ${entry.backup}`);
+        job.result = entry;
+        // 配置只在**首次安装**时写（写最小默认配置，已有的一律覆盖，不备份）；
+        // 升级只替换二进制，`data/config.yaml` 一个字都不动（订阅 / 策略组 / 分流都留着）。
+        if (upgrade) {
+          say('升级：只替换内核二进制，配置（data/config.yaml）未动');
+          job.config = { dir: KERNEL_CONFIG_DIR, skipped: true, reason: 'upgrade' };
+        } else {
+          job.config = ensureConfig(say);
+        }
+        // 安装**不动正在跑的进程**：内核只在启动时加载二进制，所以新版本要重启进程才生效
+        say('文件已就位（正在跑的进程没有动）：要生效用侧栏底部的「重启内核」');
+        job.phase = 'done';
+      } catch (err) {
+        job.phase = 'failed';
+        job.error = String(err?.message || err);
+        say(job.error, 'error');
+      } finally {
+        job.running = false;
+        job.finishedAt = Date.now();
+        say(job.error ? '任务结束: 失败' : '任务结束: 成功', job.error ? 'error' : 'info');
+        // 浏览器上传来的文件是一次性的：任务结束就删（本机路径那种不动用户自己的文件）
+        if (input.cleanupFile && localFile) {
+          try {
+            fs.rmSync(localFile, { force: true });
+          } catch {
+            /* 删不掉就留着 */
+          }
+        }
+      }
+    })();
+
+    return jobView();
+  }
+
+  /**
+   * 卸载面板自有内核：删二进制（含备份）、台账、runtime 文件与安装日志，最后把面板自有配置目录
+   * `MIHOMO_DASH_DIR/data/` 整个删掉（config.yaml / providers / cache.db / GEO 数据都在里面，**不备份**）。
+   * 只动面板自己的东西，别处的配置目录一概不碰。
+   *
+   * **两道前置检查（2026-11 按用户要求）**：内核进程必须已经停了、系统代理必须已经关了，否则直接 400 拒绝 ——
+   * 卸载不再替用户去杀进程 / 关系统代理（那两件事各有入口：侧栏「停止内核」、顶栏系统代理开关）。
+   */
+  async function uninstall() {
+    if (installJob?.running) throw new Error('安装任务进行中，等它结束再卸载');
+
+    // 前置检查（2026-11 按用户要求：不满足就直接拒绝，卸载不再替用户收尾）——
+    // ① 内核进程必须已经停了：让面板去杀一个用户以为自己在管的进程太粗暴，而且他可能只是想把二进制删了
+    const running = ownKernelRunning();
+    if (running.running) {
+      throw new Error(`内核还在运行（pid ${running.pid}）：先点侧栏底部的「停止内核」，再来卸载`);
+    }
+    // ② 系统代理必须已经关了：否则卸载后系统还把流量交给没人监听的端口，表现就是「突然上不了网」
+    const proxy = await readSystemProxy();
+    if (proxy.enabled) {
+      throw new Error(
+        '系统代理还开着：先在顶栏把它关掉（系统直连），再来卸载 —— 否则卸载后系统会把流量交给没人监听的端口',
+      );
+    }
+
+    const removed = removeInstalled(KERNEL_BIN);
+    // runtime 文件 + 旧版遗留：release-cache.json（2026-11 前「联网查版本」的缓存）、
+    // install.log（2026-11 前的安装过程日志，现在只在内存里，已没有这个文件）
+    for (const f of [
+      KERNEL_PID_FILE,
+      KERNEL_META_FILE,
+      KERNEL_LOG_FILE,
+      path.join(CLI_DIR, 'release-cache.json'),
+      path.join(CLI_DIR, 'install.log'),
+    ]) {
+      fs.rmSync(f, { force: true });
+    }
+    // 内存里那份安装日志（job 快照）也要清：卸载完不该还留着上一次安装任务的过程与结果
+    installJob = null;
+
+    // 面板自有配置目录（data/）整个删掉：它只属于面板自己装的这个内核
+    let removedConfigDir = null;
+    if (fs.existsSync(KERNEL_CONFIG_DIR)) {
+      fs.rmSync(KERNEL_CONFIG_DIR, { recursive: true, force: true });
+      removedConfigDir = KERNEL_CONFIG_DIR;
+      // 配置目录没了，两个缓存都得失效：不然 overview/探活 还会去找那份已经不存在的配置
+      resetMihomoDirCache();
+      resetControllerCache();
+    }
+    return { removed, removedConfigDir, ...(await overview()) };
+  }
+
+  /** 拉起自有内核进程 */
+  async function start() {
+    const res = await kernelStart({ bin: KERNEL_BIN });
+    if (!res.ok) throw new Error(startFailureText(res));
+    return { pid: res.pid, ...(await overview()) };
+  }
+
+  /** 停掉自有内核进程（只杀 pid 文件里那一个） */
+  async function stop() {
+    // 先检查系统代理：内核一停，系统代理指向的 mixed-port 就没人监听了，用户会以为「断网了」。
+    // 系统代理开着的话先关掉（= 系统直连），再去停进程。
+    const systemProxy = await disableSystemProxy();
+    const stopped = await kernelStop({ quiet: true });
+    return { stopped, systemProxy, ...(await overview()) };
+  }
+
+  /** 重启自有内核进程（沿用 start 时记下的二进制与配置目录） */
+  async function restart() {
+    const res = await kernelRestart({ bin: KERNEL_BIN });
+    if (!res.ok) throw new Error(startFailureText(res));
+    return { pid: res.pid, ...(await overview()) };
+  }
+
+  /**
+   * 自有内核日志尾部（stdout/stderr 都写在这个文件里）。
+   * 只从文件末尾按块往前读（`shared/log-file.js`）：内核日志没有大小上限，全量读进来会给
+   * 内核页那个 2s 轮询变成「每次都把几十 MB 读一遍」。
+   */
+  function readLog(tail = 200) {
+    const n = Math.min(Math.max(Number(tail) || 200, 1), MAX_LOG_TAIL);
+    const { lines, missing } = readTailLines(KERNEL_LOG_FILE, { lines: n });
+    if (missing) return { file: KERNEL_LOG_FILE, lines: [], missing: true };
+    return { file: KERNEL_LOG_FILE, lines: lines.filter((l) => l !== '') };
+  }
+
+  /**
+   * 挂上 `/api/kernel-admin*` 一组端点。
+   * @param {import('express').Express} app
+   */
+  function registerRoutes(app) {
+    const fail = (res, err, code = 400) =>
+      res.status(code).json({ error: String(err?.message || err) });
+
+    app.get('/api/kernel-admin', async (_req, res) => {
+      try {
+        res.json(await overview());
+      } catch (err) {
+        fail(res, err, 500);
+      }
+    });
+
+    // 安装 / 升级：只认**上传的安装包**（raw body 直接落成状态目录下的临时文件，再走安装流水线）。
+    // 不用 multipart —— 那要引 multer，而本项目运行时只留 express + js-yaml 两个依赖。
+    app.post(
+      '/api/kernel-admin/install',
+      express.raw({ type: () => true, limit: MAX_UPLOAD }),
+      (req, res) => {
+        /** @type {string|null} 已经落盘的临时文件：后续任何一步失败都得删掉 */
+        let pending = null;
+        try {
+          const name = String(req.query.name || '');
+          assertBinaryArchive(name);
+          if (!ASSET_RE.test(name)) throw new Error(`安装包文件名不合法：${name}`);
+          const body = req.body;
+          if (!Buffer.isBuffer(body) || body.length === 0) throw new Error('没有收到文件内容');
+          ensureCliDir();
+          pending = path.join(CLI_DIR, `.upload-${process.pid}-${Date.now()}-${name}`);
+          fs.writeFileSync(pending, body);
+          res.json(
+            startInstall({
+              file: pending,
+              name,
+              sha256: typeof req.query.sha256 === 'string' ? req.query.sha256 : undefined,
+              cleanupFile: true,
+            }),
+          );
+        } catch (err) {
+          // 任务没起来：临时文件留在这里没人会删，当场上手清掉
+          if (pending) fs.rmSync(pending, { force: true });
+          const msg = String(err?.message || err);
+          fail(res, err, /进行中/.test(msg) ? 409 : 400);
+        }
+      },
+    );
+
+    app.get('/api/kernel-admin/install', (_req, res) => {
+      res.json(jobView());
+    });
+
+    app.delete('/api/kernel-admin', async (_req, res) => {
+      try {
+        res.json(await uninstall());
+      } catch (err) {
+        fail(res, err, /进行中/.test(String(err?.message)) ? 409 : 400);
+      }
+    });
+
+    for (const [action, handler] of [
+      ['start', start],
+      ['stop', stop],
+      ['restart', restart],
+    ]) {
+      app.post(`/api/kernel-admin/${action}`, async (_req, res) => {
+        try {
+          res.json(await handler());
+        } catch (err) {
+          fail(res, err);
+        }
+      });
+    }
+
+    app.get('/api/kernel-admin/logs', (req, res) => {
+      try {
+        res.json(readLog(req.query.tail));
+      } catch (err) {
+        fail(res, err, 500);
+      }
+    });
+  }
+
+  return {
+    overview,
+    startInstall,
+    jobView,
+    uninstall,
+    start,
+    stop,
+    restart,
+    readLog,
+    registerRoutes,
+  };
+}
+
+/**
+ * @param {import('express').Express} app
+ */
+export function registerKernelAdminRoutes(app, opts = {}) {
+  createKernelAdmin(opts).registerRoutes(app);
+}

package/server/src/http/kernel-proxy.js

@@ -0,0 +1,43 @@
+/** 内核控制接口透明转发：/api/kernel/* → {external-controller}/*，自动附 secret。
+ *  其中 /traffic /memory /logs 的 GET 是长连接流式接口，做流式透传，其余等完整响应。 */
+import { Readable } from 'node:stream';
+import { getController, kernelFetch, kernelFetchRaw } from '../kernel/client.js';
+
+const SAFE_METHODS = new Set(['GET', 'HEAD']);
+// 内核的流式（逐行推送）REST 端点：GET 请求永不结束，必须边收边写
+const STREAM_GET = /^\/(traffic|memory|logs)(\?|$)/;
+
+/** Express 中间件：挂载在 /api/kernel 下 */
+export function kernelProxy() {
+  return async (req, res) => {
+    try {
+      const method = req.method;
+      if (method === 'GET' && STREAM_GET.test(req.url)) {
+        const upstream = await kernelFetchRaw(req.url);
+        res.status(upstream.status);
+        res.setHeader(
+          'content-type',
+          upstream.headers.get('content-type') || 'application/x-ndjson',
+        );
+        Readable.fromWeb(upstream.body).pipe(res);
+        return;
+      }
+      const data = await kernelFetch(req.url, {
+        method,
+        body: SAFE_METHODS.has(method) ? undefined : (req.body ?? {}),
+      });
+      if (data === null) {
+        res.status(204).end();
+      } else if (typeof data === 'string') {
+        res.type('text/plain').send(data);
+      } else {
+        res.json(data);
+      }
+    } catch (err) {
+      res.status(err?.status || 502).json({
+        error: String(err?.message || err),
+        api: getController().url,
+      });
+    }
+  };
+}