feat: 合并边缘节点运维并完善 Surge 配置安全

迁入通用节点部署工具、离线交付页生成器和共用技能，隔离真实配置与交付产物。统一 Codex 与 Claude Code 开发约定，补充节点迁移与运维文档。

完善 FINAL、策略组引用、输入校验、Surge 字段编码与 AI DNS 例外保护，增加隔离测试和订阅验证工具。

验证：全量类型检查、44 项单测、前端构建、脚本语法、技能入口与凭据隔离检查均通过。

server/src/routes/rules.ts

@@ -25,36 +25,52 @@ function loadRules(): RuleDto[] {
 /** 引用不存在的策略组会被 IR 静默剔除，必须在写入前拦下 */
 function policyError(policy: string): string | null {
   if ((BUILTIN_POLICIES as readonly string[]).includes(policy)) return null;
-  const exists = db.select({ id: policyGroups.id }).from(policyGroups).where(eq(policyGroups.name, policy)).get();
-  return exists ? null : `策略「${policy}」不存在：请选择内置策略或已有策略组`;
+  const group = db.select().from(policyGroups).where(eq(policyGroups.name, policy)).get();
+  return group?.enabled ? null : `策略「${policy}」不存在或已停用：请选择内置策略或启用的策略组`;
+}
+
+function inputError(input: z.output<typeof ruleInputSchema>, id?: string): string | null {
+  const err = policyError(input.policy);
+  if (err) return err;
+  if (input.type === 'FINAL' && db.select().from(rules).all().some((r) => r.type === 'FINAL' && r.id !== id)) return '只能有一条 FINAL 规则';
+  if (['RULE-SET', 'DOMAIN-SET'].includes(input.type) && !db.select().from(rulesets).where(eq(rulesets.id, input.value!)).get()) return '规则集不存在';
+  return null;
 }
 
 export const rulesRoute = new Hono()
   .get('/', (c) => c.json(loadRules()))
   .post('/', zValidator('json', ruleInputSchema), (c) => {
     const input = c.req.valid('json');
-    const err = policyError(input.policy);
+    const err = inputError(input);
     if (err) return c.json({ error: err }, 400);
     // 规则首条匹配即生效，自定义规则必须压过模板里的宽泛规则集（如 download.conf），插到最前
-    db.update(rules).set({ seq: sql`${rules.seq} + 1` }).run();
     const id = nanoid(10);
-    db.insert(rules)
-      .values({
-        id,
-        seq: 0,
-        type: input.type,
-        value: input.value ?? null,
-        policy: input.policy,
-        params: JSON.stringify(input.params),
-        enabled: input.enabled,
-        source: 'custom',
-      })
-      .run();
+    db.transaction(() => {
+      if (input.type !== 'FINAL') db.update(rules).set({ seq: sql`${rules.seq} + 1` }).run();
+      const seq = input.type === 'FINAL' ? Math.max(-1, ...db.select().from(rules).all().map((r) => r.seq)) + 1 : 0;
+      db.insert(rules)
+        .values({
+          id,
+          seq,
+          type: input.type,
+          value: input.value ?? null,
+          policy: input.policy,
+          params: JSON.stringify(input.params),
+          enabled: input.enabled,
+          source: 'custom',
+        })
+        .run();
+    });
     return c.json({ id }, 201);
   })
   .put('/reorder', zValidator('json', z.object({ ids: z.array(z.string()) })), (c) => {
     const { ids } = c.req.valid('json');
-    ids.forEach((id, i) => db.update(rules).set({ seq: i }).where(eq(rules.id, id)).run());
+    const rows = db.select().from(rules).all();
+    const known = new Set(rows.map((r) => r.id));
+    if (ids.length !== rows.length || new Set(ids).size !== ids.length || ids.some((id) => !known.has(id))) return c.json({ error: '排序必须包含全部规则且每条仅出现一次' }, 400);
+    const finals = rows.filter((r) => r.type === 'FINAL');
+    if (finals.length !== 1 || !finals[0].enabled || ids.at(-1) !== finals[0].id) return c.json({ error: '启用的唯一 FINAL 必须位于末尾' }, 400);
+    db.transaction(() => ids.forEach((id, i) => db.update(rules).set({ seq: i }).where(eq(rules.id, id)).run()));
     return c.json({ ok: true });
   })
   .post('/reset', (c) => {
@@ -66,7 +82,9 @@ export const rulesRoute = new Hono()
     const existing = db.select().from(rules).where(eq(rules.id, id)).get();
     if (!existing) return c.json({ error: '规则不存在' }, 404);
     const input = c.req.valid('json');
-    const err = policyError(input.policy);
+    if (existing.type === 'FINAL' && input.type !== 'FINAL') return c.json({ error: '不能将 FINAL 改成其他规则类型' }, 400);
+    if (existing.type !== 'FINAL' && input.type === 'FINAL') return c.json({ error: '请编辑已有 FINAL，不能改变普通规则的类型为 FINAL' }, 400);
+    const err = inputError(input, id);
     if (err) return c.json({ error: err }, 400);
     db.update(rules)
       .set({
@@ -81,6 +99,9 @@ export const rulesRoute = new Hono()
     return c.json({ ok: true });
   })
   .patch('/:id/enabled', zValidator('json', z.object({ enabled: z.boolean() })), (c) => {
+    const row = db.select().from(rules).where(eq(rules.id, c.req.param('id'))).get();
+    if (!row) return c.json({ error: '规则不存在' }, 404);
+    if (row.type === 'FINAL' && !c.req.valid('json').enabled) return c.json({ error: '不能停用 FINAL' }, 400);
     const res = db
       .update(rules)
       .set({ enabled: c.req.valid('json').enabled })
@@ -90,6 +111,9 @@ export const rulesRoute = new Hono()
     return c.json({ ok: true });
   })
   .delete('/:id', (c) => {
+    const row = db.select().from(rules).where(eq(rules.id, c.req.param('id'))).get();
+    if (!row) return c.json({ error: '规则不存在' }, 404);
+    if (row.type === 'FINAL') return c.json({ error: '不能删除 FINAL' }, 400);
     const res = db.delete(rules).where(eq(rules.id, c.req.param('id'))).run();
     if (res.changes === 0) return c.json({ error: '规则不存在' }, 404);
     return c.json({ ok: true });