From e9e2eb555dc4e79cee023d836d4bc078e89451b7 Mon Sep 17 00:00:00 2001 From: Jz0ojiang Date: Tue, 11 Aug 2026 03:10:38 +0800 Subject: [PATCH] =?UTF-8?q?=E6=AF=8F=E8=B7=AF=E5=85=A5=E7=AB=99=E9=85=8D?= =?UTF-8?q?=E4=B8=80=E7=BB=84=E4=B8=93=E5=B1=9E=E7=AD=96=E7=95=A5=E7=BB=84?= =?UTF-8?q?=EF=BC=8C=E6=8D=A2=E7=BA=BF=E4=B8=8D=E5=86=8D=E6=94=B9=E9=85=8D?= =?UTF-8?q?=E7=BD=AE=E6=96=87=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 原本换一条线要改 config.yaml、跑校验、等内核重载，几秒起步；而换线恰恰是这个工具 最高频的动作，把它放在最重的路径上方向就错了。现在每一路配一个 select 组加 AUTO、 FALLBACK 两个，入站的 proxy 永久指向 select，换线只是调一次内核接口。这样做的前提是 选中不会丢：内核把它写进 cache 文件，重启后由 patchSelectGroup 恢复，而 profile.store-selected 默认为真。 链式代理靠给来源订阅复制一份声明、挂上 override.dialer-proxy 实现，因为这个字段写在 策略组上内核只会打条日志然后忽略。副本是 type: file 读原订阅已经落盘的缓存，而不是 自己再拉一次：自己拉的话订阅地址一不可达副本就是空的，那一路入站会一条线都不剩， 表现是端口还在监听却没有任何出口。 顺带把 shared/outbound-chain.ts 里「只有 Selector 接受手动选择」那条断言删了，它是 错的（内核检查的是 SelectAble 接口，URLTest 和 Fallback 也实现了）。界面仍然只让 Selector 可点，但理由换成了另外两种的手动指定会被它们自己撤销。 完整取舍见工作区决策记录 0007。 --- scripts/verify-chain.ts | 49 +++ scripts/verify-pin.ts | 36 -- server/config-store.ts | 18 + server/index.ts | 4 +- server/kernel.ts | 18 + shared/filter-groups.test.ts | 110 ------ shared/filter-groups.ts | 118 ------ shared/inbound-groups.test.ts | 321 +++++++++++++++ shared/inbound-groups.ts | 501 +++++++++++++++++++++++ shared/outbound-chain.test.ts | 24 +- shared/outbound-chain.ts | 23 +- web/App.vue | 8 + web/components/InboundList.vue | 17 +- web/components/OutboundCard.vue | 34 +- web/components/SourcePicker.vue | 157 ++++++++ web/runtime.ts | 93 ++++- web/styles/tokens.css | 13 + web/views/InboundDetail.vue | 678 ++++++++++++++++++++++++-------- web/views/RouterPage.vue | 152 ++++--- 19 files changed, 1807 insertions(+), 567 deletions(-) create mode 100644 scripts/verify-chain.ts delete mode 100644 scripts/verify-pin.ts delete mode 100644 shared/filter-groups.test.ts delete mode 100644 shared/filter-groups.ts create mode 100644 shared/inbound-groups.test.ts create mode 100644 shared/inbound-groups.ts create mode 100644 web/components/SourcePicker.vue diff --git a/scripts/verify-chain.ts b/scripts/verify-chain.ts new file mode 100644 index 0000000..bfcaefb --- /dev/null +++ b/scripts/verify-chain.ts @@ -0,0 +1,49 @@ +/** + * 验证「每路一个专属代理组」和链式代理生成的配置内核真的接受。 + * + * 单元测试只能证明字符串拼对了，证明不了内核认。这里走一遍真实的写回路径， + * 产物交给 mihomo -t 校验。特别要看的是订阅副本上的 dialer-proxy 引用能不能过 + * `validateDialerProxies`（内核源码 config/utils.go:148-176）。 + * + * 用法：bun run scripts/verify-chain.ts <源配置> <输出路径> + */ +import { readFileSync, writeFileSync } from 'node:fs' +import { openDocument } from '../vendor/config-editor/index.ts' +import type { ConfigObject } from '../vendor/config-editor/index.ts' +import { rewriteYaml } from '../server/config-store.ts' +import { applySetup, pruneGenerated } from '../shared/inbound-groups.ts' + +const [src, out] = process.argv.slice(2) +if (!src || !out) { + console.error('用法：bun run scripts/verify-chain.ts <源配置> <输出路径>') + process.exit(1) +} + +const source = readFileSync(src, 'utf8') +const data = JSON.parse(JSON.stringify(openDocument(source).data)) as ConfigObject + +// 模拟界面上的三个动作：新增两路入站，一路直连，一路开链式代理并把入口筛到某一条线 +data.listeners = [ + { name: '容器A', type: 'mixed', port: 17895 }, + { name: '容器B', type: 'mixed', port: 17896 }, +] + +let next = applySetup(data, '容器A', { + proxy: { sources: ['subs'], filter: null }, + chain: null, +}) +next = applySetup(next, '容器B', { + proxy: { sources: ['subs'], filter: null }, + chain: { sources: ['subs'], filter: '(?i)DMIT' }, +}) + +writeFileSync(out, rewriteYaml(source, pruneGenerated(next)), 'utf8') + +console.log('生成的策略组：') +console.log(JSON.stringify(next['proxy-groups'], null, 2)) +console.log('\n生成的订阅副本（只看结构，url 不回显）：') +for (const [name, entry] of Object.entries(next['proxy-providers'] as ConfigObject)) { + if (!name.startsWith('patchbay:')) continue + const { url, ...rest } = entry as ConfigObject + console.log(name, JSON.stringify({ ...rest, url: '<同源订阅>' })) +} diff --git a/scripts/verify-pin.ts b/scripts/verify-pin.ts deleted file mode 100644 index 3ce5ade..0000000 --- a/scripts/verify-pin.ts +++ /dev/null @@ -1,36 +0,0 @@ -/** - * 验证「把入站固定到某条订阅线路」生成的配置内核真的接受。 - * - * 这个功能会往用户的配置里塞一个自动生成的策略组，光靠单元测试只能证明字符串拼对了， - * 证明不了内核认。所以这里走一遍真实的写回路径，再交给 mihomo -t 校验。 - * - * 用法：bun run scripts/verify-pin.ts <源配置> <输出路径> <线路名> - */ -import { readFileSync, writeFileSync } from 'node:fs' -import { openDocument } from '../vendor/config-editor/index.ts' -import type { ConfigObject } from '../vendor/config-editor/index.ts' -import { rewriteYaml } from '../server/config-store.ts' -import { generatedGroupName, makeFilterGroup, pruneGeneratedGroups } from '../shared/filter-groups.ts' - -const [src, out, line] = process.argv.slice(2) -if (!src || !out || !line) { - console.error('用法：bun run scripts/verify-pin.ts <源配置> <输出路径> <线路名>') - process.exit(1) -} - -const source = readFileSync(src, 'utf8') -const data = JSON.parse(JSON.stringify(openDocument(source).data)) as ConfigObject - -// 模拟界面上的两个动作：新增一路入站，把它固定到某条订阅线路 -data.listeners = [{ name: '容器A', type: 'mixed', port: 17895 }] -const group = makeFilterGroup(line, 'subs') -if (!group) { - console.error(`${line} 的名字里含反引号，无法生成筛选条件`) - process.exit(1) -} -data['proxy-groups'] = [...(data['proxy-groups'] as ConfigObject[]), group] -;(data.listeners as ConfigObject[])[0]!.proxy = generatedGroupName(line) - -writeFileSync(out, rewriteYaml(source, pruneGeneratedGroups(data)), 'utf8') -console.log('生成的组：') -console.log(JSON.stringify(group, null, 2)) diff --git a/server/config-store.ts b/server/config-store.ts index a19ad82..c35a8bd 100644 --- a/server/config-store.ts +++ b/server/config-store.ts @@ -117,6 +117,16 @@ export async function applyConfig( } } + // 落盘链路有五步各自可能变慢（校验要起一个内核进程、重载要等内核跑完、备份和写盘是磁盘 + // IO）。出问题时不靠猜，日志里直接给出每步耗时。 + const clock = { start: Date.now(), mark: Date.now() } + const lap = (stage: string) => { + const now = Date.now() + const ms = now - clock.mark + clock.mark = now + return `${stage} ${String(ms)}ms` + } + const nextYaml = rewriteYaml(current.yaml, nextData) // 内容没变就不要走后面那一串——不必要的备份和重载只会制造噪音。 @@ -138,9 +148,11 @@ export async function applyConfig( // 先写到临时文件交给内核校验，别碰真文件。 const tempPath = join(dirname(env.configPath), `.patchbay-check-${String(Date.now())}.yaml`) + let checkTiming = '' try { await writeFile(tempPath, nextYaml, 'utf8') const checked = await validateConfigFile(env, tempPath) + checkTiming = lap('内核校验') if (!checked.ok) { return { ok: false, @@ -156,6 +168,7 @@ export async function applyConfig( // 校验过了才动真文件。备份放在写入之前。 const backupPath = await createBackup(env) + const backupTiming = lap('备份') try { await writeFile(env.configPath, nextYaml, 'utf8') } catch (error) { @@ -168,7 +181,9 @@ export async function applyConfig( } } + const writeTiming = lap('写盘') const reloaded = await reloadConfig(env, env.configPath) + const reloadTiming = lap('重载') if (!reloaded.ok) { // 文件已经写进去了但内核没接受。把文件还原，再让内核载回原样， // 避免留下「文件是新的、内核跑的是旧的」这种最难排查的状态。 @@ -192,6 +207,9 @@ export async function applyConfig( } await pruneBackups(env) + console.log( + `[apply] 共 ${String(Date.now() - clock.start)}ms（${checkTiming}，${backupTiming}，${writeTiming}，${reloadTiming}）`, + ) return { ok: true, snapshot: await readConfig(env), diff --git a/server/index.ts b/server/index.ts index 0525023..d3f6cc6 100644 --- a/server/index.ts +++ b/server/index.ts @@ -8,7 +8,7 @@ import { readEnv } from './env.ts' import { resolveToken } from './auth.ts' import { createRouter } from './routes.ts' import { readConfig } from './config-store.ts' -import { kernelVersion } from './kernel.ts' +import { kernelVersion, warmUpKernelBinary } from './kernel.ts' const env = readEnv() const { token, source } = await resolveToken(env) @@ -29,6 +29,8 @@ try { process.exit(1) } +warmUpKernelBinary(env) + const kernel = await kernelVersion(env) console.log( kernel.online diff --git a/server/kernel.ts b/server/kernel.ts index 43b11e4..0a04c58 100644 --- a/server/kernel.ts +++ b/server/kernel.ts @@ -50,6 +50,24 @@ export async function validateConfigFile( } } +/** + * 启动时先把内核二进制跑一次，什么都不做。 + * + * `mihomo -t` 的第一次调用要 4 秒，之后 55 毫秒（在目标机器那种规格上实测差距只会更大）。 + * 差的是把这个几十兆的可执行文件读进系统文件缓存的时间，跟配置内容无关。不预热的话， + * 这 4 秒会落在用户按下的第一次保存上，而那正是他最容易以为「这个工具很慢」的时刻。 + * + * 失败不用管：内核二进制不可用这件事，第一次真正校验时会带着完整错误信息报出来。 + */ +export function warmUpKernelBinary(env: Env): void { + try { + const proc = Bun.spawn([env.mihomoBin, '-v'], { stdout: 'ignore', stderr: 'ignore' }) + void proc.exited + } catch { + // 同上 + } +} + /** 带上认证头访问管理接口。 */ async function callApi(env: Env, path: string, init?: RequestInit): Promise { return fetch(`${env.mihomoApi}${path}`, { diff --git a/shared/filter-groups.test.ts b/shared/filter-groups.test.ts deleted file mode 100644 index 572d27c..0000000 --- a/shared/filter-groups.test.ts +++ /dev/null @@ -1,110 +0,0 @@ -import { describe, expect, it } from 'bun:test' -import { - generatedGroupName, - isGeneratedGroup, - lineFilter, - makeFilterGroup, - pinnedLineOf, - pruneGeneratedGroups, -} from './filter-groups.ts' -import type { ConfigObject } from '../vendor/config-editor/index.ts' - -const LINE = '[vless]Gomami.SIN Secret' - -describe('筛选条件', () => { - it('转义正则元字符', () => { - // 线路名里的 [ ] . 不转义会当成正则语法，匹配到别的线路上去 - expect(lineFilter(LINE)).toBe('^\\[vless\\]Gomami\\.SIN Secret$') - }) - - it('前后加锚点，避免匹配到名字更长的线路', () => { - // 内核的筛选是部分匹配：不加锚点时「香港01」会把「香港011」也捞进来 - expect(lineFilter('香港01')).toBe('^香港01$') - }) - - it('线路名含反引号时表达不了，返回空让调用方说明原因', () => { - // 反引号在内核里是多个筛选条件的分隔符，塞进一条正则会被切成两半 - expect(lineFilter('怪`名字')).toBeNull() - }) - - it('转义后的正则确实只匹配它自己', () => { - const re = new RegExp(lineFilter(LINE)!) - expect(re.test(LINE)).toBe(true) - expect(re.test('[vless]GomamiXSIN Secret')).toBe(false) - expect(re.test(`${LINE} 备用`)).toBe(false) - }) -}) - -describe('生成的组', () => { - it('名字带前缀，这是识别它的唯一可靠标记', () => { - // 注释靠不住——被碰到的段落重写时会丢，见决策记录 0002 - const name = generatedGroupName(LINE) - expect(isGeneratedGroup(name)).toBe(true) - expect(pinnedLineOf(name)).toBe(LINE) - }) - - it('用户自己建的组不会被认成生成的', () => { - expect(isGeneratedGroup('PROXY')).toBe(false) - expect(pinnedLineOf('PROXY')).toBeNull() - }) - - it('组里只有那一条线路，类型是手动选', () => { - expect(makeFilterGroup(LINE, 'subs')).toEqual({ - name: `patchbay:${LINE}`, - type: 'select', - use: ['subs'], - filter: '^\\[vless\\]Gomami\\.SIN Secret$', - }) - }) - - it('表达不了的线路名不生成组', () => { - expect(makeFilterGroup('怪`名字', 'subs')).toBeNull() - }) -}) - -describe('清理没人用的生成组', () => { - const generated = (line: string) => ({ name: generatedGroupName(line), type: 'select' }) - - it('入站还指着它就留着', () => { - const data: ConfigObject = { - listeners: [{ name: 'A', type: 'mixed', port: 1, proxy: generatedGroupName(LINE) }], - 'proxy-groups': [generated(LINE)], - } - expect(pruneGeneratedGroups(data)['proxy-groups']).toHaveLength(1) - }) - - it('没人再指它就删掉', () => { - const data: ConfigObject = { - listeners: [{ name: 'A', type: 'mixed', port: 1 }], - 'proxy-groups': [generated(LINE)], - } - // 不清理的话，改几次出站文件里就攒下一堆用户从没主动建过的组 - expect(pruneGeneratedGroups(data)['proxy-groups']).toBeUndefined() - }) - - it('被别的策略组当成员引用也算在用', () => { - const data: ConfigObject = { - 'proxy-groups': [generated(LINE), { name: 'PROXY', proxies: [generatedGroupName(LINE)] }], - } - expect(pruneGeneratedGroups(data)['proxy-groups']).toHaveLength(2) - }) - - it('被规则引用也算在用', () => { - const data: ConfigObject = { - 'proxy-groups': [generated(LINE)], - rules: [`MATCH,${generatedGroupName(LINE)}`], - } - expect(pruneGeneratedGroups(data)['proxy-groups']).toHaveLength(1) - }) - - it('用户自己建的组一律不碰，哪怕真的没人引用', () => { - const data: ConfigObject = { 'proxy-groups': [{ name: '我建的组', type: 'select' }] } - expect(pruneGeneratedGroups(data)['proxy-groups']).toHaveLength(1) - }) - - it('没有可删的时候原样返回，不制造无谓的改动', () => { - // 返回同一个对象，落盘链路才看得出「内容没变」而跳过备份和重载 - const data: ConfigObject = { 'proxy-groups': [{ name: 'PROXY' }] } - expect(pruneGeneratedGroups(data)).toBe(data) - }) -}) diff --git a/shared/filter-groups.ts b/shared/filter-groups.ts deleted file mode 100644 index 9a71287..0000000 --- a/shared/filter-groups.ts +++ /dev/null @@ -1,118 +0,0 @@ -/** - * 把一路入站固定到某一条订阅线路。 - * - * 内核不允许直接这么写：入站的 `proxy:` 只认全局名字表里的名字，而订阅线路不在表上 - * （见决策记录 0005）。绕法是给那条线路单独建一个只装它的策略组，入站指向这个组。 - * - * 这些组是 Patchbay 自己造的，用户不该看到也不该管。名字带前缀是唯一可靠的标记—— - * 注释靠不住，被碰到的段落重写时会丢。 - */ -import type { ConfigObject } from '../vendor/config-editor/index.ts' - -/** 自动生成的筛选组的名字前缀。改它会让已有配置里的组失去标记，别改。 */ -export const GENERATED_PREFIX = 'patchbay:' - -export function isGeneratedGroup(name: string): boolean { - return name.startsWith(GENERATED_PREFIX) -} - -/** 固定到某条线路时，生成的组叫什么。名字里带上线路名，翻文件时一眼看得懂。 */ -export function generatedGroupName(line: string): string { - return `${GENERATED_PREFIX}${line}` -} - -/** 这个组固定的是哪条线路。不是生成的组返回 null。 */ -export function pinnedLineOf(groupName: string): string | null { - return isGeneratedGroup(groupName) ? groupName.slice(GENERATED_PREFIX.length) : null -} - -/** - * 出站在界面上怎么念。 - * - * 生成的组显示成它固定的那条线路——用户从没建过这个组，让他在界面上读到 - * `patchbay:[vless]Gomami` 只会莫名其妙。 - */ -export function displayOutboundName(name: string): string { - return pinnedLineOf(name) ?? name -} - -/** - * 把线路名转成只匹配它自己的筛选条件。 - * - * 两件事必须做对： - * 转义正则元字符——线路名形如 `[vmess]DMIT.LAX.Pro.MTYQ`，`[`、`]`、`.` 不转义会匹配错 - * 前后加锚点——内核的筛选是部分匹配，不加锚点时 `香港01` 会把 `香港011` 也匹配进来 - * - * 反引号在内核里是多个筛选条件的分隔符（adapter/outboundgroup/groupbase.go:72-76）， - * 线路名里含它就没法用一条正则表达，这种情况返回 null，调用方据此告诉用户做不到。 - */ -export function lineFilter(line: string): string | null { - if (line.includes('`')) return null - const escaped = line.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') - return `^${escaped}$` -} - -/** - * 造一个只装指定线路的策略组。 - * - * 用 `select` 而不是 `url-test`：组里只有一条线路，没什么可测的，而 `select` 的语义 - * 就是「用这一个」。 - */ -export function makeFilterGroup(line: string, provider: string): ConfigObject | null { - const filter = lineFilter(line) - if (filter === null) return null - return { - name: generatedGroupName(line), - type: 'select', - use: [provider], - filter, - } -} - -/** 配置里所有指向某个名字的位置。用来判断一个生成的组还有没有人在用。 */ -function referencesTo(data: ConfigObject, name: string): number { - let count = 0 - - for (const entry of Array.isArray(data.listeners) ? data.listeners : []) { - if (typeof entry === 'object' && entry !== null) { - if ((entry as Record).proxy === name) count += 1 - } - } - - for (const group of Array.isArray(data['proxy-groups']) ? data['proxy-groups'] : []) { - if (typeof group !== 'object' || group === null) continue - const members = (group as Record).proxies - if (Array.isArray(members) && members.includes(name)) count += 1 - } - - for (const rule of Array.isArray(data.rules) ? data.rules : []) { - // 规则的目标是逗号分隔的最后一段之前那个位置，形如 MATCH,目标 或 DOMAIN,x,目标 - if (typeof rule === 'string' && rule.split(',').some((part) => part.trim() === name)) count += 1 - } - - return count -} - -/** - * 删掉没人再引用的生成组。 - * - * 每次改完配置都跑一遍。不清理的话，改几次出站文件里就攒下一堆没用的组，而用户 - * 并不知道它们是干嘛的——他从来没主动建过它们。 - * - * 只动带前缀的组，用户自己建的一律不碰，哪怕它确实没人引用。 - */ -export function pruneGeneratedGroups(data: ConfigObject): ConfigObject { - const groups = Array.isArray(data['proxy-groups']) ? data['proxy-groups'] : [] - const kept = groups.filter((group) => { - if (typeof group !== 'object' || group === null) return true - const name = (group as Record).name - if (typeof name !== 'string' || !isGeneratedGroup(name)) return true - return referencesTo(data, name) > 0 - }) - - if (kept.length === groups.length) return data - const next = { ...data } - if (kept.length === 0) delete next['proxy-groups'] - else next['proxy-groups'] = kept - return next -} diff --git a/shared/inbound-groups.test.ts b/shared/inbound-groups.test.ts new file mode 100644 index 0000000..a7dc041 --- /dev/null +++ b/shared/inbound-groups.test.ts @@ -0,0 +1,321 @@ +import { describe, expect, it } from 'bun:test' +import { + applySetup, + chainGroupName, + chainProviderName, + panelGroups, + syncGenerated, + isGenerated, + linesMatching, + proxyGroupName, + pruneGenerated, + readSetup, +} from './inbound-groups.ts' +import type { OutboundSetup } from './inbound-groups.ts' +import { collectInbounds } from './inbounds.ts' +import type { ConfigObject } from '../vendor/config-editor/index.ts' + +const URL = 'http://127.0.0.1:3001/token/download/V2House' + +/** 一份最小但完整的配置：一个订阅、一路入站，还没被 Patchbay 接管过。 */ +function base(): ConfigObject { + return { + 'proxy-providers': { + subs: { type: 'http', url: URL, path: './providers/subs.yaml', interval: 86400 }, + }, + listeners: [{ name: 'test1', type: 'mixed', port: 7778 }], + } +} + +const plain: OutboundSetup = { proxy: { sources: ['subs'], filter: null }, chain: null } +const chained: OutboundSetup = { + proxy: { sources: ['subs'], filter: null }, + chain: { sources: ['subs'], filter: '(?i)DMIT' }, +} + +describe('名字', () => { + it('三种生成物都带前缀', () => { + // 前缀是识别它们的唯一可靠标记，注释会被配置改写引擎丢掉（决策记录 0002） + expect(isGenerated(proxyGroupName('test1'))).toBe(true) + expect(isGenerated(chainGroupName('test1'))).toBe(true) + expect(isGenerated(chainProviderName('test1', 'subs'))).toBe(true) + }) + + it('用户自己建的组不会被认成生成的', () => { + expect(isGenerated('PROXY')).toBe(false) + }) + + it('不同的「入站 × 来源」组合不撞名', () => { + // proxy-providers 是个映射，撞名会让其中一份被静默丢掉， + // 表现是链式代理挂到了别的入站上 + const names = new Set([ + chainProviderName('a', 'b c'), + chainProviderName('a b', 'c'), + chainProviderName('a', 'b'), + ]) + expect(names.size).toBe(3) + }) + + +}) + +describe('筛选预览', () => { + const lines = ['[vmess]DMIT.LAX.Pro.MTYQ', '[vless]Gomami.SIN Secret', '香港01', '香港011'] + + it('没写筛选条件就是全要', () => { + expect(linesMatching(null, lines)).toEqual(lines) + }) + + it('部分匹配，不自动加锚点', () => { + // 内核的筛选就是部分匹配，界面预览必须跟它一致，否则预览的数字骗人 + expect(linesMatching('香港01', lines)).toEqual(['香港01', '香港011']) + }) + + it('反引号切成多条正则，取并集', () => { + expect(linesMatching('DMIT`Gomami', lines)).toEqual([ + '[vmess]DMIT.LAX.Pro.MTYQ', + '[vless]Gomami.SIN Secret', + ]) + }) + + it('写法有误时返回空，让界面提示而不是显示一个错的数字', () => { + expect(linesMatching('[未闭合', lines)).toBeNull() + }) +}) + +describe('一路入站的三个组', () => { + it('SELECT 的成员是 DIRECT 加另外两个组，加上订阅', () => { + // 这三种挑法是所有 clash 配置里固定的那几种，让用户从零拼一遍没有意义 + const groups = applySetup(base(), 'test1', plain)['proxy-groups'] as ConfigObject[] + expect(groups[0]).toEqual({ + name: 'patchbay:test1', + type: 'select', + proxies: ['DIRECT', 'patchbay:test1 AUTO', 'patchbay:test1 FALLBACK'], + use: ['subs'], + }) + }) + + it('AUTO 是 url-test，FALLBACK 是 fallback，都带测速地址', () => { + // 不写测速地址时内核会去借来源订阅的健康检查配置，那依赖订阅写了它，不能指望 + const groups = applySetup(base(), 'test1', plain)['proxy-groups'] as ConfigObject[] + expect(groups[1]).toEqual({ + name: 'patchbay:test1 AUTO', + type: 'url-test', + use: ['subs'], + url: 'https://www.gstatic.com/generate_204', + interval: 300, + }) + expect((groups[2] as ConfigObject).type).toBe('fallback') + }) + + it('tab 的顺序是 SELECT、AUTO、FALLBACK，只有 SELECT 能点', () => { + // 另外两个自己决定用哪条，手动指定会被它们自己撤销，见 outbound-chain.ts + const data = applySetup(base(), 'test1', plain) + const runtime = { + 'patchbay:test1': { type: 'Selector' }, + 'patchbay:test1 AUTO': { type: 'URLTest' }, + 'patchbay:test1 FALLBACK': { type: 'Fallback' }, + } + const inbound = collectInbounds(data)[0]! + const panel = panelGroups(data, runtime, inbound) + + expect(panel.shared).toBe(false) + expect(panel.groups.map((g) => g.label)).toEqual(['SELECT', 'AUTO', 'FALLBACK']) + expect(panel.groups.map((g) => g.pickable)).toEqual([true, false, false]) + expect(panel.groups[0]!.uses).toEqual(['subs']) + }) + + it('内核里还没有的组不出现在 tab 上', () => { + // 保存完到内核重载完之间会有这么一小段，画一个点不出东西的 tab 只会让人以为坏了 + const data = applySetup(base(), 'test1', plain) + const inbound = collectInbounds(data)[0]! + expect(panelGroups(data, {}, inbound).groups).toEqual([]) + }) + + it('没接管的入站落到它顺着规则表走到的那个手动选择组，并标为共用', () => { + const data: ConfigObject = { + ...base(), + rules: ['MATCH,PROXY'], + 'proxy-groups': [{ name: 'PROXY', type: 'select', use: ['subs'] }], + } + const runtime = { PROXY: { type: 'Selector', now: 'A', all: ['A'] } } + const panel = panelGroups(data, runtime, collectInbounds(data)[0]!) + + expect(panel.shared).toBe(true) + expect(panel.groups).toEqual([ + { name: 'PROXY', label: 'PROXY', uses: ['subs'], pickable: true }, + ]) + }) + + it('筛选条件三个组共用一份', () => { + const groups = applySetup(base(), 'test1', { + proxy: { sources: ['subs'], filter: '(?i)hk' }, + chain: null, + })['proxy-groups'] as ConfigObject[] + for (const g of groups) expect((g as ConfigObject).filter).toBe('(?i)hk') + }) +}) + +describe('重建成当前形状', () => { + it('旧形状的生成组会被补齐成三个', () => { + // 改过生成规则之后，早先建的那些停在旧形状上，界面按新形状去找就静默少一块 + const stale: ConfigObject = { + ...base(), + 'proxy-groups': [{ name: 'patchbay:test1', type: 'select', use: ['subs'] }], + listeners: [{ name: 'test1', type: 'mixed', port: 7778, proxy: 'patchbay:test1' }], + } + const fixed = syncGenerated(stale, collectInbounds(stale)) + const names = (fixed['proxy-groups'] as ConfigObject[]).map((g) => (g as ConfigObject).name) + + expect(names).toEqual(['patchbay:test1', 'patchbay:test1 AUTO', 'patchbay:test1 FALLBACK']) + }) + + it('没接管的入站不碰', () => { + const data = base() + expect(syncGenerated(data, collectInbounds(data))).toBe(data) + }) +}) + +describe('读取设置', () => { + it('没有代理组时返回空，表示这一路由别的方式决定去向', () => { + expect(readSetup(base(), 'test1')).toBeNull() + }) + + it('没开链式代理时，来源就是代理组的 use', () => { + const setup: OutboundSetup = { proxy: { sources: ['subs'], filter: '(?i)hk' }, chain: null } + expect(readSetup(applySetup(base(), 'test1', setup), 'test1')).toEqual(setup) + }) + + it('开了链式代理时，来源从副本的 url 还原', () => { + // 代理组的 use 这时指向副本，用户选的订阅只能靠 url 相同认回来 + const data = applySetup(base(), 'test1', chained) + expect(readSetup(data, 'test1')).toEqual(chained) + }) +}) + +describe('写回设置', () => { + it('开链式代理时建入口组，三个组一起改用副本', () => { + const groups = applySetup(base(), 'test1', chained)['proxy-groups'] as ConfigObject[] + const copyName = chainProviderName('test1', 'subs') + + // 只有副本挂着 dialer-proxy，自动测速和故障转移也得走副本，否则那两条路绕过了中转 + for (const g of groups.slice(0, 3)) expect((g as ConfigObject).use).toEqual([copyName]) + expect(groups[3]).toEqual({ + name: 'patchbay:test1 链式', + type: 'select', + use: ['subs'], + filter: '(?i)DMIT', + }) + }) + + it('副本读原订阅的缓存文件，自己不联网', () => { + // 副本要是自己去拉，订阅地址一不可达它就是空的，那一路入站的线路会全部消失， + // 表现是端口还在监听却一条线都没有 + const data = applySetup(base(), 'test1', chained) + const copy = (data['proxy-providers'] as ConfigObject)[ + chainProviderName('test1', 'subs') + ] as ConfigObject + + expect(copy.type).toBe('file') + expect(copy.path).toBe('./providers/subs.yaml') + expect(copy.url).toBeUndefined() + expect(copy.interval).toBeUndefined() + expect(copy.override).toEqual({ 'dialer-proxy': 'patchbay:test1 链式' }) + }) + + it('原订阅没写 path 时给它补一个，否则副本认不到该读哪个文件', () => { + // 内核会按 url 哈希自己生成缓存路径，那个路径 Patchbay 算不出来 + const data = base() + delete ((data['proxy-providers'] as ConfigObject).subs as ConfigObject).path + const next = applySetup(data, 'test1', chained) + const providers = next['proxy-providers'] as ConfigObject + + expect((providers.subs as ConfigObject).path).toBe('./providers/subs.yaml') + expect(readSetup(next, 'test1')).toEqual(chained) + }) + + it('源订阅原有的 override 保留，不被覆盖', () => { + const data = base() + ;((data['proxy-providers'] as ConfigObject).subs as ConfigObject).override = { udp: true } + const next = applySetup(data, 'test1', chained) + const copy = (next['proxy-providers'] as ConfigObject)[ + chainProviderName('test1', 'subs') + ] as ConfigObject + + expect(copy.override).toEqual({ udp: true, 'dialer-proxy': 'patchbay:test1 链式' }) + }) + + it('关掉链式代理时，入口组和副本一起消失', () => { + const off = applySetup(applySetup(base(), 'test1', chained), 'test1', plain) + const names = (off['proxy-groups'] as ConfigObject[]).map((g) => (g as ConfigObject).name) + + expect(names).not.toContain('patchbay:test1 链式') + expect(Object.keys(off['proxy-providers'] as ConfigObject)).toEqual(['subs']) + }) + + it('换来源时旧副本立刻消失', () => { + // 留着的话就是一份没人引用、却还在按 interval 定时联网的订阅 + const data = base() + const providers = data['proxy-providers'] as ConfigObject + providers.other = { type: 'http', url: 'http://other.example/x', path: './providers/o.yaml' } + + const first = applySetup(data, 'test1', chained) + const second = applySetup(first, 'test1', { + proxy: { sources: ['other'], filter: null }, + chain: { sources: ['subs'], filter: null }, + }) + + const names = Object.keys(second['proxy-providers'] as ConfigObject) + expect(names).toContain(chainProviderName('test1', 'other')) + expect(names).not.toContain(chainProviderName('test1', 'subs')) + }) + + it('两路入站各自的副本互不干扰', () => { + const data = base() + ;(data.listeners as ConfigObject[]).push({ name: 'test2', type: 'mixed', port: 7779 }) + + const next = applySetup(applySetup(data, 'test1', chained), 'test2', chained) + const providers = next['proxy-providers'] as ConfigObject + + expect(Object.keys(providers)).toHaveLength(3) + expect(readSetup(next, 'test1')).toEqual(chained) + expect(readSetup(next, 'test2')).toEqual(chained) + }) +}) + +describe('清理', () => { + it('删掉入站之后，几个组和副本连锁消失', () => { + // 链式引用：SELECT 引 AUTO 和 FALLBACK，三者引副本，副本引入口组，要反复扫才清得干净 + const withInbound = applySetup(base(), 'test1', chained) + const removed: ConfigObject = { ...withInbound, listeners: [] } + + const cleaned = pruneGenerated(removed) + expect(cleaned['proxy-groups']).toBeUndefined() + expect(Object.keys(cleaned['proxy-providers'] as ConfigObject)).toEqual(['subs']) + }) + + it('入站还在就一个都不删', () => { + const data = applySetup(base(), 'test1', chained) + expect(pruneGenerated(data)).toBe(data) + }) + + it('用户自己建的组和订阅一律不碰，哪怕真的没人引用', () => { + const data: ConfigObject = { + 'proxy-groups': [{ name: '我建的组', type: 'select', use: ['subs'] }], + 'proxy-providers': { subs: { type: 'http', url: URL } }, + } + expect(pruneGenerated(data)).toBe(data) + }) + + it('没有可删的时候原样返回，不制造无谓的改动', () => { + // 返回同一个对象，落盘链路才看得出「内容没变」而跳过备份和重载 + const data: ConfigObject = { 'proxy-groups': [{ name: 'PROXY' }] } + expect(pruneGenerated(data)).toBe(data) + }) + + it('被规则引用的生成组不删，连它引用的两个组一起留下', () => { + const data = applySetup(base(), 'test1', plain) + const orphaned: ConfigObject = { ...data, listeners: [], rules: ['MATCH,patchbay:test1'] } + expect((pruneGenerated(orphaned)['proxy-groups'] as ConfigObject[]).length).toBe(3) + }) +}) diff --git a/shared/inbound-groups.ts b/shared/inbound-groups.ts new file mode 100644 index 0000000..b5bcaaf --- /dev/null +++ b/shared/inbound-groups.ts @@ -0,0 +1,501 @@ +/** + * 每一路入站的专属策略组。 + * + * 一路入站配三个组，入站的 `proxy:` 指向其中的 SELECT，换线是换那个组的当前选中， + * 不改配置文件（决策记录 0007）： + * SELECT 手动选。它的成员是 DIRECT、下面两个组，加上订阅里的线路 + * AUTO url-test，自动挑延迟最低的 + * FALLBACK fallback，按顺序挑第一个测得通的 + * 界面上这三个是并排的 tab。做成三个而不是让用户自己配，是因为它们就是所有 clash 配置 + * 里那三种固定的挑法，让人从零拼一遍没有意义。 + * + * 开了链式代理时再多一个入口组，以及若干份订阅声明的副本——`dialer-proxy` 写不到策略组 + * 上，只能挂在整个订阅上（内核源码 adapter/outboundgroup/parser.go:68-70）。 + * + * 配置里的东西属于谁全靠三条线索还原，不靠解析名字： + * 四个组 名字由入站名推出来 + * 订阅副本 override.dialer-proxy 指向哪一路的入口组 + * 副本的来源 url 和哪个用户订阅相同 + */ +import type { ConfigObject } from '../vendor/config-editor/index.ts' +import { resolveDestination } from './inbounds.ts' +import type { Inbound } from './inbounds.ts' +import { lastSwitchableGroup, resolveChain } from './outbound-chain.ts' +import type { RuntimeNode } from './outbound-chain.ts' + +/** + * Patchbay 自动创建的策略组和订阅的名字前缀。 + * + * 名字是识别它们的唯一可靠标记。注释靠不住——配置改写引擎重建整个被碰到的顶层段落， + * 段落内的注释会丢（决策记录 0002）。改这个前缀会让已有配置里的组失去标记，别改。 + */ +export const GENERATED_PREFIX = 'patchbay:' + +export function isGenerated(name: string): boolean { + return name.startsWith(GENERATED_PREFIX) +} + +/** 手动选的那个组。入站的 `proxy:` 指向它，它的当前选中决定这一路走哪。 */ +export function proxyGroupName(inbound: string): string { + return `${GENERATED_PREFIX}${inbound}` +} + +/** 自动测速组，作为 SELECT 的一个成员出现。 */ +export function autoGroupName(inbound: string): string { + return `${GENERATED_PREFIX}${inbound} AUTO` +} + +/** 故障转移组，同上。 */ +export function fallbackGroupName(inbound: string): string { + return `${GENERATED_PREFIX}${inbound} FALLBACK` +} + +/** 链式代理的入口组。订阅副本的 `dialer-proxy` 指向它。 */ +export function chainGroupName(inbound: string): string { + return `${GENERATED_PREFIX}${inbound} 链式` +} + +/** + * 一个出站在界面上叫什么。 + * + * 生成的组要去掉 `patchbay:` 前缀和入站名。用户从没建过这些组，让他在卡片和链条上读到 + * `patchbay:test1 FALLBACK` 只是噪音——那一屏本来就是这一路入站的详情，名字里再重复 + * 一遍入站名不增加任何信息。 + */ +export function displayName(name: string): string { + if (!isGenerated(name)) return name + const rest = name.slice(GENERATED_PREFIX.length) + for (const [suffix, label] of [ + [' AUTO', 'AUTO'], + [' FALLBACK', 'FALLBACK'], + [' 链式', '链式代理'], + ] as const) { + if (rest.endsWith(suffix)) return label + } + return rest +} + +/** 这一路的三个组，按界面上的显示顺序。 */ +function ownGroups(inbound: string): Array<{ name: string; label: string }> { + return [ + { name: proxyGroupName(inbound), label: 'SELECT' }, + { name: autoGroupName(inbound), label: 'AUTO' }, + { name: fallbackGroupName(inbound), label: 'FALLBACK' }, + ] +} + +/** FNV-1a。只用来给名字和文件名去重，不是安全用途，所以不引哈希库，浏览器端也要能算。 */ +function shortHash(text: string): string { + let h = 0x811c9dc5 + for (let i = 0; i < text.length; i += 1) { + h ^= text.charCodeAt(i) + h = Math.imul(h, 0x01000193) >>> 0 + } + return h.toString(16).padStart(8, '0') +} + +const pairKey = (inbound: string, source: string) => `${inbound} ${source}` + +/** + * 「某一路入站 × 某个来源订阅」这个组合对应的订阅副本叫什么。 + * + * 名字里带哈希是因为 `proxy-providers` 是个映射，两个组合撞名会让其中一个被静默丢掉， + * 表现是链式代理挂到了别的入站上。带上入站名只是为了翻配置文件时读得懂。 + */ +export function chainProviderName(inbound: string, source: string): string { + return `${GENERATED_PREFIX}chain ${inbound} ${shortHash(pairKey(inbound, source))}` +} + +/** + * 一个订阅的缓存文件落在哪。 + * + * 内核把拉回来的内容写在这里（内核源码 component/resource/vehicle.go:42-47）。没写 + * `path:` 时它按 url 哈希自己生成一个（adapter/provider/parser.go:87），那个路径 Patchbay + * 算不出来，所以缺的时候补一个确定的进去。 + */ +export function providerCachePath(name: string): string { + const safe = name.replace(/[^\p{L}\p{N}_-]+/gu, '-').replace(/^-+|-+$/g, '') + return `./providers/${safe || shortHash(name)}.yaml` +} + +/** 一组线路从哪来、要哪些。三个组共用同一份，它们只是挑法不同。 */ +export interface GroupSpec { + /** 成员来自哪几个订阅，写进组的 `use:` */ + sources: string[] + /** 只要名字匹配这个正则的线路。null 表示全要 */ + filter: string | null +} + +/** 一路入站的出站设置。 */ +export interface OutboundSetup { + proxy: GroupSpec + /** 链式代理的入口。null 表示没开 */ + chain: GroupSpec | null +} + +function isPlainObject(value: unknown): value is ConfigObject { + return typeof value === 'object' && value !== null && !Array.isArray(value) +} + +function groupsOf(data: ConfigObject): ConfigObject[] { + return (Array.isArray(data['proxy-groups']) ? data['proxy-groups'] : []).filter(isPlainObject) +} + +function providersOf(data: ConfigObject): ConfigObject { + return isPlainObject(data['proxy-providers']) ? data['proxy-providers'] : {} +} + +function findGroup(data: ConfigObject, name: string): ConfigObject | null { + return groupsOf(data).find((g) => g.name === name) ?? null +} + +function stringList(value: unknown): string[] { + return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : [] +} + +function specOf(group: ConfigObject): GroupSpec { + return { + sources: stringList(group.use), + filter: typeof group.filter === 'string' && group.filter ? group.filter : null, + } +} + +/** 用户自己配的订阅，不含 Patchbay 生成的副本。界面上「来源」能选的就是这些。 */ +export function userProviders(data: ConfigObject): string[] { + return Object.keys(providersOf(data)).filter((name) => !isGenerated(name)) +} + +/** 某个策略组从哪几个订阅取成员。组不存在时返回 null。 */ +export function groupUses(data: ConfigObject, name: string): string[] | null { + const group = findGroup(data, name) + return group ? stringList(group.use) : null +} + +/** 这个订阅副本是哪一路入站的。不是副本、或者认不出归属时返回 null。 */ +function chainOwnerOf(provider: unknown): string | null { + if (!isPlainObject(provider)) return null + const override = provider.override + if (!isPlainObject(override)) return null + const target = override['dialer-proxy'] + if (typeof target !== 'string' || !isGenerated(target)) return null + const suffix = ' 链式' + if (!target.endsWith(suffix)) return null + return target.slice(GENERATED_PREFIX.length, target.length - suffix.length) +} + +/** 副本的来源订阅叫什么。靠读同一个缓存文件来认，因为名字不可靠解析。 */ +function sourceOfCopy(data: ConfigObject, copy: ConfigObject): string | null { + if (typeof copy.path !== 'string') return null + for (const [name, entry] of Object.entries(providersOf(data))) { + if (isGenerated(name) || !isPlainObject(entry)) continue + if (entry.path === copy.path) return name + } + return null +} + +/** + * 读出这一路入站当前的出站设置。 + * + * 返回 null 表示它还没在专属组模式下，可能是走规则表、直连，或者指向用户自己建的组。 + */ +export function readSetup(data: ConfigObject, inbound: string): OutboundSetup | null { + const proxyGroup = findGroup(data, proxyGroupName(inbound)) + if (!proxyGroup) return null + + const spec = specOf(proxyGroup) + const providers = providersOf(data) + const copies = spec.sources.filter((name) => chainOwnerOf(providers[name]) === inbound) + + if (copies.length === 0) return { proxy: spec, chain: null } + + const chainGroup = findGroup(data, chainGroupName(inbound)) + const sources = copies + .map((name) => sourceOfCopy(data, providers[name] as ConfigObject)) + .filter((name): name is string => name !== null) + + return { + proxy: { sources, filter: spec.filter }, + chain: chainGroup ? specOf(chainGroup) : { sources: [], filter: null }, + } +} + +function makeGroup( + name: string, + type: string, + use: string[], + filter: string | null, + members: string[] = [], +): ConfigObject { + const group: ConfigObject = { name, type } + if (members.length > 0) group.proxies = members + if (use.length > 0) group.use = use + if (filter) group.filter = filter + // url-test 和 fallback 要有测速地址才知道谁快谁通。不写的话内核会借用来源订阅自己的 + // 健康检查地址（adapter/outboundgroup/parser.go:139-148），但那依赖订阅写了它， + // 不能指望；写死一个和内核默认一致的更稳。 + if (type !== 'select') { + group.url = 'https://www.gstatic.com/generate_204' + group.interval = 300 + } + return group +} + +function upsert(list: ConfigObject[], entry: ConfigObject): ConfigObject[] { + const at = list.findIndex((item) => item.name === entry.name) + if (at < 0) return [...list, entry] + const next = [...list] + next[at] = entry + return next +} + +/** + * 照着一个用户订阅做出带 `dialer-proxy` 的那一份。 + * + * 副本是 `type: file`，读的正是原订阅那个缓存文件，自己不联网。这一点是硬性的：副本要是 + * 自己去拉，订阅地址一不可达它就是空的，而这一路入站的线路全部来自它，结果是端口还在 + * 监听却一条线都没有。派生自原订阅已经落盘的内容，原订阅有什么副本就有什么。 + * + * 内核对 file 类型的 provider 自带文件监视（component/resource/fetcher.go:212-228）， + * 原订阅刷新写盘之后副本自动跟着更新，不需要 Patchbay 做任何事。 + * + * `filter` 这些影响「这个订阅里有哪些线路」的字段照抄，`url` 和 `interval` 去掉， + * 它们只对 http 类型有意义。 + */ +function makeChainProvider(source: ConfigObject, inbound: string, cachePath: string): ConfigObject { + const override = isPlainObject(source.override) ? { ...source.override } : {} + override['dialer-proxy'] = chainGroupName(inbound) + const { url: _url, interval: _interval, ...rest } = source + return { ...rest, type: 'file', path: cachePath, override } +} + +/** + * 把一路入站的出站设置写回配置。 + * + * 开了链式代理时，三个组的成员都改从订阅副本里取，因为只有副本挂着 `dialer-proxy`。 + * 用户选的来源订阅仍然可以从副本的 `url` 还原出来，所以配置文件之外不需要另存状态。 + */ +export function applySetup(data: ConfigObject, inbound: string, setup: OutboundSetup): ConfigObject { + const next = { ...data } + const chained = setup.chain !== null + const providers = { ...providersOf(next) } + + // 先清掉这一路原有的副本，再按新的来源重建。改来源时旧的副本必须消失， + // 否则代理组不再引用它，它就成了一份没人用却还在定时拉取的订阅。 + for (const [name, entry] of Object.entries(providers)) { + if (chainOwnerOf(entry) === inbound) delete providers[name] + } + + const use: string[] = [] + if (chained) { + for (const sourceName of setup.proxy.sources) { + const source = providers[sourceName] + if (!isPlainObject(source)) continue + // 副本靠「读同一个缓存文件」认亲。原订阅没写 path 时内核按 url 哈希自己生成一个， + // 那个路径这边算不出来，所以先给原订阅补一个确定的。 + const cachePath = + typeof source.path === 'string' && source.path ? source.path : providerCachePath(sourceName) + providers[sourceName] = { ...source, path: cachePath } + const copyName = chainProviderName(inbound, sourceName) + providers[copyName] = makeChainProvider(providers[sourceName], inbound, cachePath) + use.push(copyName) + } + } else { + use.push(...setup.proxy.sources) + } + + const { filter } = setup.proxy + let groups = groupsOf(next) + groups = upsert( + groups, + makeGroup(proxyGroupName(inbound), 'select', use, filter, [ + 'DIRECT', + autoGroupName(inbound), + fallbackGroupName(inbound), + ]), + ) + groups = upsert(groups, makeGroup(autoGroupName(inbound), 'url-test', use, filter)) + groups = upsert(groups, makeGroup(fallbackGroupName(inbound), 'fallback', use, filter)) + + if (chained) { + groups = upsert( + groups, + makeGroup(chainGroupName(inbound), 'select', setup.chain!.sources, setup.chain!.filter), + ) + } else { + groups = groups.filter((g) => g.name !== chainGroupName(inbound)) + } + next['proxy-groups'] = groups + + if (Object.keys(providers).length === 0) delete next['proxy-providers'] + else next['proxy-providers'] = providers + + const listeners = (Array.isArray(next.listeners) ? next.listeners : []).map((entry) => + isPlainObject(entry) && entry.name === inbound + ? { ...entry, proxy: proxyGroupName(inbound) } + : entry, + ) + if (listeners.length > 0) next.listeners = listeners + + return next +} + +/** 配置里指向某个名字的地方有几处。用来判断生成的东西还有没有人在用。 */ +function referencesTo(data: ConfigObject, name: string): number { + let count = 0 + + for (const entry of Array.isArray(data.listeners) ? data.listeners : []) { + if (isPlainObject(entry) && entry.proxy === name) count += 1 + } + + for (const group of groupsOf(data)) { + if (stringList(group.proxies).includes(name)) count += 1 + if (stringList(group.use).includes(name)) count += 1 + } + + for (const entry of Object.values(providersOf(data))) { + if (!isPlainObject(entry) || !isPlainObject(entry.override)) continue + if (entry.override['dialer-proxy'] === name) count += 1 + } + + for (const rule of Array.isArray(data.rules) ? data.rules : []) { + // 规则是逗号分隔的，目标出站是其中一段，形如 MATCH,目标 或 DOMAIN,x,目标 + if (typeof rule === 'string' && rule.split(',').some((part) => part.trim() === name)) count += 1 + } + + return count +} + +/** + * 删掉没人再引用的生成组和订阅副本。 + * + * 每次改完配置都跑一遍。删一路入站之后，它的几个组和几份副本会先后变成孤儿，不清理的话 + * 文件里就攒下一堆用户从没主动建过的东西，而副本还在按 interval 定时联网。 + * + * 要反复扫：AUTO 和 FALLBACK 被 SELECT 引用，入口组被副本引用，副本被那三个组引用， + * 所以删掉 SELECT 之后下一轮才轮到它们。只动带前缀的，用户自己建的一律不碰。 + */ +export function pruneGenerated(data: ConfigObject): ConfigObject { + const groups = Array.isArray(data['proxy-groups']) ? data['proxy-groups'] : [] + const keptGroups = groups.filter((group) => { + if (!isPlainObject(group)) return true + const name = group.name + if (typeof name !== 'string' || !isGenerated(name)) return true + return referencesTo(data, name) > 0 + }) + + const providers = providersOf(data) + const keptProviders = Object.entries(providers).filter( + ([name]) => !isGenerated(name) || referencesTo(data, name) > 0, + ) + const providersChanged = keptProviders.length !== Object.keys(providers).length + + if (keptGroups.length === groups.length && !providersChanged) return data + + const next = { ...data } + if (keptGroups.length === 0) delete next['proxy-groups'] + else next['proxy-groups'] = keptGroups + + if (providersChanged) { + if (keptProviders.length === 0) delete next['proxy-providers'] + else next['proxy-providers'] = Object.fromEntries(keptProviders) + } + + return pruneGenerated(next) +} + +/** + * 把所有已接管入站的生成组按当前的生成规则重建一遍。 + * + * 每次写配置前跑。生成的东西必须永远和生成它的代码一致，否则改过生成规则之后，早先建的 + * 那些就停在旧形状上，界面按新形状去找，找不到就静默少一块——tab 少了两个正是这么来的。 + * `applySetup` 幂等，形状没变时返回的内容一样，落盘链路会看出内容没变而跳过重载。 + */ +export function syncGenerated(data: ConfigObject, inbounds: Inbound[]): ConfigObject { + let next = data + for (const inbound of inbounds) { + const setup = readSetup(next, inbound.name) + const mode = inbound.outbound + if (!setup || mode.kind !== 'named' || mode.name !== proxyGroupName(inbound.name)) continue + next = applySetup(next, inbound.name, setup) + } + return next +} + +/** 面板上一个 tab 对应的策略组。 */ +export interface PanelGroup { + name: string + /** tab 上显示什么。自己的组显示挑法，共用的组显示它自己的名字 */ + label: string + /** 它从哪几个订阅取成员。测延迟要顺着来源找，见 web/runtime.ts 的 membersOf */ + uses: string[] + /** 能不能点成员换选中 */ + pickable: boolean +} + +/** + * 这一路入站的面板上能操作哪些策略组。 + * + * 只此一处回答这个问题。之前它散在四个地方（页面算一次能不能点、组件再算一次、 + * 共用与否又各算一次），加一种情况就要同时改四处，漏一处就是界面和实际操作对不上。 + * + * 两种情况：接管过的入站是它自己那三个组；没接管的（比如 `mixed-port`，配置顶层的端口 + * 字段没有 `proxy` 可写）落到它顺着规则表走到的那个手动选择组上，那个组是共用的。 + */ +export function panelGroups( + data: ConfigObject, + runtime: Record, + inbound: Inbound, +): { groups: PanelGroup[]; shared: boolean } { + const mode = inbound.outbound + const managed = mode.kind === 'named' && mode.name === proxyGroupName(inbound.name) + + if (managed) { + return { + shared: false, + groups: ownGroups(inbound.name) + // 保存完到内核重载完之间，组已经在配置里但运行时还没有，这时先不显示那个 tab + .filter((g) => runtime[g.name]) + .map((g) => ({ + ...g, + uses: groupUses(data, g.name) ?? [], + // 只有手动选的那个能点。另外两个自己决定用哪条，理由见 outbound-chain.ts + pickable: runtime[g.name]?.type === 'Selector', + })), + } + } + + const chain = resolveChain(runtime, resolveDestination(data, inbound)) + const fallback = lastSwitchableGroup(runtime, chain) + if (!fallback) return { groups: [], shared: false } + return { + shared: true, + groups: [ + { + name: fallback.group, + label: fallback.group, + uses: groupUses(data, fallback.group) ?? [], + pickable: true, + }, + ], + } +} + +/** + * 筛选条件会留下哪些线路。界面上用来在保存前当场告诉用户「匹配到几条」。 + * + * 照着内核的规则算（`adapter/outboundgroup/groupbase.go:72-76, 168-195`）：反引号把 + * 条件切成多条独立正则，取并集；每条都是部分匹配，不自动加锚点。 + * + * 内核用的是支持前后向查找的 .NET 风味引擎，浏览器只有 JS 的，所以复杂写法这里算出来的 + * 数字可能和内核不一致。写法有误时返回 null，界面据此提示而不是显示一个错的数字。 + */ +export function linesMatching(filter: string | null, lines: string[]): string[] | null { + if (!filter) return lines + let regexps: RegExp[] + try { + regexps = filter.split('`').map((part) => new RegExp(part)) + } catch { + return null + } + return lines.filter((line) => regexps.some((re) => re.test(line))) +} diff --git a/shared/outbound-chain.test.ts b/shared/outbound-chain.test.ts index cf61e6c..49325b9 100644 --- a/shared/outbound-chain.test.ts +++ b/shared/outbound-chain.test.ts @@ -1,5 +1,5 @@ import { describe, expect, it } from 'bun:test' -import { acceptsManualChoice, lastSwitchableGroup, resolveChain } from './outbound-chain.ts' +import { lastSwitchableGroup, resolveChain } from './outbound-chain.ts' import type { RuntimeNode } from './outbound-chain.ts' /** @@ -41,25 +41,11 @@ describe('解析流量最终走到哪条线', () => { }) }) -describe('哪种策略组接受手动选择', () => { - it('只有 Selector', () => { - expect(acceptsManualChoice('Selector')).toBe(true) - }) - - it('自动决定的那几种都不接受', () => { - // 内核里 URLTest 按延迟挑、Fallback 挑第一个可用、LoadBalance 分摊， - // 它们的选中结果是算出来的，点了会被算回去 - for (const type of ['URLTest', 'Fallback', 'LoadBalance', 'Relay']) { - expect(acceptsManualChoice(type)).toBe(false) - } - expect(acceptsManualChoice(undefined)).toBe(false) - }) -}) - describe('找出用户能换选中的那一层', () => { it('跳过自动决定的组，落在最后一个 Selector 上', () => { - // 链条是 PROXY(Selector) → AUTO(URLTest) → 线路。 - // 能点的是 PROXY，不是 AUTO——让人去点 URLTest 的成员，点完会被延迟测试算回去。 + // 链条是 PROXY(Selector) → AUTO(URLTest) → 线路。能点的是 PROXY 不是 AUTO： + // 内核对 URLTest 也接受手动指定，但那条线测不通时指定会临时让位， + // 和「选了就一直是它」不是一回事，摆成同一个控件会骗人。 const chain = resolveChain(runtime, 'PROXY') expect(lastSwitchableGroup(runtime, chain)).toEqual({ group: 'PROXY', @@ -78,7 +64,7 @@ describe('找出用户能换选中的那一层', () => { expect(lastSwitchableGroup(nested, resolveChain(nested, '外层'))?.group).toBe('内层') }) - it('整条链都是自动决定时返回空', () => { + it('整条链都不是 Selector 时返回空', () => { const auto: Record = { AUTO: { type: 'URLTest', now: '线路A', all: ['线路A'] }, 线路A: { type: 'Vmess' }, diff --git a/shared/outbound-chain.ts b/shared/outbound-chain.ts index 9059912..b8bbb05 100644 --- a/shared/outbound-chain.ts +++ b/shared/outbound-chain.ts @@ -19,18 +19,6 @@ export interface RuntimeNode { all?: string[] } -/** - * 这个类型的策略组接不接受手动选择。 - * - * 内核里只有 `Selector` 是「由人来选」的（内核源码 constant/adapters.go:240-248 列出 - * 全部类型）。`URLTest` 按延迟挑最快的、`Fallback` 挑第一个可用的、`LoadBalance` 在成员 - * 之间分摊——它们的选中结果是算出来的，界面上给一个能点的列表只会让人困惑：点完可能 - * 立刻被算回去。`Relay` 已经被内核移除。 - */ -export function acceptsManualChoice(type: string | undefined): boolean { - return type === 'Selector' -} - /** * 从落脚的出站一路跟着「当前选中」往下走。 * @@ -58,13 +46,16 @@ export interface SwitchableGroup { } /** - * 链条上最后一个能由人来选的策略组。 + * 链条上最后一个 `Selector` 组。这一路入站没被 Patchbay 接管时，界面上能点的就是它。 * * 取最后一个而不是第一个，是因为越靠近线路的那一层越接近「换线路」这个意图； * 前面的层换的是「走哪套策略」，那是另一回事。 * - * 跳过自动决定的组：让人去点一个 URLTest 组的成员，点完会被延迟测试算回去， - * 那不是选择，是错觉。 + * 只认 `Selector`，尽管内核对 `URLTest` 和 `Fallback` 也接受手动指定 + * （hub/route/proxies.go:85-90 检查的是 `SelectAble` 接口，不是类型）。原因是那两种的 + * 手动指定会自己失效：`URLTest` 选中的线路测不通时临时让位给最快的 + * （adapter/outboundgroup/urltest.go:103-116），`Fallback` 更狠，测不通一次就把手动指定 + * 永久清掉（fallback.go:117）。把它们和「选了就一直是它」摆成同一个控件会骗人。 */ export function lastSwitchableGroup( runtime: Record, @@ -73,7 +64,7 @@ export function lastSwitchableGroup( for (let i = chain.length - 1; i >= 0; i -= 1) { const name = chain[i]! const node = runtime[name] - if (!node?.all?.length || !acceptsManualChoice(node.type)) continue + if (!node?.all?.length || node.type !== 'Selector') continue return { group: name, members: node.all, now: node.now ?? '' } } return null diff --git a/web/App.vue b/web/App.vue index 130056b..4683305 100644 --- a/web/App.vue +++ b/web/App.vue @@ -146,7 +146,15 @@ const current = computed(() => NAV.find((n) => n.key === active.value)) } /* ── 侧栏 ───────────────────────────────────── */ +/* + * 钉在视口里。不加 sticky 的话它会被网格行撑到和主区一样高，页面一长， + * 导航就跟着滚出屏幕外，而它是全局导航，任何时候都该够得着。 + */ .side { + position: sticky; + top: 0; + align-self: start; + height: 100vh; display: flex; flex-direction: column; gap: var(--s-5); diff --git a/web/components/InboundList.vue b/web/components/InboundList.vue index 82480d2..17cbf71 100644 --- a/web/components/InboundList.vue +++ b/web/components/InboundList.vue @@ -5,11 +5,24 @@ * 只管显示和选中，不碰任何数据。 */ import { inboundTypeLabel, isUnsetOutbound, outboundLabel } from '@shared/inbounds.ts' -import { displayOutboundName } from '@shared/filter-groups.ts' +import { displayName, isGenerated } from '@shared/inbound-groups.ts' import type { Inbound } from '@shared/inbounds.ts' +import { runtime } from '../runtime' defineProps<{ inbounds: Inbound[] }>() const selected = defineModel('selected', { required: true }) + +/** + * 这一行右侧显示什么。 + * + * 指向 Patchbay 自动创建的代理组时显示那个组当前选中的线路，而不是组名——组名是 + * 「patchbay:」加入站名，和左边的名字列完全重复，等于一列没有信息。 + */ +function outboundOf(inbound: Inbound): string { + const mode = inbound.outbound + if (mode.kind !== 'named' || !isGenerated(mode.name)) return outboundLabel(mode) + return displayName(runtime.value[mode.name]?.now ?? '') || '未选择' +}