@lancewu602/mihomo-dash 0.0.0-stage → 0.6.0

package/server/src/cli/status.js

@@ -0,0 +1,243 @@
+/**
+ * mihomo-dash status：一眼看清这台机器上的几件事（默认命令，无参数时也走它）：
+ *
+ *   内核（版本 / 模式 / 控制接口 / 密钥）· 配置文件规模 · 面板进程 · 系统代理 · 开机自启
+ *
+ * 每一块单独兜底：探不到就写一行原因，不让别的块跟着消失（面板没起、平台不支持都不算错）。
+ * **退出码沿用老行为：内核不通 → 1**（方便脚本当健康检查），其它块不参与判定。
+ *
+ * 探测函数（proxy / service）可注入，测试用桩，不碰本机系统设置与 launchd / systemd。
+ */
+import { createRequire } from 'node:module';
+import { bareVersion } from '../kernel/binary.js';
+import { getController, kernelFetch } from '../kernel/client.js';
+import { detectMihomoDir } from '../shared/paths.js';
+import { probePanel } from '../shared/panel.js';
+import { createSystemProxy } from '../shared/system-proxy.js';
+import { createServiceManager } from '../shared/service.js';
+import { pad } from '../shared/text.js';
+import { loadKernelConfig } from '../shared/kernel-config.js';
+
+const require = createRequire(import.meta.url);
+const { version: PKG_VERSION } = require('../../../package.json');
+
+/** 顶层标签的显示宽度（中文各占 2 列） */
+const LABEL_WIDTH = 10;
+/** 子行的缩进 */
+const SUB = '  ';
+const list = (v) => (Array.isArray(v) ? v : []);
+const map = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+
+/** 内核：控制接口通不通、版本 / 模式 / 密钥 */
+async function kernelPart() {
+  const { url, secret } = getController();
+  try {
+    const [version, configs] = await Promise.all([
+      kernelFetch('/version'),
+      kernelFetch('/configs'),
+    ]);
+    return {
+      up: true,
+      api: url,
+      secret: !!secret,
+      version: `${bareVersion(version.version)}${version.meta ? ' (Meta)' : ''}`,
+      mode: configs?.mode ?? '-',
+    };
+  } catch (err) {
+    return { up: false, api: url, secret: !!secret, error: String(err?.message || err) };
+  }
+}
+
+/** 配置文件：在哪、能不能解析、里面有多少东西（不存在的目录不算错，交给 doctor 去报） */
+function configPart() {
+  const { path, config, error } = loadKernelConfig();
+  if (!config) return { path, dir: detectMihomoDir(), exists: false, error };
+  return {
+    path,
+    dir: detectMihomoDir(),
+    exists: true,
+    providers: Object.keys(map(config['proxy-providers'])).length,
+    groups: list(config['proxy-groups']).length,
+    rules: list(config.rules).length,
+  };
+}
+
+/**
+ * 面板进程：打 `/api/health` 探活（不再看 pid 文件）。
+ * 拿到 version / uptime 就能看出是不是旧版本在跑。
+ * @param {{ host?: string, port?: number }} [target]
+ */
+async function panelPart(target = {}) {
+  const info = await probePanel(target);
+  return {
+    running: info.running,
+    url: info.url,
+    port: info.port,
+    pid: info.pid ?? 0,
+    version: info.version,
+    uptime: info.uptime,
+  };
+}
+
+/** 系统代理：开没开、指向哪、绕过几条、动的是哪个网络服务 */
+async function proxyPart(proxy) {
+  const raw = await proxy.read();
+  const enabled = ['http', 'https', 'socks'].filter((k) => raw.protocols?.[k]?.enabled);
+  const one = enabled.length ? raw.protocols[enabled[0]] : null;
+  return {
+    supported: !!raw.supported,
+    hint: raw.hint ?? null,
+    enabled: !!raw.enabled,
+    protocols: enabled,
+    pointing: one ? `${one.host}:${one.port}` : null,
+    bypass: list(raw.bypass).length,
+    service: raw.service ?? null,
+  };
+}
+
+/** 开机自启：两个服务定义装没装、什么时候会起（登录后 / 开机即起） */
+async function autostartPart(service) {
+  const st = await service.status();
+  return {
+    supported: !!st.supported,
+    hint: st.hint ?? null,
+    platform: st.platform ?? process.platform,
+    linger: st.linger ?? null,
+    installed: list(st.jobs).filter((j) => j.installed).length,
+    total: list(st.jobs).length || 2,
+  };
+}
+
+/**
+ * 汇总所有块。任何一块抛错都只记下原因。
+ * @param {{ proxy?: { read: Function }, service?: { status: Function }, panel?: { host?: string, port?: number } }} [opts]
+ *   测试可注入桩与面板端口
+ */
+export async function gatherStatus(opts = {}) {
+  const proxy = opts.proxy || createSystemProxy();
+  const service = opts.service || createServiceManager();
+  const safe = async (fn, fallback) => {
+    try {
+      return await fn();
+    } catch (err) {
+      return { ...fallback, error: String(err?.message || err) };
+    }
+  };
+
+  const [kernel, panel, proxyState, autostart] = await Promise.all([
+    safe(kernelPart, { up: false }),
+    safe(() => panelPart(opts.panel), { running: false }),
+    safe(() => proxyPart(proxy), { supported: false }),
+    safe(() => autostartPart(service), { supported: false }),
+  ]);
+  return { kernel, panel, config: configPart(), proxy: proxyState, autostart };
+}
+
+const line = (label, text) => `${pad(label, LABEL_WIDTH)}${text}`;
+const sub = (label, text) => `${SUB}${pad(label, LABEL_WIDTH - SUB.length)} ${text}`;
+const indent = (text) => `${SUB}${text}`;
+
+const whenText = (platform, linger) => {
+  if (platform === 'darwin') return '登录后启动';
+  if (linger === true) return '开机即起（linger 已开）';
+  if (linger === false) return '登录后启动（无 linger）';
+  return '登录后启动';
+};
+
+const duration = (sec) => {
+  const s = Math.max(0, Math.floor(sec));
+  if (s < 60) return `${s} 秒`;
+  if (s < 3600) return `${Math.floor(s / 60)} 分钟`;
+  return `${Math.floor(s / 3600)} 小时 ${Math.floor((s % 3600) / 60)} 分钟`;
+};
+
+/**
+ * 把汇总结果渲染成给人看的几行。
+ * @param {Awaited<ReturnType<typeof gatherStatus>>} d
+ * @returns {string}
+ */
+export function formatStatus(d) {
+  const { kernel, panel, config, proxy, autostart } = d;
+  const out = [];
+
+  // 内核
+  if (kernel.up) {
+    out.push(line('内核', `运行中 · v${kernel.version} · ${kernel.mode}`));
+    out.push(
+      sub(
+        '控制接口',
+        `${kernel.api} · ${kernel.secret ? '密钥已配置' : '密钥未配置（无鉴权，仅适合本机使用）'}`,
+      ),
+    );
+  } else {
+    const why = kernel.error ? `不通：${kernel.error}` : '不通';
+    out.push(line('内核', `未运行（控制接口 ${kernel.api} ${why}）`));
+    out.push(indent('启动：用侧栏底部的「启动内核」，或面板「内核」页安装后启动'));
+  }
+
+  // 配置文件
+  if (config.exists) {
+    out.push(
+      line(
+        '配置文件',
+        `${config.path}（订阅 ${config.providers} / 策略组 ${config.groups} / 规则 ${config.rules}）`,
+      ),
+    );
+  } else {
+    out.push(
+      line('配置文件', `还没有 config.yaml（${config.dir}）：在面板「配置文件」页写好保存就会创建`),
+    );
+  }
+
+  // 面板
+  if (panel.running) {
+    const bits = [`pid ${panel.pid}`];
+    if (panel.version) bits.push(`v${panel.version}`);
+    if (panel.uptime !== null && panel.uptime !== undefined)
+      bits.push(`已运行 ${duration(panel.uptime)}`);
+    out.push(line('面板', `运行中 · ${panel.url} · ${bits.join(' · ')}`));
+  } else {
+    out.push(line('面板', `未运行（端口 ${panel.port}；在面板「自启」页装成系统服务）`));
+  }
+
+  // 系统代理
+  if (!proxy.supported) {
+    out.push(line('系统代理', proxy.hint ? `不支持（${proxy.hint}）` : '不支持'));
+  } else if (!proxy.enabled) {
+    out.push(line('系统代理', '关（系统直连，内核照跑）'));
+  } else {
+    const bits = [
+      proxy.pointing
+        ? `${proxy.protocols.map((p) => p.toUpperCase()).join('/')} → ${proxy.pointing}`
+        : proxy.protocols.map((p) => p.toUpperCase()).join('/') || '未启用协议',
+    ];
+    bits.push(`绕过 ${proxy.bypass} 条`);
+    if (proxy.service) bits.push(`服务 ${proxy.service}`);
+    out.push(line('系统代理', `开 · ${bits.join(' · ')}`));
+  }
+
+  // 开机自启
+  if (!autostart.supported) {
+    out.push(line('开机自启', autostart.hint ? `不支持（${autostart.hint}）` : '不支持'));
+  } else if (!autostart.installed) {
+    out.push(line('开机自启', '未安装（面板「自启」页打开开关即可）'));
+  } else {
+    const where = autostart.platform === 'darwin' ? 'macOS LaunchAgent' : 'systemd --user';
+    out.push(
+      line(
+        '开机自启',
+        `已安装 ${autostart.installed}/${autostart.total} · ${where} · ${whenText(autostart.platform, autostart.linger)}`,
+      ),
+    );
+  }
+
+  return out.join('\n');
+}
+
+export async function cmdStatus(panel) {
+  console.log(`mihomo-dash ${PKG_VERSION}\n`);
+  const data = await gatherStatus({ panel });
+  console.log(formatStatus(data));
+  // 内核不通当作失败：老行为，方便脚本拿它当健康检查
+  if (!data.kernel.up) process.exit(1);
+}

package/server/src/http/config-files.js

@@ -0,0 +1,148 @@
+/** 配置文件读写：YAML 校验 → 写盘 → 热重载。 */
+import fs from 'node:fs';
+import path from 'node:path';
+import yaml from 'js-yaml';
+import { writeFileAtomic } from '../shared/atomic-file.js';
+import { configPath, detectMihomoDir, ensureConfigDir } from '../shared/paths.js';
+import { kernelFetch } from '../kernel/client.js';
+import { orderTopLevel } from './config-order.js';
+
+/** 内核没在运行时写盘的提示文案（写盘已经成功，只是没生效；前端拿它显示黄色 toast） */
+export const KERNEL_DOWN_WARNING = '内核没在运行：配置已写入，启动内核后生效';
+
+/** name → 内核目录内的绝对路径；限制 .yaml/.yml 且防路径穿越 */
+function safeResolve(name) {
+  const root = path.resolve(detectMihomoDir());
+  const p = path.resolve(root, name);
+  if (p !== root && !p.startsWith(root + path.sep)) throw new Error('非法路径');
+  if (!/\.ya?ml$/i.test(p)) throw new Error('仅支持 YAML 文件');
+  return p;
+}
+
+function validateYaml(content) {
+  try {
+    return yaml.load(content);
+  } catch (e) {
+    throw new Error(`YAML 解析失败: ${e.message}`);
+  }
+}
+
+/**
+ * 顶层键排序 + 安全网：排完必须解析出**完全一样**的配置（只是键的顺序变了）。
+ * 排序只是排版，万一它搬丢 / 搬重了内容，宁可放弃排序也不让写盘出错 ——
+ * 所以这里比一遍解析结果，不一致就原样返回（并留一行日志）。
+ * @param {string} content
+ * @returns {string}
+ */
+export function orderedConfigText(content) {
+  let next;
+  try {
+    next = orderTopLevel(content);
+    if (next === content) return content;
+    if (!sameDoc(yaml.load(next), yaml.load(content))) {
+      console.warn('[mihomo-dash] 顶层键排序被跳过：排序后解析结果与原文不一致');
+      return content;
+    }
+    return next;
+  } catch (e) {
+    console.warn(`[mihomo-dash] 顶层键排序被跳过：${e.message}`);
+    return content;
+  }
+}
+
+/** 两份解析结果是否完全一致（键序无关；对象 / 数组逐层比） */
+function sameDoc(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    return (
+      Array.isArray(a) &&
+      Array.isArray(b) &&
+      a.length === b.length &&
+      a.every((v, i) => sameDoc(v, b[i]))
+    );
+  }
+  if (a && b && typeof a === 'object' && typeof b === 'object') {
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    return ka.length === kb.length && ka.every((k) => k in b && sameDoc(a[k], b[k]));
+  }
+  return false;
+}
+
+/** 可编辑文件清单：config.yaml + providers/*.yaml */
+import { resetControllerCache } from '../kernel/client.js';
+
+export function listFiles() {
+  const dir = detectMihomoDir();
+  const files = ['config.yaml'];
+  const providerDir = path.join(dir, 'providers');
+  if (fs.existsSync(providerDir)) {
+    for (const f of fs.readdirSync(providerDir).sort()) {
+      if (/\.ya?ml$/i.test(f)) files.push(`providers/${f}`);
+    }
+  }
+  return files.filter((f) => fs.existsSync(path.join(dir, f)));
+}
+
+export function readFile(name) {
+  const p = safeResolve(name);
+  if (!fs.existsSync(p)) throw new Error(`还没有这个文件：${p}（保存一次就会创建）`);
+  return fs.readFileSync(p, 'utf8');
+}
+
+/** 读文件但「不存在」不算错：给「配置文件」页判断该不该显示「还没有配置」 */
+export function readFileInfo(name) {
+  const p = safeResolve(name);
+  const exists = fs.existsSync(p);
+  return { name, path: p, exists, content: exists ? fs.readFileSync(p, 'utf8') : '' };
+}
+
+/** 保存任意编辑文件（不触发内核重载）；config.yaml 顺手把顶层键按固定顺序排好 */
+export function saveFile(name, content) {
+  validateYaml(content);
+  const text = name === 'config.yaml' ? orderedConfigText(content) : content;
+  const p = safeResolve(name);
+  fs.mkdirSync(path.dirname(p), { recursive: true }); // providers/*.yaml 这类子目录也要建出来
+  ensureConfigDir();
+  writeFileAtomic(p, text);
+  // 改的可能就是面板在用的 config.yaml（external-controller / secret）：写盘后让接口缓存失效
+  resetControllerCache();
+}
+
+/** 删除文件；文件不存在时返回 removed: false */
+export function deleteFile(name) {
+  const p = safeResolve(name);
+  if (!fs.existsSync(p)) return { removed: false };
+  fs.unlinkSync(p);
+  return { removed: true };
+}
+
+/**
+ * 保存 config.yaml 并热重载内核。
+ *
+ * 两种「写盘成功但未生效」不当成错误：
+ * - **内核没在跑 / 连不上**（没有 HTTP 状态码）：文件确实已经写好，返回 `reloaded: false` +
+ *   一句 warning，让页面提示「已写入，启动内核后生效」；以前这里直接抛错，前端弹「保存失败」，
+ *   用户以为没存上、反复重存，其实文件已经变了。
+ * - 内核**回了错**（配置不合法、重载被拒）仍然抛错：那是真问题，只是文件已经写进去了（不回滚）。
+ * @param {string} content
+ * @returns {Promise<{ reloaded: boolean, warning?: string }>}
+ */
+export async function saveConfigWithReload(content) {
+  const p = configPath();
+  const text = orderedConfigText(content);
+  validateYaml(text);
+  ensureConfigDir();
+  writeFileAtomic(p, text);
+  resetControllerCache();
+  try {
+    await kernelFetch('/configs?force=true', {
+      method: 'PUT',
+      body: { path: p, payload: '' },
+    });
+  } catch (e) {
+    if (!e?.status) return { reloaded: false, warning: KERNEL_DOWN_WARNING };
+    throw new Error(`热重载失败（config.yaml 已写入，未回滚）: ${e.message}`);
+  }
+  return { reloaded: true };
+}

package/server/src/http/config-order.js

@@ -0,0 +1,186 @@
+/**
+ * config.yaml 顶层键的固定顺序（2026-11 定的规范）。
+ *
+ * 面板**每次写盘**都会调 `orderTopLevel()` 把顶层键按下面的顺序排一遍：写配置的人不用自己挑
+ * 位置（以前缺的键统一插到文件最顶上，于是 GEO / 快捷设置那几个键总是飘在 mixed-port 上面），
+ * 手写的文件保存一次也就归位了。
+ *
+ * 只搬「整块」的位置，不改内容：
+ * - 键下面缩进的内容、行尾注释、键上方紧贴的说明注释都跟着键一起走，缩进与字面量一个字不改；
+ * - 面板不认识的顶层键不算乱丢：它们保持**原相对顺序**，统一排在「规则」组（rules / sub-rules /
+ *   script）前面（见下面的 GEO_TAIL 说明）；
+ * - 顶层键**挨着写，块与块之间不留空行**（文件头注释与第一个键之间也一样）：配置项之间空一行
+ *   只是好看，写多了反而难扫；想分组就用注释行（注释会跟着它下面那个键走）。块内部的空行、
+ *   缩进、注释、排版一律不动。
+ *
+ * 这个模块刻意不 import 任何东西（只做「文本进、文本出」），好让 config-files.js 直接用而不绕成环。
+ */
+
+/**
+ * 顶层键的固定顺序。分组只为读起来清楚，同组内按数组先后排。
+ */
+export const TOP_LEVEL_ORDER = [
+  // ① 基础运行：流量从哪进来、内核怎么跑
+  'mixed-port',
+  'port',
+  'socks-port',
+  'redir-port',
+  'tproxy-port',
+  'tun',
+  'allow-lan',
+  'bind-address',
+  'ipv6',
+  'mode',
+  'log-level',
+  'unified-delay',
+  'tcp-concurrent',
+  'find-process-mode',
+  'global-client-fingerprint',
+  'interface-name',
+  'routing-mark',
+  'keep-alive-interval',
+  'keep-alive-idle',
+  'disable-keep-alive',
+  'authentication',
+  'skip-auth-prefixes',
+  // ② 控制接口：面板 / 别的客户端连哪个端口
+  'external-controller',
+  'external-controller-tls',
+  'external-controller-unix',
+  'external-controller-pipe',
+  'secret',
+  'external-ui',
+  'external-ui-name',
+  'external-ui-url',
+  // ③ GEO 数据
+  'geodata-mode',
+  'geodata-loader',
+  'geo-auto-update',
+  'geo-update-interval',
+  'geox-url',
+  // ④ 内核行为 / 数据面
+  'profile',
+  'dns',
+  'hosts',
+  'sniffer',
+  'tls',
+  'experimental',
+  'ntp',
+  'listeners',
+  'tunnels',
+  // ⑤ 代理来源与分组
+  'proxy-providers',
+  'rule-providers',
+  'proxies',
+  'proxy-groups',
+  // ⑥ 规则：惯例放最后
+  'rules',
+  'sub-rules',
+  'script',
+];
+
+/** 面板不认识的键排在这组之前（即紧挨着 rules 上面），保持它们之间的相对顺序 */
+const UNKNOWN_RANK = TOP_LEVEL_ORDER.indexOf('rules');
+
+/** 行首缩进宽度 */
+export const indentOf = (line) => line.match(/^\s*/)[0].length;
+
+/** 取行首键名（兼容引号键；列表项与注释返回 null） */
+export function keyOf(line) {
+  const t = line.trim();
+  if (!t || t.startsWith('#') || t.startsWith('- ')) return null;
+  const m = line.match(/^\s*(?:"([^"]*)"|'([^']*)'|([^:#]*?))\s*:/);
+  if (!m) return null;
+  return (m[1] ?? m[2] ?? m[3] ?? '').trim();
+}
+
+/**
+ * 顶层段落（键行 + 其下缩进内容，含中间空行）结束的行号。
+ * 空行不算结束 —— 段落后面跟的空行视作段落的一部分，下一行顶格内容才算下一段。
+ */
+export function sectionEnd(lines, start) {
+  let i = start;
+  while (i < lines.length) {
+    if (!lines[i].trim()) {
+      i++;
+      continue;
+    }
+    if (indentOf(lines[i]) === 0) break;
+    i++;
+  }
+  return i;
+}
+
+const isBlank = (line) => !line.trim();
+/** 顶层注释行（缩进 0 的 `# ...`） */
+const isTopComment = (line) => indentOf(line) === 0 && line.trim().startsWith('#');
+
+/**
+ * 某个顶层键所在块的起始行（含上方属于它的注释行）。
+ *
+ * 注释归属规则：
+ * - **文件最上面的注释块是文件头**（不跟任何键走）：第一个顶层键上面的注释一律留在原位；
+ * - 紧贴键上方、中间没有空行的注释 → 跟着这个键走；
+ * - 「上下都被空行夹着」的注释块（分节标题那种）→ 也算下面那个键的；
+ * - 其余（段尾注释、被缩进的注释）留在原处，跟着上面那块走。
+ */
+function blockStart(lines, at) {
+  let start = at;
+  while (start > 0 && isTopComment(lines[start - 1])) start--;
+  if (start === 0 || !isBlank(lines[start - 1])) return start;
+  // 再往上是空行：看看空行之上是不是一整块独立的注释（分节标题），是就一并搬走
+  let head = start - 1;
+  while (head > 0 && isBlank(lines[head - 1])) head--;
+  let top = head;
+  while (top > 0 && isTopComment(lines[top - 1])) top--;
+  const isDetachedBlock = top < head && (top === 0 || isBlank(lines[top - 1]));
+  return isDetachedBlock ? top : start;
+}
+
+/** 块内容的结束行（去掉尾部的空行，空行由拼装时统一给一个） */
+function blockEnd(lines, start, next) {
+  let end = next;
+  while (end > start && isBlank(lines[end - 1])) end--;
+  return end;
+}
+
+/**
+ * 按 {@link TOP_LEVEL_ORDER} 重排 config.yaml 的顶层键，返回新文本（末尾保证一个换行）。
+ * 内容一字不改，只是整块换位置；没有顶层键时原样返回。
+ * @param {string} text
+ * @returns {string}
+ */
+export function orderTopLevel(text) {
+  const lines = text.split('\n');
+  /** 顶层键所在行 */
+  const keyLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (indentOf(lines[i]) === 0 && keyOf(lines[i])) keyLines.push(i);
+  }
+  if (!keyLines.length) return text;
+
+  // 第一个键上面的注释是文件头，不跟着键走；其余键上方紧贴的注释跟着键
+  const starts = keyLines.map((i, n) => (n === 0 ? i : blockStart(lines, i)));
+  /** @type {{ start: number, end: number, key: string }[]} 每块：起点（含自己的注释）到下一块起点（去掉尾随空行） */
+  const blocks = keyLines.map((i, n) => {
+    const rawEnd = n + 1 < starts.length ? starts[n + 1] : lines.length;
+    return { start: starts[n], end: blockEnd(lines, starts[n], rawEnd), key: keyOf(lines[i]) };
+  });
+  const prologue = lines.slice(0, blocks[0].start);
+  // 文件头与第一个键之间也不留空行
+  while (prologue.length && isBlank(prologue[prologue.length - 1])) prologue.pop();
+
+  const ordered = blocks
+    .map((b, i) => ({ ...b, order: i, rank: rankOf(b.key) }))
+    .sort((a, b) => a.rank - b.rank || a.order - b.order);
+
+  const out = [...prologue];
+  for (const b of ordered) out.push(...lines.slice(b.start, b.end)); // 键挨着键，不插空行
+  return `${out.join('\n').replace(/\n+$/, '')}\n`;
+}
+
+/** 排序权重：认识的键按表里的位置，不认识的统一排在「规则」组前面 */
+function rankOf(key) {
+  const i = TOP_LEVEL_ORDER.indexOf(key);
+  return i < 0 ? UNKNOWN_RANK - 0.5 : i;
+}