im0o
c3c0f56e56
用内核的 sub-rules 机制：listener 写 rule: 指向顶层 sub-rules 里的表 （listener/inbound/base.go:96，tunnel.go:713-721）。两个硬约束决定了 形态：proxy 优先级更高且完全短路规则匹配（tunnel.go:318-325），有附加 规则时 listener 只能写 rule；子规则表没命中时兜底是 DIRECT 而不是这一 路的出站（tunnel.go match 循环末尾），表底那条 MATCH,专属组 是承重的， 由 Patchbay 自动维护、界面上单独画不参与编辑。不变式：附加规则空 ⇔ proxy 直连专属组，非空 ⇔ rule 形态。 三处既有逻辑教会认 rule 形态：applySetup 不再无条件写 proxy（会把附加 规则静默短路掉）；referencesTo 扫 sub-rules 里的规则——表底 MATCH 是 rule 形态下专属组活着的唯一理由，不数它就会被当孤儿清掉；pruneGenerated 清理没有 listener 引用的生成表。panelGroups 和 syncGenerated 的「是否 由 Patchbay 接线」收敛成一个 managedWiring。 listener 的 rule 指向不存在的表时内核静默退回全局规则（getRules 的 else 分支），-t 和重载都不拦，自检里补上这条（vendor 本地改动，记入 ORIGIN.md）。界面：详情列新增附加规则区块，逐条增删改和排序复用 RuleForm，带内网直连预设；生成形状过了 mihomo -t 实测。
648 lines
26 KiB
TypeScript
648 lines
26 KiB
TypeScript
/**
|
||
* 每一路入站的专属策略组。
|
||
*
|
||
* 一路入站配三个组，入站的 `proxy:` 指向其中的 SELECT，换线是换那个组的当前选中，
|
||
* 不改配置文件（决策记录 0007）：
|
||
* SELECT 手动选。成员是 AUTO、FALLBACK、DIRECT 加订阅里的线路，顺序见 applySetup
|
||
* AUTO url-test，自动挑延迟最低的
|
||
* FALLBACK fallback，按顺序挑第一个测得通的
|
||
* 界面上这三个是并排的 tab。做成三个而不是让用户自己配，是因为它们就是所有 clash 配置
|
||
* 里那三种固定的挑法，让人从零拼一遍没有意义。
|
||
*
|
||
* 开了链式代理时再多一个入口组，以及若干份订阅声明的副本——`dialer-proxy` 写不到策略组
|
||
* 上，只能挂在整个订阅上（内核源码 adapter/outboundgroup/parser.go:68-70）。
|
||
*
|
||
* 配置里的东西属于谁全靠三条线索还原，不靠解析名字：
|
||
* 四个组 名字由入站名推出来
|
||
* 订阅副本 override.dialer-proxy 指向哪一路的入口组
|
||
* 副本的来源 path 和哪个用户订阅相同（读同一个缓存文件）
|
||
*/
|
||
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} 链式`
|
||
}
|
||
|
||
/** 这一路入站的附加规则表在顶层 `sub-rules:` 里的键名。listener 的 `rule:` 指向它。 */
|
||
export function subRuleName(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 },
|
||
}
|
||
}
|
||
|
||
/* ── 附加规则 ─────────────────────────────────────
|
||
*
|
||
* 挂在某一路入站上的分流规则（内核的 sub-rules 机制）：listener 写 `rule: <表名>`，
|
||
* 该入站的流量改查顶层 `sub-rules:` 里同名的表（tunnel.go:713-721）。两个硬约束：
|
||
* - `proxy:` 的优先级更高且完全短路规则匹配（tunnel.go:318-325），所以有附加规则时
|
||
* listener 只能写 rule 不写 proxy；
|
||
* - 子规则表没有命中时兜底是 DIRECT 而不是这一路的出站（tunnel.go match 循环末尾），
|
||
* 所以表底那条 `MATCH,专属组` 是承重的，Patchbay 始终自动补上，不交给用户维护。
|
||
* 于是不变式是：附加规则为空 ⇔ listener 用 proxy 直连专属组；非空 ⇔ listener 用 rule，
|
||
* 表底 MATCH 指回专属组。两种形态对「没被规则分走的流量」效果完全相同。
|
||
*/
|
||
|
||
function subRulesOf(data: ConfigObject): ConfigObject {
|
||
return isPlainObject(data['sub-rules']) ? data['sub-rules'] : {}
|
||
}
|
||
|
||
/** 这一路入站有没有 Patchbay 管理的附加规则表。 */
|
||
export function hasSubRules(data: ConfigObject, inbound: string): boolean {
|
||
return subRuleName(inbound) in subRulesOf(data)
|
||
}
|
||
|
||
/** 表底的兜底规则。它把没被分走的流量送回这一路自己的出站。 */
|
||
function terminalRule(inbound: string): string {
|
||
return `MATCH,${proxyGroupName(inbound)}`
|
||
}
|
||
|
||
/**
|
||
* 读出这一路的附加规则，不含表底的兜底 MATCH——那条是生成物，界面上单独画、
|
||
* 不参与编辑。手改过、兜底不在末尾的表原样全给，编辑保存时会重新规整。
|
||
*/
|
||
export function readSubRules(data: ConfigObject, inbound: string): string[] {
|
||
const entry = subRulesOf(data)[subRuleName(inbound)]
|
||
const rules = Array.isArray(entry)
|
||
? entry.filter((rule): rule is string => typeof rule === 'string')
|
||
: []
|
||
return rules.at(-1) === terminalRule(inbound) ? rules.slice(0, -1) : rules
|
||
}
|
||
|
||
/**
|
||
* 把这一路的附加规则写回配置。
|
||
*
|
||
* 空表恢复 proxy 直连形态（删表、删 rule、接回专属组）；非空补上兜底 MATCH、
|
||
* listener 换成 rule。listener 上用户手写的其它字段原样保留。
|
||
*/
|
||
export function applySubRules(data: ConfigObject, inbound: string, rules: string[]): ConfigObject {
|
||
const next = { ...data }
|
||
const name = subRuleName(inbound)
|
||
const tables = { ...subRulesOf(next) }
|
||
|
||
if (rules.length === 0) delete tables[name]
|
||
else tables[name] = [...rules, terminalRule(inbound)]
|
||
|
||
if (Object.keys(tables).length === 0) delete next['sub-rules']
|
||
else next['sub-rules'] = tables
|
||
|
||
const listeners = (Array.isArray(next.listeners) ? next.listeners : []).map((entry) => {
|
||
if (!isPlainObject(entry) || entry.name !== inbound) return entry
|
||
if (rules.length === 0) {
|
||
const { rule: _rule, ...rest } = entry
|
||
return { ...rest, proxy: proxyGroupName(inbound) }
|
||
}
|
||
const { proxy: _proxy, ...rest } = entry
|
||
return { ...rest, rule: name }
|
||
})
|
||
if (listeners.length > 0) next.listeners = listeners
|
||
|
||
return next
|
||
}
|
||
|
||
/**
|
||
* 这一路入站是否由 Patchbay 接线。两种形态：proxy 直指专属组，
|
||
* 或经附加规则表兜底到专属组。panelGroups 和 syncGenerated 共用这一个答案。
|
||
*/
|
||
export function managedWiring(data: ConfigObject, inbound: Inbound): boolean {
|
||
const mode = inbound.outbound
|
||
if (mode.kind === 'named' && mode.name === proxyGroupName(inbound.name)) return true
|
||
return inbound.ruleSet === subRuleName(inbound.name) && hasSubRules(data, inbound.name)
|
||
}
|
||
|
||
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`。
|
||
* 用户选的来源订阅仍然可以从副本的 `path` 还原出来，所以配置文件之外不需要另存状态。
|
||
*/
|
||
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)
|
||
// AUTO 排第一位：内核给没有选中记录的组默认用第一个成员，选中的线路被订阅刷新删掉时
|
||
// 也静默回退到第一个成员（内核源码 adapter/outboundgroup/selector.go:103-112）。这两种
|
||
// 情况都该落到自动测速上；排 DIRECT 就是静默直连，对按端口定向出站的场景是泄露。
|
||
groups = upsert(
|
||
groups,
|
||
makeGroup(proxyGroupName(inbound), 'select', use, filter, [
|
||
autoGroupName(inbound),
|
||
fallbackGroupName(inbound),
|
||
'DIRECT',
|
||
]),
|
||
)
|
||
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
|
||
|
||
// 有附加规则时 listener 走 rule 形态，proxy 会短路规则匹配、不能写；
|
||
// 表底的兜底 MATCH 已经指向专属组，接线效果一样
|
||
const viaSubRules = hasSubRules(next, inbound)
|
||
const listeners = (Array.isArray(next.listeners) ? next.listeners : []).map((entry) => {
|
||
if (!isPlainObject(entry) || entry.name !== inbound) return entry
|
||
if (viaSubRules) {
|
||
const { proxy: _proxy, ...rest } = entry
|
||
return { ...rest, rule: subRuleName(inbound) }
|
||
}
|
||
return { ...entry, proxy: proxyGroupName(inbound) }
|
||
})
|
||
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
|
||
}
|
||
|
||
// 附加规则表里的规则同样引用出站——表底的 MATCH,专属组 正是 rule 形态下
|
||
// 专属组活着的唯一理由，不数它专属组会被当孤儿清掉
|
||
for (const table of Object.values(subRulesOf(data))) {
|
||
if (!Array.isArray(table)) continue
|
||
for (const rule of table) {
|
||
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
|
||
|
||
// 生成的附加规则表活着的唯一理由是有 listener 的 rule 指着它。
|
||
// 入站被删后先清表，表里的 MATCH 引用消失，下一轮才轮到那几个组
|
||
const listenerRules = new Set(
|
||
(Array.isArray(data.listeners) ? data.listeners : [])
|
||
.filter(isPlainObject)
|
||
.map((entry) => entry.rule)
|
||
.filter((rule): rule is string => typeof rule === 'string'),
|
||
)
|
||
const tables = subRulesOf(data)
|
||
const keptTables = Object.entries(tables).filter(
|
||
([name]) => !isGenerated(name) || listenerRules.has(name),
|
||
)
|
||
const tablesChanged = keptTables.length !== Object.keys(tables).length
|
||
|
||
if (keptGroups.length === groups.length && !providersChanged && !tablesChanged) 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)
|
||
}
|
||
|
||
if (tablesChanged) {
|
||
if (keptTables.length === 0) delete next['sub-rules']
|
||
else next['sub-rules'] = Object.fromEntries(keptTables)
|
||
}
|
||
|
||
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)
|
||
if (!setup || !managedWiring(next, inbound)) 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<string, RuntimeNode>,
|
||
inbound: Inbound,
|
||
): { groups: PanelGroup[]; shared: boolean } {
|
||
const managed = managedWiring(data, inbound)
|
||
|
||
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,
|
||
},
|
||
],
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 还有哪些入站和这一路落在同一个共用组上。
|
||
*
|
||
* 「共用」这个提醒只在真有人共用时才成立：几路没接管的入站顺着规则表落到同一个手动
|
||
* 选择组时，在其中一路上换选中会连带改掉其它几路的去向。只有自己在用就没什么可提醒的。
|
||
*/
|
||
export function sharedPeers(
|
||
data: ConfigObject,
|
||
runtime: Record<string, RuntimeNode>,
|
||
inbounds: Inbound[],
|
||
inbound: Inbound,
|
||
): string[] {
|
||
const own = panelGroups(data, runtime, inbound)
|
||
if (!own.shared) return []
|
||
const group = own.groups[0]?.name
|
||
return inbounds
|
||
.filter((other) => other.id !== inbound.id)
|
||
.filter((other) => {
|
||
const panel = panelGroups(data, runtime, other)
|
||
return panel.shared && panel.groups[0]?.name === group
|
||
})
|
||
.map((other) => other.name)
|
||
}
|
||
|
||
/**
|
||
* 筛选条件会留下哪些线路。界面上用来在保存前当场告诉用户「匹配到几条」。
|
||
*
|
||
* 照着内核的规则算（`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)))
|
||
}
|