@lancewu602/mihomo-dash 0.0.0-stage → 0.6.1

package/server/src/http/rules.js

@@ -0,0 +1,509 @@
+/**
+ * 规则页的两块内容（都落 config.yaml 的 `rules` 段，写盘 → 热重载）：
+ *
+ * 1. **自定义规则**：`# >>> mihomo-dash 自定义规则` 标记块里的条目，面板只允许新增 `DOMAIN-SUFFIX`
+ *    （2026-11 定：曾经放开过任意类型，随后按用户要求收回；GEOSITE / IP-CIDR 这类去「配置文件」页写）。
+ *    支持新增与删除（都不再提供排序），新规则插到第一条 `MATCH`/`FINAL` 之前。
+ * 2. **系统规则**（{@link SYSTEM_RULES}）：固定那几条 GEOSITE + 末尾 `MATCH`，卡片上逐条启 / 禁、并能选目标。
+ *    禁用的写法是**把该行注释掉**（内容留着，随时能再启用），因此解析结果里它就消失了 —— 这就是「热重载后不再生效」。
+ *    `MATCH` 是兜底规则，不给开关（禁掉会让未匹配的流量没处去）。
+ *
+ * 两处改写都保留注释与其它段落：文本级定位 + `verifyRewrite` 校验「解析结果与预期一致」后才写盘。
+ */
+import fs from 'node:fs';
+import { configPath } from '../shared/paths.js';
+import { saveConfigWithReload } from './config-files.js';
+import {
+  findSection,
+  indentOf,
+  listIndent,
+  listSection,
+  loadConfig,
+  normalize,
+  openEmptyFlowSection,
+  removeRange,
+  scalarItemOf,
+  sectionEnd,
+  verifyRewrite,
+} from './config-sections.js';
+
+const SECTION = 'rules';
+/** 标记块：面板在这里增删 / 排序；块外规则只读不动 */
+const BEGIN_MARK = '# >>> mihomo-dash 自定义规则';
+const BEGIN_LINE = `${BEGIN_MARK}（这块由面板维护，请通过规则页增删排序）`;
+const END_MARK = '# <<< mihomo-dash 自定义规则';
+/** DOMAIN-SUFFIX / DOMAIN 的域名：至少两级标签，支持 `+.example.com`（含子域）写法 */
+const DOMAIN_RE = /^(?:\+\.)?(?:[a-z0-9_](?:[a-z0-9_-]*[a-z0-9_])?\.)+[a-z]{2,}$/i;
+/** 没有参数的规则类型：`MATCH,target` / `FINAL,target` */
+const NO_PAYLOAD = new Set(['MATCH', 'FINAL']);
+/** 面板唯一允许新增的规则类型 */
+const ONLY_TYPE = 'DOMAIN-SUFFIX';
+/** 末尾兜底型规则：新规则一律插到它们之前 */
+const CATCH_ALL = new Set(['MATCH', 'FINAL']);
+const TYPE_RE = /^[A-Z][A-Z0-9-]{0,31}$/;
+
+/** 校验并规范化域名（小写、去空白） */
+export function normalizeDomain(raw) {
+  const d = String(raw ?? '')
+    .trim()
+    .toLowerCase();
+  if (!d) throw new Error('域名不能为空');
+  if (!DOMAIN_RE.test(d)) {
+    throw new Error(`域名不合法：${raw}（示例 example.com，含子域可用 +.example.com）`);
+  }
+  return d;
+}
+
+/** 校验规则目标（策略组名 / DIRECT / REJECT 等） */
+function assertTarget(raw) {
+  const t = String(raw ?? '').trim();
+  if (!t) throw new Error('目标不能为空（策略组 / DIRECT / REJECT）');
+  if (/[\n\r,#]/.test(t)) throw new Error('目标不能包含 , # 或换行');
+  if (t.length > 64) throw new Error('目标过长（≤64 字符）');
+  return t;
+}
+
+/**
+ * 拆解规则行 `TYPE,参数,目标[,其它参数…]`。
+ * `MATCH` / `FINAL` 没有参数（`MATCH,DIRECT`），参数位为空串。
+ * @param {string} raw
+ * @returns {{ type: string, payload: string, target: string, params: string[] }|null} 结构不足时 null
+ */
+export function parseRuleLine(raw) {
+  const parts = String(raw ?? '')
+    .split(',')
+    .map((s) => s.trim());
+  const type = (parts[0] || '').toUpperCase();
+  if (!TYPE_RE.test(type)) return null;
+  if (NO_PAYLOAD.has(type)) {
+    if (parts.length < 2 || !parts[1]) return null;
+    return { type, payload: '', target: parts[1], params: parts.slice(2) };
+  }
+  if (parts.length < 3 || !parts[1] || !parts[2]) return null;
+  return { type, payload: parts[1], target: parts[2], params: parts.slice(3) };
+}
+
+/** 把解析结果拼回一行（`params` 原样跟在后面，`no-resolve` 这类写法不会被吃掉） */
+export function ruleLine({ type, payload, target, params = [] }) {
+  return [type, payload, target, ...params].filter((s) => s !== '' && s != null).join(',');
+}
+
+/**
+ * 校验并规范化一条要新增的规则：**只认 `DOMAIN-SUFFIX`**。
+ * 可以给 `type` / `payload` / `target`，也可以直接给整行原文 `rule`（如 `DOMAIN-SUFFIX,a.com,DIRECT`）。
+ * @param {{ rule?: string, type?: string, payload?: string, target?: string }} input
+ * @returns {{ type: string, payload: string, target: string, params: string[], rule: string }}
+ */
+export function normalizeRule(input) {
+  const raw = String(input?.rule ?? '').trim();
+  let parsed;
+  if (raw) {
+    parsed = parseRuleLine(raw);
+    if (!parsed) {
+      throw new Error(
+        `规则格式不对：${raw}（应为 ${ONLY_TYPE},域名,目标，例如 ${ONLY_TYPE},example.com,DIRECT）`,
+      );
+    }
+  } else {
+    const type = String(input?.type ?? ONLY_TYPE)
+      .trim()
+      .toUpperCase();
+    parsed = {
+      type: type || ONLY_TYPE,
+      payload: String(input?.payload ?? '').trim(),
+      target: String(input?.target ?? '').trim(),
+      params: [],
+    };
+  }
+  if (parsed.type !== ONLY_TYPE) {
+    throw new Error(
+      `面板只加 ${ONLY_TYPE} 规则（收到 ${parsed.type || '空类型'}）：GEOSITE / IP-CIDR 这类请去「配置文件」页写`,
+    );
+  }
+  parsed.payload = normalizeDomain(parsed.payload);
+  parsed.target = assertTarget(parsed.target);
+  return { ...parsed, rule: ruleLine(parsed) };
+}
+
+const isBegin = (line) => line.trim().startsWith(BEGIN_MARK);
+const isEnd = (line) => line.trim().startsWith(END_MARK);
+
+/** 定位标记块 [begin, end]（含两行标记）；缺少任一标记时返回 null */
+function findBlock(lines) {
+  const begin = lines.findIndex(isBegin);
+  if (begin < 0) return null;
+  for (let i = begin + 1; i < lines.length; i++) {
+    if (isEnd(lines[i])) return { begin, end: i };
+  }
+  return null;
+}
+
+/** 标记块内的标量条目（带所在行号） */
+function blockItems(lines, block) {
+  const items = [];
+  for (let i = block.begin + 1; i < block.end; i++) {
+    const raw = scalarItemOf(lines[i]);
+    if (raw !== null) items.push({ index: i, raw });
+  }
+  return items;
+}
+
+/** [sectionLine+1, until) 之间的条目数：新条目 / 被删条目在解析结果里的下标 */
+function countItems(lines, sectionLine, until) {
+  let n = 0;
+  for (let i = sectionLine + 1; i < until; i++) if (scalarItemOf(lines[i]) !== null) n++;
+  return n;
+}
+
+/**
+ * 读取面板管理的规则（标记块内全部条目，按文件里的顺序）。
+ * @returns {{ exists: boolean, rules: Array<{ raw: string, type: string, payload: string, target: string }>, total: number }}
+ */
+export function listCustomRules() {
+  const { text, doc } = loadConfigOrEmpty();
+  const lines = text.split('\n');
+  const block = findBlock(lines);
+  const rules = [];
+  if (block) {
+    for (const { raw } of blockItems(lines, block)) {
+      const p = parseRuleLine(raw);
+      rules.push(
+        p
+          ? { raw, type: p.type, payload: p.payload, target: p.target }
+          : { raw, type: '', payload: '', target: '' },
+      );
+    }
+  }
+  return { exists: !!block, rules, total: listSection(doc, SECTION).length };
+}
+
+/**
+ * 新增规则：写入标记块（无块时在 rules 段首创建）并热重载。
+ * 插入位置 = 第一条 `MATCH` / `FINAL` 之前（那之后写什么都不会生效），没有就追加到末尾。
+ * @param {{ rule?: string, type?: string, payload?: string, target?: string }} input
+ */
+export async function addRule(input) {
+  const { type, payload, rule } = normalizeRule(input);
+
+  const { text, doc } = loadConfig();
+  const list = listSection(doc, SECTION);
+  const lines = text.split('\n');
+  const at = findSection(lines, SECTION);
+  if (at < 0) throw new Error('config.yaml 中未找到 rules 段');
+
+  // 同类型同参数只允许一条（目标不同也算重复），否则顺序与去重都说不清
+  const dup = list.findIndex((r) => {
+    const p = parseRuleLine(r);
+    return p && p.type === type && p.payload.toLowerCase() === payload.toLowerCase();
+  });
+  if (dup >= 0) {
+    throw new Error(`规则已存在：第 ${dup + 1} 条 ${String(list[dup]).trim()}`);
+  }
+
+  openEmptyFlowSection(lines, at, SECTION); // 兼容 `rules: []`
+  const block = findBlock(lines);
+  const pad = ' '.repeat(block ? indentOf(lines[block.begin]) : listIndent(lines, at));
+  // 没有块时先建块（两行标记），块建在 rules 段首
+  const blockLines = block ? [] : [`${pad}${BEGIN_LINE}`, `${pad}${END_MARK}`];
+  if (blockLines.length) lines.splice(at + 1, 0, ...blockLines);
+
+  const target = findBlock(lines);
+  const items = blockItems(lines, target);
+  const firstCatchAll = items.find((it) => {
+    const p = parseRuleLine(it.raw);
+    return p && CATCH_ALL.has(p.type);
+  });
+  const insertPos = firstCatchAll ? firstCatchAll.index : target.end;
+  const out = [...lines.slice(0, insertPos), `${pad}- ${rule}`, ...lines.slice(insertPos)];
+
+  const before = countItems(lines, at, insertPos); // 新条目在 rules 列表中的下标
+  const next = normalize(out);
+  verifyRewrite(next, {
+    ...doc,
+    [SECTION]: [...list.slice(0, before), rule, ...list.slice(before)],
+  });
+
+  const reload = await saveConfigWithReload(next);
+  return { ok: true, rule, insertedBefore: firstCatchAll ? firstCatchAll.raw : null, ...reload };
+}
+
+/**
+ * 删除规则：只从标记块内移除该行（块外的手工规则不动）；块内最后一条被删时标记一并移除。
+ * @param {{ raw?: string }} input 规则原文（`raw` 精确匹配，两边空白忽略）
+ */
+export async function removeRule(input) {
+  const raw = String(input?.raw ?? '').trim();
+  if (!raw) throw new Error('缺少要删除的规则（raw）');
+
+  const { text, doc } = loadConfig();
+  const list = listSection(doc, SECTION);
+  const lines = text.split('\n');
+  const at = findSection(lines, SECTION);
+  if (at < 0) throw new Error('config.yaml 中未找到 rules 段');
+
+  const block = findBlock(lines);
+  if (!block) throw new Error('config.yaml 中没有面板管理的规则块');
+
+  const items = blockItems(lines, block);
+  const hit = items.find(({ raw: line }) => line.trim() === raw);
+  if (!hit) throw new Error(`面板管理的规则块中未找到 ${raw}`);
+
+  const before = countItems(lines, at, hit.index); // 该条目在 rules 列表中的下标
+  if (String(list[before] ?? '').trim() !== hit.raw.trim()) {
+    throw new Error('规则块与 rules 段解析结果不一致（已放弃删除）');
+  }
+
+  let out;
+  let expected;
+  if (list.length === 1) {
+    // 最后一条规则：连同 rules 段头一起移除（空段解析出来是 null，与预期对不上）
+    out = removeRange(lines, at, sectionEnd(lines, at + 1));
+    expected = { ...doc };
+    delete expected[SECTION];
+  } else {
+    // 块内只剩这一条时连标记一起删
+    out =
+      items.length === 1
+        ? removeRange(lines, block.begin, block.end + 1, { blank: false })
+        : removeRange(lines, hit.index, hit.index + 1, { blank: false });
+    expected = { ...doc, [SECTION]: list.filter((_, i) => i !== before) };
+  }
+
+  const next = normalize(out);
+  verifyRewrite(next, expected);
+
+  const reload = await saveConfigWithReload(next);
+  return { ok: true, rule: hit.raw.trim(), ...reload };
+}
+
+/**
+ * 「系统规则」卡片固定展示的那几条（顺序即写入顺序）。
+ * - `desc`：给人看的概要（卡片表格里那一列），不参与任何改写
+ * - `target`：默认目标；`'PROXY'` 是占位，表示「用配置里第一个策略组」（没有组时退回 `DIRECT`）
+ * - `locked`：不给启 / 禁开关（`MATCH` 兜底那条）
+ */
+export const SYSTEM_RULES = [
+  {
+    key: 'private',
+    desc: '局域网 / 内网地址',
+    type: 'GEOSITE',
+    payload: 'private',
+    target: 'DIRECT',
+  },
+  {
+    key: 'ads',
+    desc: '广告与追踪域名',
+    type: 'GEOSITE',
+    payload: 'category-ads-all',
+    target: 'REJECT',
+  },
+  { key: 'cn', desc: '中国大陆站点', type: 'GEOSITE', payload: 'cn', target: 'DIRECT' },
+  { key: 'gfw', desc: '被墙（GFW）站点', type: 'GEOSITE', payload: 'gfw', target: 'PROXY' },
+  {
+    key: 'scholar',
+    desc: '学术站点（非中国大陆）',
+    type: 'GEOSITE',
+    payload: 'category-scholar-!cn',
+    target: 'PROXY',
+  },
+  {
+    key: 'ai',
+    desc: 'AI 服务（非中国大陆）',
+    type: 'GEOSITE',
+    payload: 'category-ai-!cn',
+    target: 'PROXY',
+  },
+  {
+    key: 'match',
+    desc: '以上都没命中时的兜底',
+    type: 'MATCH',
+    payload: '',
+    target: 'DIRECT',
+    locked: true,
+  },
+];
+
+const specOf = (key) => SYSTEM_RULES.find((r) => r.key === String(key ?? '').trim());
+
+/**
+ * 读 config.yaml，但**文件还不存在时不算错**：返回空文本 + 空文档。
+ * 这样规则页在内核刚装上、还没保存过配置的状态下也能把「系统规则」那几条固定列出来（都显示为未启用），
+ * 而不是整块读不出来 / 弹一堆错。解析失败仍然照旧抛错（那是真问题）。
+ */
+function loadConfigOrEmpty() {
+  if (!fs.existsSync(configPath())) return { text: '', doc: {}, missing: true };
+  return { ...loadConfig(), missing: false };
+}
+/** 配置里第一个策略组名（GEOSITE,gfw 这类默认走它）；没有组就退回 DIRECT */
+function firstGroupTarget(doc) {
+  const groups = Array.isArray(doc?.['proxy-groups']) ? doc['proxy-groups'] : [];
+  const name = groups.find((g) => g && typeof g === 'object' && g.name)?.name;
+  return name ? String(name) : 'DIRECT';
+}
+
+/** 把某一行当作规则来读：去掉注释前缀后能拆出 TYPE,参数,目标 才算（返回 null 表示不是规则行） */
+function ruleOnLine(line) {
+  const text = line.replace(/^\s*#\s*/, '').trim();
+  if (!text.startsWith('- ')) return null;
+  return parseRuleLine(text.slice(2));
+}
+
+/** 行的缩进（写回时用）：保持原缩进，0 / 2 两种列表写法都不能被改动 */
+function lineIndent(line) {
+  return ' '.repeat(indentOf(line));
+}
+
+/**
+ * 「系统规则」卡片的数据：固定那几条在当前配置里的状态。
+ * 不存在的条目也算一条（`enabled: false`，目标用默认值），这样卡片能把它启起来。
+ * @returns {{rules: Array<{key,desc,type,payload,target,enabled,locked,raw}>, lockedTarget: string}}
+ */
+export function listSystemRules() {
+  const { text, doc } = loadConfigOrEmpty();
+  const lines = text.split('\n');
+  const at = findSection(lines, SECTION);
+  const end = at < 0 ? -1 : sectionEnd(lines, at + 1);
+  const fallback = firstGroupTarget(doc);
+
+  const rules = SYSTEM_RULES.map((spec) => {
+    const want = { type: spec.type, payload: (spec.payload || '').toLowerCase() };
+    let hit = null;
+    for (let i = at + 1; end > 0 && i < end; i++) {
+      const parsed = ruleOnLine(lines[i]);
+      if (parsed && parsed.type === want.type && parsed.payload.toLowerCase() === want.payload) {
+        hit = { i, parsed, enabled: !/^\s*#/.test(lines[i]) };
+        break;
+      }
+    }
+    const defaultTarget = spec.target === 'PROXY' ? fallback : spec.target;
+    return {
+      key: spec.key,
+      desc: spec.desc,
+      type: spec.type,
+      payload: spec.payload,
+      target: hit?.parsed.target || defaultTarget,
+      enabled: !!hit?.enabled,
+      locked: !!spec.locked,
+      raw: hit
+        ? lines[hit.i]
+            .replace(/^\s*#\s*/, '')
+            .trim()
+            .slice(2)
+            .trim()
+        : '',
+    };
+  });
+  return { rules, lockedTarget: fallback };
+}
+
+/**
+ * 启 / 禁一条系统规则，或改它的目标：改 `rules` 段里对应那一行（行不存在时按固定顺序插入）→ 热重载。
+ * @param {{ key?: string, enabled?: boolean, target?: string }} input
+ * @returns {Promise<{ ok: true, key: string, enabled: boolean, target: string, rule: string }>}
+ */
+export async function setSystemRule(input) {
+  const spec = specOf(input?.key);
+  if (!spec) {
+    throw new Error(
+      `未知的系统规则：${input?.key ?? ''}（可选 ${SYSTEM_RULES.map((r) => r.key).join(' / ')}）`,
+    );
+  }
+  if (input?.enabled === false && spec.locked) {
+    throw new Error(`${spec.type},${spec.target} 是兜底规则，不能禁用`);
+  }
+
+  const { text, doc } = loadConfig();
+  const lines = text.split('\n');
+  const at = findSection(lines, SECTION);
+  if (at < 0) throw new Error('config.yaml 中未找到 rules 段');
+  const list = listSection(doc, SECTION);
+  const end = sectionEnd(lines, at + 1);
+  const fallback = firstGroupTarget(doc);
+
+  const want = { type: spec.type, payload: (spec.payload || '').toLowerCase() };
+  let hit = null;
+  for (let i = at + 1; i < end; i++) {
+    const parsed = ruleOnLine(lines[i]);
+    if (parsed && parsed.type === want.type && parsed.payload.toLowerCase() === want.payload) {
+      hit = { i, parsed };
+      break;
+    }
+  }
+
+  const target = assertTarget(
+    input?.target ?? hit?.parsed.target ?? (spec.target === 'PROXY' ? fallback : spec.target),
+  );
+  // 没传 enabled 就保持现状（只想改目标时不至于顺手把它关了）
+  const enabled =
+    typeof input?.enabled === 'boolean' ? input.enabled : hit ? !/^\s*#/.test(lines[hit.i]) : false;
+  const rule = ruleLine({ type: spec.type, payload: spec.payload, target });
+
+  if (!hit) {
+    if (!enabled) return { ok: true, key: spec.key, enabled: false, target, rule }; // 本来就没启用，无需写盘
+    const insertPos = systemRuleInsertPos(lines, at, end, spec);
+    const pad = ' '.repeat(listIndent(lines, at));
+    const before = countItems(lines, at, insertPos);
+    const out = [...lines.slice(0, insertPos), `${pad}- ${rule}`, ...lines.slice(insertPos)];
+    const next = normalize(out);
+    verifyRewrite(next, {
+      ...doc,
+      [SECTION]: [...list.slice(0, before), rule, ...list.slice(before)],
+    });
+    const reload = await saveConfigWithReload(next);
+    return { ok: true, key: spec.key, enabled: true, target, rule, inserted: true, ...reload };
+  }
+
+  const before = countItems(lines, at, hit.i);
+  const wasEnabled = !/^\s*#/.test(lines[hit.i]);
+  if (wasEnabled === enabled && hit.parsed.target === target) {
+    return { ok: true, key: spec.key, enabled, target, rule, unchanged: true };
+  }
+  const next = enabled
+    ? `${lineIndent(lines[hit.i])}- ${rule}`
+    : `${lineIndent(lines[hit.i])}# - ${rule}`;
+  const out = [...lines.slice(0, hit.i), next, ...lines.slice(hit.i + 1)];
+  const expected = enabled
+    ? {
+        ...doc,
+        [SECTION]: wasEnabled
+          ? list.map((r, i) => (i === before ? rule : r))
+          : [...list.slice(0, before), rule, ...list.slice(before)],
+      }
+    : {
+        ...doc,
+        [SECTION]: wasEnabled ? list.filter((_, i) => i !== before) : list,
+      };
+  const text2 = normalize(out);
+  verifyRewrite(text2, expected);
+  const reload = await saveConfigWithReload(text2);
+  return { ok: true, key: spec.key, enabled, target, rule, ...reload };
+}
+
+/**
+ * 新启用的系统规则插到哪：按 {@link SYSTEM_RULES} 的顺序，插到「排在它后面的第一条已存在系统规则」之前 ——
+ * 这样即使几条规则被删过，也能保持 private → ads → cn → gfw → scholar → ai → MATCH 的固定顺序。
+ */
+function systemRuleInsertPos(lines, at, end, spec) {
+  const hitKeys = new Map(); // 行号 → 该行是哪条系统规则的 key
+  for (let i = at + 1; i < end; i++) {
+    const parsed = ruleOnLine(lines[i]);
+    if (!parsed) continue;
+    const found = SYSTEM_RULES.find(
+      (r) =>
+        r.type === parsed.type && (r.payload || '').toLowerCase() === parsed.payload.toLowerCase(),
+    );
+    if (found) hitKeys.set(i, found.key);
+  }
+  const mine = SYSTEM_RULES.findIndex((r) => r.key === spec.key);
+  for (let i = at + 1; i < end; i++) {
+    const key = hitKeys.get(i);
+    if (!key) continue;
+    if (SYSTEM_RULES.findIndex((r) => r.key === key) > mine) return i;
+  }
+  // 后面没有系统规则了：插到第一条 MATCH/FINAL 之前，没有就追加到 rules 段末尾
+  for (let i = at + 1; i < end; i++) {
+    const parsed = ruleOnLine(lines[i]);
+    if (parsed && CATCH_ALL.has(parsed.type)) return i;
+  }
+  return end;
+}