@lancewu602/mihomo-dash 0.0.0-stage → 0.6.1

package/server/src/kernel/archive.js

@@ -0,0 +1,181 @@
+/**
+ * 内核安装包（本机上的压缩包）的识别与解包。
+ *
+ * 面板**不联网下载内核**（2026-11 起：内核页只接受本地上传的安装包），所以这里只处理
+ * 已经落盘的 `.gz` / `.zip`：按**内容**判格式 → 拷到落点目录并算 sha256 → 解出可执行文件。
+ * 安装包从哪来（官方 release 页面手工下载、从别的机器拷过来）与面板无关。
+ *
+ * 只认二进制压缩包：darwin / linux 的单文件 `.gz`、Windows 的 `.zip`。同版本 release 里的
+ * `.deb` / `.rpm` / `.pkg.tar.zst` 是发行版安装包（会往系统里装文件、要 root、卸不干净），
+ * 一律拒 —— 面板只往自己的状态目录放一个可执行文件。
+ *
+ * 零依赖：Node 内置 zlib 处理 .gz；Windows 的 .zip 交给系统自带的 bsdtar（Win10 1803+ 的 tar.exe）。
+ *
+ * 外部命令（解 zip 用的 `tar`）走 `shared/exec.js` 的异步执行器：解几十 MB 的包时不能把面板
+ * 的事件循环卡住（以前用 spawnSync，安装任务期间整个面板都不响应）。
+ */
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { once } from 'node:events';
+import os from 'node:os';
+import path from 'node:path';
+import { createGunzip } from 'node:zlib';
+import { pipeline } from 'node:stream/promises';
+import { defaultRun } from '../shared/exec.js';
+
+const BINARY_ARCHIVE_RE = /\.(gz|zip)$/i;
+const PACKAGE_FORMAT_RE = /\.(deb|rpm|apk|pkg\.tar\.zst|pkg\.tar\.xz|pkg\.tar\.gz)$/i;
+
+/**
+ * 校验文件名确实是二进制压缩包（页面上的提示文案与上传校验共用）。
+ * @param {string} name
+ * @returns {string} 原样返回，方便链式调用
+ */
+export function assertBinaryArchive(name) {
+  if (PACKAGE_FORMAT_RE.test(name) || !BINARY_ARCHIVE_RE.test(name)) {
+    const kind = PACKAGE_FORMAT_RE.test(name) ? '发行版安装包' : '不认识的格式';
+    throw new Error(
+      `文件 ${name} 是${kind}：只支持二进制压缩包（.gz / .zip），请换成 mihomo-<平台>-<架构>-<版本>.gz`,
+    );
+  }
+  return name;
+}
+
+/** 平台+架构 → 官方 release 资产里的目标串（darwin amd64 用 compatible 变体，兼容较老的 macOS/CPU） */
+const ASSET_TARGETS = {
+  darwin: { arm64: 'darwin-arm64', x64: 'darwin-amd64-compatible' },
+  linux: { x64: 'linux-amd64', arm64: 'linux-arm64', arm: 'linux-armv7' },
+  win32: { x64: 'windows-amd64', arm64: 'windows-arm64' },
+};
+
+/**
+ * 本机该下哪个资产（**纯字符串，不联网**）：页面上告诉用户去 release 页面拿哪一个。
+ * @param {string} [platform]
+ * @param {string} [arch]
+ * @returns {string|null} 例 `darwin-arm64`；平台/架构没有官方构建时返回 null
+ */
+export function assetTarget(platform = process.platform, arch = process.arch) {
+  return ASSET_TARGETS[platform]?.[arch] || null;
+}
+
+/**
+ * 本机安装包的扩展名：只有 Windows 是 zip，其余（darwin / linux）都是单文件 .gz。
+ * @param {string} [platform]
+ * @returns {'gz'|'zip'}
+ */
+export function archiveExt(platform = process.platform) {
+  return platform === 'win32' ? 'zip' : 'gz';
+}
+
+/**
+ * 按**文件内容**（不是名字）判压缩包格式：手工下载的文件常被改过名。
+ * gzip 头 `1f 8b`；zip 头 `PK`。
+ * @param {string} file
+ * @returns {'gz'|'zip'|null} 认不出来返回 null
+ */
+export function sniffArchiveExt(file) {
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+    const head = Buffer.alloc(4);
+    const read = fs.readSync(fd, head, 0, 4, 0);
+    if (read >= 2 && head[0] === 0x1f && head[1] === 0x8b) return 'gz';
+    if (read >= 2 && head[0] === 0x50 && head[1] === 0x4b) return 'zip';
+    return null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+        /* 关不掉就算了 */
+      }
+    }
+  }
+}
+
+/**
+ * 把本地压缩包拷到落点目录（边拷边算 sha256）。
+ * 路径由调用方保证是已校验的普通文件。
+ * @param {string} src
+ * @param {string} destPath
+ * @param {{ onProgress?: (written: number, total: number) => void }} [opts]
+ * @returns {Promise<{ sha256: string, size: number }>}
+ */
+export async function copyToFile(src, destPath, opts = {}) {
+  const total = fs.statSync(src).size;
+  const hash = createHash('sha256');
+  const out = createWriteStream(destPath);
+  let size = 0;
+  try {
+    for await (const chunk of createReadStream(src)) {
+      hash.update(chunk);
+      size += chunk.length;
+      if (!out.write(chunk)) await once(out, 'drain');
+      opts.onProgress?.(size, total);
+    }
+    await new Promise((resolve, reject) => out.end((err) => (err ? reject(err) : resolve())));
+  } catch (err) {
+    out.destroy();
+    throw new Error(`读本地文件失败：${err?.message || err}（${src}）`);
+  }
+  return { sha256: hash.digest('hex'), size };
+}
+
+/** 归档里找 mihomo 可执行文件：优先名字匹配，其次取最大的那个文件 */
+function findBinaryIn(dir) {
+  let best = null;
+  const walk = (d) => {
+    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+      const full = path.join(d, entry.name);
+      if (entry.isDirectory()) {
+        const hit = walk(full);
+        if (hit) return hit;
+      } else if (/^mihomo(\.exe)?$/i.test(entry.name)) {
+        return full;
+      } else if (!best || fs.statSync(full).size > fs.statSync(best).size) {
+        best = full;
+      }
+    }
+    return null;
+  };
+  return walk(dir) || best;
+}
+
+/** Windows 的 zip：用系统自带 bsdtar 解（Node 没有内置 zip 支持） */
+async function extractZip(archivePath, destPath) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'mihomo-unzip-'));
+  try {
+    const r = await defaultRun('tar', ['-xf', archivePath, '-C', dir], { timeout: 120000 });
+    if (!r.ok) {
+      throw new Error(
+        `解压 zip 失败（依赖系统自带的 tar）：${r.stderr.trim() || `退出码 ${r.status}`}`,
+      );
+    }
+    const found = findBinaryIn(dir);
+    if (!found) throw new Error('上传的 zip 里没找到 mihomo 可执行文件');
+    fs.copyFileSync(found, destPath);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * 解出可执行文件并给上执行权限。
+ * @param {string} archivePath 本机上的 .gz / .zip
+ * @param {'gz'|'zip'} ext
+ * @param {string} destPath 目标可执行文件路径
+ */
+export async function extractBinary(archivePath, ext, destPath) {
+  if (ext === 'gz') {
+    await pipeline(createReadStream(archivePath), createGunzip(), createWriteStream(destPath));
+  } else if (ext === 'zip') {
+    await extractZip(archivePath, destPath);
+  } else {
+    throw new Error(`不认识的归档格式：${ext}`);
+  }
+  if (process.platform !== 'win32') fs.chmodSync(destPath, 0o755);
+  return destPath;
+}

package/server/src/kernel/binary.js

@@ -0,0 +1,33 @@
+/**
+ * 内核版本读取。
+ *
+ * 面板假定**主机上只有自己这一个内核**（唯一落点 `MIHOMO_DASH_DIR/bin/mihomo`），所以这里
+ * 不去扫 PATH / brew / 包管理器目录找「别的内核」：安装（kernel-install.js）与状态展示
+ * （kernel-admin.js）要版本号时，直接对目标文件跑一次 `-v` 就够了。面板不比较版本（不联网查新版），
+ * 所以这里没有「谁比谁新」的工具。
+ *
+ * 唯一会跑外部程序的地方就是 readKernelVersion（`mihomo -v`，带 5 秒超时，失败返回 null）；
+ * 走 `shared/exec.js` 的异步执行器，不阻塞面板的事件循环（`/api/kernel-admin` 每次轮询都要读它）。
+ */
+import { defaultRun } from '../shared/exec.js';
+
+/**
+ * 跑一次 `mihomo -v` 取版本号，例：`Mihomo Meta 1.19.31 darwin arm64 with go1.27.1` → 1.19.31
+ * @param {string} binPath
+ * @returns {Promise<string|null>} 拿不到（不是 mihomo / 跑不起来）返回 null
+ */
+export async function readKernelVersion(binPath) {
+  try {
+    const r = await defaultRun(binPath, ['-v'], { timeout: 5000 });
+    const text = `${r.stdout || ''}${r.stderr || ''}`;
+    const m = text.match(/(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)/);
+    return m ? m[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+/** 版本号归一化：去掉可能的 v 前缀，便于展示 */
+export function bareVersion(v) {
+  return String(v || '').replace(/^v/, '');
+}

package/server/src/kernel/client.js

@@ -0,0 +1,138 @@
+/** 内核控制接口客户端：解析 external-controller / secret，发请求，抽状态摘要。 */
+import fs from 'node:fs';
+import path from 'node:path';
+import yaml from 'js-yaml';
+import { detectMihomoDir } from '../shared/paths.js';
+
+const FALLBACK_API = 'http://127.0.0.1:9090';
+
+export function normalizeUrl(raw) {
+  if (!raw) return FALLBACK_API;
+  return /^https?:\/\//.test(raw) ? raw.replace(/\/$/, '') : `http://${raw}`;
+}
+
+/**
+ * 读某个配置目录里写的控制接口与密钥（每次都读文件，不走缓存）。
+ * 拉内核之前用它做前置检查：配置里没写 `external-controller` 时内核根本不听控制接口，
+ * 面板拉起来也只能干看着（见 kernel-lifecycle.js 的 `no-controller`）。
+ * @param {string|null} dir
+ * @returns {{ external: string, secret: string }}
+ */
+export function readControllerConfig(dir) {
+  const out = { external: '', secret: '' };
+  if (!dir) return out;
+  try {
+    const cfg = yaml.load(fs.readFileSync(path.join(dir, 'config.yaml'), 'utf8')) || {};
+    out.external = cfg['external-controller'] || '';
+    out.secret = cfg.secret || '';
+  } catch {
+    // 文件不在 / 解析不了都当「没写」
+  }
+  return out;
+}
+
+let cachedController;
+
+/**
+ * 清掉控制接口缓存。
+ * 缓存是为了不改配置时少读文件，但面板**自己**改了 config.yaml（安装写默认配置、配置文件页保存）时
+ * 必须失效 —— 否则面板会一直拿旧地址去探内核（典型现象：装完点侧栏「启动内核」被告知「改完 external-controller
+ * 要重启面板」）。外部工具改的文件仍靠 kernel-lifecycle.js 的 `controller-changed` 检查提醒重启。
+ */
+export function resetControllerCache() {
+  cachedController = undefined;
+}
+
+/**
+ * 控制接口地址与密钥：只读 config.yaml 的 `external-controller` / `secret`（内核自己也读这份，
+ * 单一来源，没有环境变量覆盖）。读不到时回退默认地址 127.0.0.1:9090。
+ * 结果缓存到进程结束（面板自己改完配置会主动清缓存，见 resetControllerCache）。
+ * @returns {{ url: string, secret: string }}
+ */
+export function getController() {
+  if (cachedController) return cachedController;
+  const { external, secret } = readControllerConfig(detectMihomoDir());
+  cachedController = { url: normalizeUrl(external), secret };
+  return cachedController;
+}
+
+/**
+ * 拿到内核原始 Response（流式端点用：body 边收边透传）。
+ * @param {string} apiPath
+ * @returns {Promise<Response>}
+ */
+export async function kernelFetchRaw(apiPath) {
+  const { url, secret } = getController();
+  const headers = {};
+  if (secret) headers.authorization = `Bearer ${secret}`;
+  return fetch(url + apiPath, { headers });
+}
+
+/**
+ * 请求内核控制接口。
+ * @param {string} apiPath 形如 /version、/configs?force=true
+ * @param {{ method?: string, body?: unknown }} [opts]
+ */
+export async function kernelFetch(apiPath, opts = {}) {
+  const { url, secret } = getController();
+  const method = opts.method || 'GET';
+  const headers = {};
+  if (secret) headers.authorization = `Bearer ${secret}`;
+  if (opts.body !== undefined) headers['content-type'] = 'application/json';
+
+  const res = await fetch(url + apiPath, {
+    method,
+    headers,
+    body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+  });
+  const text = await res.text();
+  let data;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = text;
+  }
+  if (!res.ok) {
+    const msg = typeof data === 'object' && data && data.message ? data.message : text;
+    const err = new Error(`内核返回 ${res.status}: ${msg}`);
+    err.status = res.status;
+    throw err;
+  }
+  return data;
+}
+
+/**
+ * 内核的本地代理入口（系统代理要指过来的地址）：运行时 `mixed-port` 优先，回退 config.yaml 的
+ * `mixed-port` / `socks-port` / `port`，再回退 7890。每次现读（改完端口不用重启面板）。
+ * @returns {Promise<{ host: string, port: number, source: string }>}
+ */
+export async function resolveKernelProxyTarget() {
+  try {
+    const cfg = await kernelFetch('/configs');
+    const port = Number(cfg?.['mixed-port'] || 0);
+    if (port) return { host: '127.0.0.1', port, source: '内核运行时 mixed-port' };
+  } catch {
+    // 内核没跑就看配置文件
+  }
+  const dir = detectMihomoDir();
+  if (dir) {
+    try {
+      const doc = yaml.load(fs.readFileSync(path.join(dir, 'config.yaml'), 'utf8')) || {};
+      const port = Number(doc['mixed-port'] || doc['socks-port'] || doc.port || 0);
+      if (port) return { host: '127.0.0.1', port, source: 'config.yaml' };
+    } catch {
+      /* 解析失败就退默认值 */
+    }
+  }
+  return { host: '127.0.0.1', port: 7890, source: '默认 7890' };
+}
+
+/** status 用的摘要：版本 / 模式 / 接口 */
+export async function kernelSummary() {
+  const [version, configs] = await Promise.all([kernelFetch('/version'), kernelFetch('/configs')]);
+  return {
+    version: `${version.version}${version.meta ? ' (Meta)' : ''}`,
+    mode: configs.mode,
+    api: getController().url,
+  };
+}

package/server/src/kernel/install.js

@@ -0,0 +1,150 @@
+/**
+ * 面板自有内核的安装 / 升级 / 卸载：文件级操作 + 台账。
+ *
+ * 安装包是**本地上传的压缩包**（面板不联网下载，见 kernel-archive.js），这里只管
+ * 「拷到落点 → 校验 sha256 → 解压 → 试跑 `mihomo -v` → 备份旧文件 → 同目录 rename 原子替换 → 记台账」。
+ *
+ * 与 config.yaml 那套一致：替换用同目录 rename（原子），旧版本会留一个 `.bak-<版本>` 备份，
+ * 但**没有自动回滚** —— 备份是留给用户手工恢复的（`bin/mihomo.bak-<版本>` 直接拷回去即可）。
+ *
+ * 台账 kernels.json 记录「这个文件是我们装的、装的是哪一版」（主机上就当只有这一个落点，
+ * 不去探测别处有没有别的 mihomo）。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { KERNEL_BIN, KERNEL_BIN_DIR, KERNEL_LEDGER_FILE, ensureCliDir } from '../shared/paths.js';
+import { readKernelVersion } from './binary.js';
+import { assertBinaryArchive, copyToFile, extractBinary } from './archive.js';
+
+/** 台账最多留几条历史，够回查即可 */
+const MAX_HISTORY = 10;
+
+/** @returns {{ installed: Array<Record<string, unknown>> }} */
+export function readLedger() {
+  try {
+    const data = JSON.parse(fs.readFileSync(KERNEL_LEDGER_FILE, 'utf8'));
+    return { installed: Array.isArray(data.installed) ? data.installed : [] };
+  } catch {
+    return { installed: [] };
+  }
+}
+
+/** 面板在指定落点上装的那一版（台账里同路径最新一条），没装过返回 null */
+export function currentInstall(target = KERNEL_BIN) {
+  return readLedger().installed.find((e) => e.path === target) || null;
+}
+
+function writeLedger(installed) {
+  ensureCliDir();
+  const payload = { installed: installed.slice(0, MAX_HISTORY) };
+  fs.writeFileSync(KERNEL_LEDGER_FILE, JSON.stringify(payload, null, 2));
+}
+
+/**
+ * 安装（升级）：把已落到本机（浏览器上传时是状态目录下的临时文件）的压缩包
+ * 校验 sha256 → 解压 → 试跑 → 备份旧文件 → 原子替换 → 记台账。
+ * 校验失败时现有文件原封不动（临时文件都带 `.` 前缀，最后一步才 rename）。
+ * @param {{
+ *   localFile: string,
+ *   ext: 'gz'|'zip',
+ *   asset?: string,
+ *   target?: string,
+ *   sha256?: string,
+ *   onProgress?: (written: number, total: number) => void,
+ * }} opts asset = 安装包原始文件名（只用于日志/台账展示），默认取 localFile 的文件名
+ * @returns {Promise<Record<string, any>>} 台账里新增的那条记录
+ */
+export async function performInstall({
+  localFile,
+  ext,
+  asset,
+  target = KERNEL_BIN,
+  sha256,
+  onProgress,
+}) {
+  const name = assertBinaryArchive(asset || path.basename(localFile));
+  ensureCliDir();
+  const dir = path.dirname(target);
+  fs.mkdirSync(dir, { recursive: true });
+  const stamp = `${process.pid}.${Date.now()}`;
+  const archive = path.join(dir, `.${path.basename(target)}.${stamp}.upload`);
+  const staged = path.join(dir, `.${path.basename(target)}.${stamp}.new`);
+
+  try {
+    const got = await copyToFile(localFile, archive, { onProgress });
+    if (sha256 && sha256.trim().toLowerCase() !== got.sha256) {
+      throw new Error(`sha256 不匹配：期望 ${sha256.trim()}，实际 ${got.sha256}`);
+    }
+    await extractBinary(archive, ext, staged);
+    const version = await readKernelVersion(staged);
+    if (!version) {
+      throw new Error('这个文件跑不起来（`mihomo -v` 没输出），安装包可能选错了或已损坏');
+    }
+
+    let backup = null;
+    if (fs.existsSync(target)) {
+      const prev = currentInstall();
+      const prevLabel = prev?.version || (await readKernelVersion(target)) || 'unknown';
+      backup = `${target}.bak-${prevLabel}`;
+      fs.copyFileSync(target, backup);
+      if (process.platform !== 'win32') fs.chmodSync(backup, 0o755);
+    }
+    fs.renameSync(staged, target);
+    if (process.platform !== 'win32') fs.chmodSync(target, 0o755);
+
+    const entry = {
+      version,
+      asset: name,
+      sha256: got.sha256,
+      size: got.size,
+      path: target,
+      backup,
+      /** 安装来源：本地上传的安装包（面板不联网下载，所以这里是常量） */
+      source: 'upload',
+      installedAt: new Date().toISOString(),
+    };
+    const { installed } = readLedger();
+    // 同一路径只留最新一条在台账首位，历史留 10 条方便回查（不再有自动回滚用它）
+    writeLedger([entry, ...installed.filter((e) => e.installedAt !== entry.installedAt)]);
+    return entry;
+  } finally {
+    for (const f of [archive, staged]) fs.rmSync(f, { force: true });
+  }
+}
+
+/**
+ * 卸载：只删面板自己装的二进制（含 `.bak-*` 与残留的临时文件）与台账，目录里别的东西不动。
+ * @param {string} target
+ * @returns {string[]} 删掉的文件
+ */
+export function removeInstalled(target = KERNEL_BIN) {
+  const dir = path.dirname(target);
+  const base = path.basename(target);
+  const removed = [];
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    entries = [];
+  }
+  for (const name of entries) {
+    const mine = name === base || name.startsWith(`${base}.bak-`) || name.startsWith(`.${base}.`);
+    if (!mine) continue;
+    const full = path.join(dir, name);
+    fs.rmSync(full, { force: true });
+    removed.push(full);
+  }
+  // 目录本来就只为我们而建的话顺手删掉（HOME 之外别人塞过东西就留着）
+  try {
+    if (dir !== KERNEL_BIN_DIR && fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+  } catch {
+    /* 删不掉就算了 */
+  }
+  try {
+    if (dir === KERNEL_BIN_DIR && fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+  } catch {
+    /* 同上 */
+  }
+  fs.rmSync(KERNEL_LEDGER_FILE, { force: true });
+  return removed;
+}