@lancewu602/mihomo-dash 0.0.0-stage → 0.6.0

package/server/src/http/settings.js

@@ -0,0 +1,409 @@
+/**
+ * 面板「快捷设置」的持久化：文本级改写 config.yaml 的顶层键（保留注释与排版），
+ * 校验「改写后解析结果与预期一致」后写盘 → 应用。
+ *
+ * 两种应用方式（由键本身决定）：
+ * - 内核 PATCH /configs 支持的几项（mode / mixed-port / allow-lan / log-level / tcp-concurrent /
+ *   find-process-mode）：写完 PATCH 对齐运行时，不整包重载，因此不会重置「规则临时禁用」
+ *   「节点固定选择」等仅运行时状态；
+ * - 内核 PATCH 的 schema 里没有的项（GEO 那组 geodata-mode / geo-auto-update / geo-update-interval / geox-url，
+ *   以及 unified-delay —— 2026-11 实测：PATCH 带上它内核回 204 但值不变，静默忽略）：
+ *   只能整包热重载（PUT /configs?force=true）才生效；
+ *   geox-url 的子键写法以 config.yaml 为准（geosite / geoip / mmdb / asn）。
+ */
+import { writeFileAtomic } from '../shared/atomic-file.js';
+import { KERNEL_DOWN_WARNING, orderedConfigText, saveConfigWithReload } from './config-files.js';
+import { configPath } from '../shared/paths.js';
+import { kernelFetch } from '../kernel/client.js';
+import {
+  indentOf,
+  insertAtSectionEnd,
+  keyOf,
+  loadConfig,
+  normalize,
+  removeRange,
+  sectionEnd,
+  verifyRewrite,
+} from './config-sections.js';
+
+/** 内核支持的运行模式（config.yaml 的 mode 取值） */
+const MODES = ['rule', 'global', 'direct'];
+/** 内核支持的日志级别（config.yaml 的 log-level 取值） */
+const LOG_LEVELS = ['silent', 'error', 'warning', 'info', 'debug'];
+/** 进程匹配模式（find-process-mode）：always = 强制匹配所有连接，strict = 交给内核判断，off = 不匹配 */
+const FIND_PROCESS_MODES = ['always', 'strict', 'off'];
+
+/**
+ * 只能整包热重载生效的键（内核 PATCH /configs 的 schema 里没有，或实测被忽略）。
+ * `unified-delay` 实测（v1.19.32）：PATCH 回 204 但 `GET /configs` 里值不变 —— 静默忽略，所以归到这里。
+ */
+const RELOAD_KEYS = [
+  'geodata-mode',
+  'geo-auto-update',
+  'geo-update-interval',
+  'geox-url',
+  'unified-delay',
+];
+
+/**
+ * geox-url 支持的子键（**写法以 config.yaml 为准**：`geosite` / `geoip` / `mmdb` / `asn`）。
+ * 注意内核控制接口 `GET /configs` 用的是 JSON 字段名 `geo-site` / `geo-ip`（见 config.GeoXUrl），
+ * 两者不可混用：写错名字内核会静默忽略，面板与内核取值时需自行对应。
+ * 空字符串 = 从配置里删掉该子键，回退内核默认地址。
+ */
+const GEOX_KEYS = ['geosite', 'geoip', 'mmdb', 'asn'];
+
+/** 布尔键的解析器（工厂）：非法时报错并带上键名 */
+const booleanSpec = (key) => (v) => {
+  if (typeof v !== 'boolean') throw new Error(`${key} 非法：${v}（需为 true / false）`);
+  return v;
+};
+
+/** 可持久化的顶层标量键：解析 + 校验 + 归一化 */
+const SCALAR_SPECS = {
+  mode: (v) => {
+    const s = String(v ?? '')
+      .trim()
+      .toLowerCase();
+    if (!MODES.includes(s))
+      throw new Error(`运行模式非法：${s || '(空)'}（可选 ${MODES.join(' / ')}）`);
+    return s;
+  },
+  'mixed-port': (v) => {
+    const n = typeof v === 'number' ? v : Number(String(v ?? '').trim());
+    if (!Number.isInteger(n) || n < 1 || n > 65535) {
+      throw new Error(`mixed-port 非法：${v}（需为 1-65535 的整数）`);
+    }
+    return n;
+  },
+  'allow-lan': booleanSpec('allow-lan'),
+  // 延迟测试是否统一口径（只算 RTT）：改动需整包热重载（见 RELOAD_KEYS）
+  'unified-delay': booleanSpec('unified-delay'),
+  // 并发拨号：对 DNS 解析出的所有 IP 同时建连、取最先成功者；内核 PATCH 支持，改完不用重载
+  'tcp-concurrent': booleanSpec('tcp-concurrent'),
+  'log-level': (v) => {
+    const s = String(v ?? '')
+      .trim()
+      .toLowerCase();
+    if (!LOG_LEVELS.includes(s))
+      throw new Error(`log-level 非法：${s || '(空)'}（可选 ${LOG_LEVELS.join(' / ')}）`);
+    return s;
+  },
+  // GEO：geodata-mode=true 用 geoip.dat（geodata loader），false 用 mmdb
+  'geodata-mode': booleanSpec('geodata-mode'),
+  // GEO 自动更新：内核只在启动时注册更新任务，改动需重启内核才真正生效
+  'geo-auto-update': booleanSpec('geo-auto-update'),
+  'geo-update-interval': (v) => {
+    const n = typeof v === 'number' ? v : Number(String(v ?? '').trim());
+    if (!Number.isInteger(n) || n < 1 || n > 720) {
+      throw new Error(`geo-update-interval 非法：${v}（需为 1-720 的整数，单位：小时）`);
+    }
+    return n;
+  },
+  // 进程匹配：面板概览的「流量分布 · 按进程」靠它（strict 时内核可能一个都匹配不到，实测如此）
+  // 注意：这个键 **在 PATCH /configs 的 schema 里**（2026-11 用独立实例实测：PATCH 回 204、
+  // GET /configs 立刻变），所以不进 RELOAD_KEYS，改完即时生效、不用重启内核。
+  'find-process-mode': (v) => {
+    const s = String(v ?? '')
+      .trim()
+      .toLowerCase();
+    if (!FIND_PROCESS_MODES.includes(s)) {
+      throw new Error(
+        `find-process-mode 非法：${s || '(空)'}（可选 ${FIND_PROCESS_MODES.join(' / ')}）`,
+      );
+    }
+    return s;
+  },
+};
+
+/** 可持久化的键名列表（用于报错提示） */
+const SETTING_KEYS = [...Object.keys(SCALAR_SPECS), 'geox-url'];
+
+/**
+ * 解析 geox-url 子键补丁：值必须是 http(s) 链接，空串表示「删除该子键」（回退内核默认）。
+ * @param {Record<string, unknown>} v
+ * @returns {Record<string, string | null>}
+ */
+function parseGeoxUrl(v) {
+  if (!v || typeof v !== 'object' || Array.isArray(v)) {
+    throw new Error(`geox-url 非法：需为 { "${GEOX_KEYS[0]}": "https://..." } 形式的对象`);
+  }
+  /** @type {Record<string, string | null>} */
+  const out = {};
+  for (const [key, raw] of Object.entries(v)) {
+    if (!GEOX_KEYS.includes(key)) {
+      throw new Error(
+        `geox-url 不支持的子键：${key}（config.yaml 里可选 ${GEOX_KEYS.join(' / ')}；` +
+          '内核接口里的 geo-site / geo-ip 对应配置文件里的 geosite / geoip）',
+      );
+    }
+    const url = String(raw ?? '').trim();
+    if (!url) {
+      out[key] = null;
+      continue;
+    }
+    if (!/^https?:\/\/\S+$/i.test(url)) {
+      throw new Error(`geox-url.${key} 非法：${url}（需为 http(s) 链接）`);
+    }
+    out[key] = url;
+  }
+  if (!Object.keys(out).length)
+    throw new Error(`geox-url 未指定任何子键（可选 ${GEOX_KEYS.join(' / ')}）`);
+  return out;
+}
+
+/** `key: value` 行：兼容引号键与引号值，只替换值部分，保留行尾注释 */
+const linePattern = (key) =>
+  new RegExp(`^(\\s*(?:"${key}"|'${key}'|${key})\\s*:\\s*)(?:"[^"]*"|'[^']*'|[^\\s#]+)`);
+
+/** 顶层键所在行号，找不到返回 -1 */
+function findLine(lines, key) {
+  return lines.findIndex((l) => indentOf(l) === 0 && keyOf(l) === key);
+}
+
+/** 缺失键的插入位置（下标）：文件头部注释块之后 */
+function headerInsertPos(lines) {
+  const at = lines.findIndex((l) => l.trim() && !l.trim().startsWith('#'));
+  return at < 0 ? lines.length : at;
+}
+
+/** 写回文件时的字面量：数字 / 布尔直接转字符串；含 : # 或空白的字符串加双引号 */
+function scalar(v) {
+  if (typeof v !== 'string') return `${v}`;
+  return /[:#\s]/.test(v) ? `"${v.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"` : v;
+}
+
+/** geox-url 段落头是行内写法时改为块状；带真实值时报错（避免误删数据） */
+function ensureBlockHeader(lines, at, section) {
+  const inline = lines[at]
+    .replace(new RegExp(`^\\s*(?:"${section}"|'${section}'|${section})\\s*:`), '')
+    .trim();
+  if (!inline || /^[{[]\s*[}\]]\s*$/.test(inline)) {
+    lines[at] = lines[at].replace(/:\s*.*$/, ':');
+    return;
+  }
+  throw new Error(`${section} 目前是行内写法（${inline}），请先在配置页改为块状写法再保存`);
+}
+
+/** 段落内仍然存在的子键所在行号（段落的「有效内容」） */
+function sectionKeyLines(lines, at) {
+  const end = sectionEnd(lines, at + 1);
+  const found = [];
+  for (let i = at + 1; i < end; i++) {
+    if (indentOf(lines[i]) >= 2 && keyOf(lines[i])) found.push(i);
+  }
+  return found;
+}
+
+/**
+ * 改写 `geox-url` 内的子键：已存在的行就地替换（保留行尾注释），缺失的补行，值为 null 的删行；
+ * 子键被删空时连同段落头一起移除（回退内核默认地址）。
+ * @param {string[]} lines
+ * @param {Record<string, string | null>} geoxPatch
+ * @returns {string[]} 改写后的行数组（删除整个段落返回新数组）
+ */
+function rewriteGeoxUrl(lines, geoxPatch) {
+  /** @type {[string, string][]} 段落内没有对应行、需要补的子键 */
+  const adds = [];
+  for (const [key, value] of Object.entries(geoxPatch)) {
+    // 每轮重新定位：删行会移动后续行号
+    const at = findLine(lines, 'geox-url');
+    const found =
+      at < 0 ? -1 : (sectionKeyLines(lines, at).find((i) => keyOf(lines[i]) === key) ?? -1);
+    if (found >= 0) {
+      if (value === null) {
+        lines.splice(found, 1); // 删掉该子键，回退内核默认
+        continue;
+      }
+      const re = linePattern(key);
+      lines[found] = re.test(lines[found])
+        ? lines[found].replace(re, `$1${scalar(value)}`)
+        : `  ${key}: ${scalar(value)}`;
+      continue;
+    }
+    if (value !== null) adds.push([key, value]); // 段落或子键不存在：待补
+  }
+
+  if (adds.length) {
+    let at = findLine(lines, 'geox-url');
+    if (at < 0) {
+      lines.splice(headerInsertPos(lines), 0, 'geox-url:');
+      at = findLine(lines, 'geox-url');
+    } else {
+      ensureBlockHeader(lines, at, 'geox-url');
+    }
+    // 新子键追加到段落末尾（不插到第一个子键前面，改动 diff 更干净）
+    lines = insertAtSectionEnd(
+      lines,
+      at,
+      adds.map(([k, v]) => `  ${k}: ${scalar(v)}`),
+    );
+  }
+
+  // 子键被删空：连同标题行移除（留着 `geox-url:` 空段落会解析成 null，且无实际意义）
+  const at = findLine(lines, 'geox-url');
+  if (at >= 0 && !sectionKeyLines(lines, at).length) {
+    return removeRange(lines, at, sectionEnd(lines, at + 1));
+  }
+  return lines;
+}
+
+/** 按 changed 生成「改写后应有的解析结果」，供 verifyRewrite 比对 */
+function expectedDoc(doc, changed) {
+  const expected = { ...doc };
+  for (const [key, value] of Object.entries(changed)) {
+    if (key !== 'geox-url') {
+      expected[key] = value;
+      continue;
+    }
+    const current = doc['geox-url'];
+    if (
+      current !== undefined &&
+      (typeof current !== 'object' || current === null || Array.isArray(current))
+    ) {
+      throw new Error('geox-url 目前不是映射写法，请先在配置页改为块状写法再保存');
+    }
+    const merged = { ...(current ?? {}) };
+    for (const [sub, url] of Object.entries(value)) {
+      if (url === null) delete merged[sub];
+      else merged[sub] = url;
+    }
+    // 子键被删空时整段移除（与 rewriteGeoxUrl 的行为一致）
+    if (Object.keys(merged).length) expected[key] = merged;
+    else delete expected[key];
+  }
+  return expected;
+}
+
+/**
+ * 持久化一组快捷设置：落盘 + 生效（标量键 PATCH，GEO 键整包热重载）。
+ * @param {Record<string, unknown>} input 形如 { mode: 'global', 'geodata-mode': true, 'geox-url': { geoip: 'https://...' } }
+ * @returns {Promise<{ applied: string[], previous: Record<string, unknown>, persisted: boolean, reloaded: boolean }>}
+ */
+export async function setSettings(input) {
+  const keys = Object.keys(input ?? {});
+  if (!keys.length) {
+    throw new Error(`未指定要修改的配置项（可选 ${SETTING_KEYS.join(' / ')}）`);
+  }
+  /** @type {Record<string, unknown>} */
+  const patch = {};
+  for (const key of keys) {
+    if (key === 'geox-url') {
+      patch[key] = parseGeoxUrl(input[key]);
+      continue;
+    }
+    const parse = SCALAR_SPECS[key];
+    if (!parse) {
+      throw new Error(
+        `不支持的配置项：${key}（可选 ${SETTING_KEYS.join(' / ')}）` +
+          '—— 若面板刚更新过代码，重启面板进程（服务管理器 stop/start，或 launchctl kickstart -k）后新配置项才会被认识',
+      );
+    }
+    patch[key] = parse(input[key]);
+  }
+
+  const { text, doc } = loadConfig();
+  /** @type {Record<string, unknown>} */
+  const previous = {};
+  /** @type {Record<string, unknown>} 只含真正变化的键（geox-url 为其子键补丁） */
+  const changed = {};
+  for (const [key, value] of Object.entries(patch)) {
+    previous[key] = doc[key] ?? null;
+    if (key !== 'geox-url') {
+      if (doc[key] !== value) changed[key] = value;
+      continue;
+    }
+    const current =
+      doc['geox-url'] && typeof doc['geox-url'] === 'object' && !Array.isArray(doc['geox-url'])
+        ? doc['geox-url']
+        : {};
+    const sub = Object.fromEntries(
+      Object.entries(value).filter(([k, v]) => (current[k] ?? null) !== v),
+    );
+    if (Object.keys(sub).length) changed[key] = sub;
+  }
+
+  const reload = Object.keys(changed).some((k) => RELOAD_KEYS.includes(k));
+
+  // 配置文件里已是目标值：GEO 键本就无需处理，标量键仍把运行时状态对齐一次
+  if (!Object.keys(changed).length) {
+    const scalars = Object.fromEntries(
+      Object.entries(patch).filter(([k]) => !RELOAD_KEYS.includes(k)),
+    );
+    const warning = Object.keys(scalars).length
+      ? await applyRuntimeQuiet(scalars, { written: false })
+      : null;
+    return {
+      applied: [],
+      previous,
+      persisted: false,
+      reloaded: false,
+      ...(warning && { warning }),
+    };
+  }
+
+  let lines = text.split('\n');
+  const inserts = [];
+  for (const [key, value] of Object.entries(changed)) {
+    if (key === 'geox-url') {
+      lines = rewriteGeoxUrl(lines, value);
+      continue;
+    }
+    const at = findLine(lines, key);
+    if (at < 0) {
+      inserts.push(`${key}: ${scalar(value)}`);
+      continue;
+    }
+    const re = linePattern(key);
+    lines[at] = re.test(lines[at])
+      ? lines[at].replace(re, `$1${scalar(value)}`)
+      : // 值是块状 / 空值等无法就地替换时整行重写（嵌套残留会被 verifyRewrite 拦下）
+        `${lines[at].match(/^\s*/)[0]}${key}: ${scalar(value)}`;
+  }
+  if (inserts.length) lines.splice(headerInsertPos(lines), 0, ...inserts);
+
+  // 顶层键按固定顺序排一遍（见 config-order.js），再校验「解析结果与预期一致」
+  const next = orderedConfigText(normalize(lines));
+  verifyRewrite(next, expectedDoc(doc, changed));
+
+  const applied = Object.keys(changed);
+
+  // GEO 键：PATCH 无效，走「校验 → 写盘 → 整包热重载」
+  if (reload) {
+    const result = await saveConfigWithReload(next);
+    return { applied, previous, persisted: true, ...result };
+  }
+
+  const p = configPath();
+  writeFileAtomic(p, next);
+  const warning = await applyRuntimeQuiet(patch);
+  if (warning) return { applied, previous, persisted: true, reloaded: false, warning };
+
+  return { applied, previous, persisted: true, reloaded: false };
+}
+
+/** 运行时生效：PATCH /configs 只改这几个键，不整包重载 */
+async function applyRuntime(patch) {
+  await kernelFetch('/configs', { method: 'PATCH', body: patch });
+}
+
+/**
+ * 运行时应用，但**把「内核没在跑」降级成 warning**：那时文件已经是目标值，等内核起来自然生效，
+ * 报错只会让页面弹「保存失败」、用户以为没写上。内核真回了错（配置不合法）仍然抛。
+ * @param {Record<string, unknown>} patch
+ * @param {{ written?: boolean }} [opts] written = 这次调用前是否已经写盘（决定报错文案）
+ * @returns {Promise<string|null>} warning 文案（正常返回 null）
+ */
+async function applyRuntimeQuiet(patch, { written = true } = {}) {
+  try {
+    await applyRuntime(patch);
+    return null;
+  } catch (e) {
+    if (!e?.status) return KERNEL_DOWN_WARNING;
+    throw new Error(
+      written
+        ? `内核应用失败（config.yaml 已写入，未回滚）: ${e.message}`
+        : `内核应用失败: ${e.message}`,
+    );
+  }
+}

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

@@ -0,0 +1,86 @@
+/**
+ * 系统代理接口：GET 读本机系统代理状态，PUT 开关。
+ *
+ * 只动**本机系统设置**（macOS networksetup / Linux gsettings），不碰内核：
+ * 内核的 mode 决定走不走节点，系统代理决定系统会不会把流量交给内核的端口，两层独立。
+ *
+ * 开启时除了写地址与端口，还会把 `BYPASS_DEFAULTS`（回环 / 私网 / link-local / 多播 / 本地域名的固定项）
+ * **补进**绕过列表 —— 与已有条目求并集、不删手工加的；关闭时不动绕过列表。补了哪些会从 `bypassAdded`
+ * 回给前端；GET 还会带上 `bypassDefaults`（值 + 说明），供页面把「固定项 / 自己加的 / 待补」分开展示。
+ *
+ * 面板无鉴权（仅监听 127.0.0.1），所以这里的写操作跟别的一样只接受 JSON body
+ * （跨站表单发不出 application/json，等于顺手挡掉一类 CSRF）。
+ */
+import { resolveKernelProxyTarget } from '../kernel/client.js';
+import { BYPASS_DEFAULTS, createSystemProxy } from '../shared/system-proxy.js';
+
+/**
+ * 只读探测系统代理：卸载内核这类「前置检查」用（**不动任何设置**）。
+ * 读不到 / 平台不支持时回 `{ supported: false, enabled: false, hint }`，调用方据此决定放不放行。
+ * @param {{ run?: Function, platform?: string }} [opts] 测试可注入假执行器
+ * @returns {Promise<{ supported: boolean, enabled: boolean, hint?: string, [k: string]: unknown }>}
+ */
+export async function readSystemProxyState(opts = {}) {
+  const state = await createSystemProxy(opts).read();
+  return { enabled: false, ...state };
+}
+
+/**
+ * 关掉系统代理（如果它开着）。
+ *
+ * 停内核 / 卸载内核前调它：系统代理指向的就是内核的 mixed-port，内核一停，系统还会把流量
+ * 交给那个没人监听的端口 —— 用户看到的就是「突然上不了网」。所以先把系统代理关掉（= 系统直连），
+ * 再停内核。本平台不支持读系统代理、或读/写失败时一律**不阻止**停内核，只把原因回给调用方。
+ * @param {{ run?: Function, platform?: string }} [opts] 测试可注入假执行器，不碰真实系统设置
+ * @returns {Promise<{ disabled: boolean, reason?: string }>} disabled=true 表示真的关了一个开着的系统代理
+ */
+export async function disableSystemProxyIfOn(opts = {}) {
+  try {
+    const proxy = createSystemProxy(opts);
+    const state = await proxy.read();
+    if (!state.supported) return { disabled: false, reason: 'unsupported' };
+    if (!state.enabled) return { disabled: false, reason: 'already-off' };
+    const target = await resolveKernelProxyTarget();
+    await proxy.setEnabled(false, target);
+    return { disabled: true };
+  } catch (err) {
+    return { disabled: false, reason: String(err?.message || err) };
+  }
+}
+
+/**
+ * 注册 `/api/system-proxy` 两个端点。
+ * @param {import('express').Express} app
+ * @param {{ run?: Function, platform?: string }} [opts] 测试可注入假执行器，不碰真实系统设置
+ */
+export function registerSystemProxyRoutes(app, opts = {}) {
+  const proxy = createSystemProxy(opts);
+
+  app.get('/api/system-proxy', async (_req, res) => {
+    try {
+      const [state, target] = await Promise.all([proxy.read(), resolveKernelProxyTarget()]);
+      res.json({ ...state, target, bypassDefaults: BYPASS_DEFAULTS });
+    } catch (err) {
+      res.status(500).json({ error: String(err?.message || err) });
+    }
+  });
+
+  app.put('/api/system-proxy', async (req, res) => {
+    try {
+      const enabled = req.body?.enabled;
+      if (typeof enabled !== 'boolean') throw new Error('enabled 必须是 true / false');
+      const state = await proxy.read();
+      if (!state.supported) throw new Error(state.hint || '本平台不支持改系统代理');
+      const target = await resolveKernelProxyTarget();
+      const result = await proxy.setEnabled(enabled, target);
+      res.json({
+        ...result.state,
+        target,
+        applied: result.applied,
+        bypassAdded: result.bypassAdded,
+      });
+    } catch (err) {
+      res.status(400).json({ error: String(err?.message || err) });
+    }
+  });
+}

package/server/src/index.js

@@ -0,0 +1,26 @@
+/**
+ * 后端入口：前台起面板服务（`npm --prefix server start`）。
+ *
+ * 服务管理器拉起的入口是 `bin/mihomo-dash-runner.js panel`，它复用这里的 `runPanel()`，
+ * 所以「手动起」与「被 launchd / systemd 拉起」走同一条代码路径。
+ */
+import { startServer } from './http/index.js';
+import { parseArgs, parsePort } from './shared/args.js';
+import { DEFAULT_HOST, DEFAULT_PORT } from './shared/paths.js';
+
+/**
+ * @param {Record<string, string|boolean>} [flags] `--port` / `--host` / `--dev`
+ */
+export async function runPanel(flags = {}) {
+  await startServer({
+    port: parsePort(flags.port, DEFAULT_PORT),
+    host: typeof flags.host === 'string' ? flags.host : DEFAULT_HOST,
+    dev: !!flags.dev,
+  });
+}
+
+// 直接被执行时（不是被 runner import）才起服务
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const { flags } = parseArgs(process.argv.slice(2));
+  await runPanel(flags);
+}