ai-fly 0.0.0 → 0.1.0

package/dist/common-BULbPtYn.mjs

@@ -0,0 +1,1295 @@
+import { n as UsageError } from "./errors-BGtxPkM7.mjs";
+import { i as randomZ32, n as resolveRelayUrls, t as loadConfig } from "./config-CO3WyW2H.mjs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { oc } from "@orpc/contract";
+z.enum([
+	"NOT_FOUND",
+	"CONFLICT",
+	"INVALID_INPUT",
+	"INVALID_STATE",
+	"UNAVAILABLE",
+	"INTERNAL"
+]);
+/** 与错误码绑定的稳定传输状态（skill-creator-v2 同款 ErrorMap 形状）。 */
+const RpcErrorDefinitions = {
+	NOT_FOUND: {
+		status: 404,
+		message: "The requested resource was not found."
+	},
+	CONFLICT: {
+		status: 409,
+		message: "The operation conflicts with current state."
+	},
+	INVALID_INPUT: {
+		status: 422,
+		message: "The input failed validation."
+	},
+	INVALID_STATE: {
+		status: 409,
+		message: "The operation is not valid in the current state."
+	},
+	UNAVAILABLE: {
+		status: 503,
+		message: "The required engine is not running."
+	},
+	INTERNAL: {
+		status: 500,
+		message: "Internal error."
+	}
+};
+const SERVICE_MATCH_SCHEMA = z.strictObject({
+	type: z.enum([
+		"exact",
+		"suffix",
+		"regex"
+	]),
+	value: z.string().min(1).max(2048)
+});
+const SERVICE_REWRITE_SCHEMA = z.strictObject({
+	hostHeader: z.string().min(1).max(2048).optional(),
+	pathPrefixStrip: z.string().min(1).max(2048).optional(),
+	pathPrefixAppend: z.string().min(1).max(2048).optional(),
+	headerSet: z.record(z.string().min(1).max(1024), z.string().max(8192)).optional(),
+	headerRemove: z.array(z.string().min(1).max(1024)).max(32).optional()
+});
+const ROUTE_FORM_SCHEMA = z.enum([
+	"openai-chat",
+	"openai-responses",
+	"anthropic"
+]);
+/** 路由匹配模式（M3-r7）：prefix = 前缀替换（默认）；pattern = URLPattern
+*  匹配 + RFC 6570 URI Template 拼装。 */
+const ROUTE_MODE_SCHEMA = z.enum(["prefix", "pattern"]);
+/**
+* 路径路由（M3-r7 定形）：**按声明顺序命中**（先声明先匹配）。
+* - prefix 模式（默认）：localPrefix（版本段粒度如 /v1）替换为 upstreamPrefix；
+* - pattern 模式：matchPattern（URLPattern pathname 表达式，`:name`/`{name}`
+*   组、`*` 通配）匹配请求路径，template（RFC 6570 URI Template）以捕获组
+*   + 查询参数拼装 upstream 路径。
+* forms 标注承载的 API 标准（AI 层；引擎转发与 forms 无关，可为空）。
+*/
+const SERVICE_ROUTE_SCHEMA = z.strictObject({
+	forms: z.array(ROUTE_FORM_SCHEMA).max(3),
+	mode: ROUTE_MODE_SCHEMA.optional(),
+	/** prefix 模式：本地端口前缀。缺省 = 首个 form 的规范前缀。 */
+	localPrefix: z.string().min(1).max(2048).optional(),
+	/** prefix 模式：替换本地前缀的 upstream 路径前缀（"" = upstream 根）。 */
+	upstreamPrefix: z.string().max(2048).optional(),
+	/** pattern 模式：URLPattern pathname 表达式。 */
+	matchPattern: z.string().min(1).max(2048).optional(),
+	/** pattern 模式：RFC 6570 URI Template（变量 = 捕获组 + 查询参数）。 */
+	template: z.string().min(1).max(2048).optional()
+});
+/** 各 API 标准在本地端口上的规范前缀（缺省 localPrefix 与 agent 配置基准）。 */
+const ROUTE_LOCAL_PREFIX = {
+	"openai-chat": "/v1",
+	"openai-responses": "/v1",
+	anthropic: "/anthropic"
+};
+/** 路由的生效本地前缀（缺省派生规范前缀）。 */
+function routeLocalPrefix(route) {
+	return route.localPrefix ?? ROUTE_LOCAL_PREFIX[route.forms[0] ?? "openai-chat"];
+}
+const SERVICE_SCHEMA = z.strictObject({
+	serviceId: z.string().min(1).max(128),
+	name: z.string().min(1).max(256),
+	match: z.array(SERVICE_MATCH_SCHEMA).max(64),
+	upstream: z.string().min(1).max(2048),
+	rewrite: SERVICE_REWRITE_SCHEMA.optional(),
+	routes: z.array(SERVICE_ROUTE_SCHEMA).max(3).optional(),
+	defaultPort: z.number().int().min(1).max(65535)
+});
+/** services.add 输入（defaultPort 缺省规则的校验在 store，同 CLI）。 */
+const SERVICE_INPUT_SCHEMA = z.strictObject({
+	name: z.string().min(1).max(256),
+	upstream: z.string().min(1).max(2048),
+	match: z.array(SERVICE_MATCH_SCHEMA).min(1).max(64),
+	defaultPort: z.number().int().min(1).max(65535).optional(),
+	rewrite: SERVICE_REWRITE_SCHEMA.optional(),
+	routes: z.array(SERVICE_ROUTE_SCHEMA).max(3).optional()
+});
+const GROUP_LIMITS_SCHEMA = z.strictObject({
+	maxConcurrency: z.number().int().min(1).optional(),
+	dailyRequests: z.number().int().min(1).optional()
+});
+const GROUP_SCHEMA = z.strictObject({
+	name: z.string().min(1).max(256),
+	serviceIds: z.array(z.string().min(1).max(128)).max(256),
+	limits: GROUP_LIMITS_SCHEMA.optional()
+});
+/** 密钥视图：keyId/分组/时间/状态；哈希与原文一律不进契约（原文仅 issue 时一次性返回）。 */
+const KEY_VIEW_SCHEMA = z.strictObject({
+	keyId: z.string().min(1).max(128),
+	group: z.string().min(1).max(256),
+	createdAt: z.number().int().min(0),
+	revokedAt: z.number().int().min(0).optional()
+});
+/** 使用方服务目录条目（AUTH_OK / import 视图；detail 为脱敏披露，$env 值显示 ●）。 */
+const SERVICE_ENTRY_SCHEMA = z.object({
+	serviceId: z.string(),
+	name: z.string(),
+	match: z.array(z.strictObject({
+		type: z.string(),
+		value: z.string()
+	})),
+	defaultPort: z.number().int(),
+	detail: z.object({
+		upstream: z.string(),
+		match: z.array(z.strictObject({
+			type: z.string(),
+			value: z.string()
+		})),
+		rewrite: z.object({
+			host: z.string().optional(),
+			prefix: z.string().optional(),
+			headerSet: z.array(z.strictObject({
+				name: z.string(),
+				value: z.string()
+			})).optional()
+		}).optional(),
+		/** 按标准路由披露（消费侧呈现各标准本地 base 与可用性判定）。 */
+		routes: z.array(z.strictObject({
+			forms: z.array(ROUTE_FORM_SCHEMA).max(3),
+			mode: ROUTE_MODE_SCHEMA.optional(),
+			localPrefix: z.string().optional(),
+			upstreamPrefix: z.string().optional(),
+			matchPattern: z.string().optional(),
+			template: z.string().optional()
+		})).max(4).optional()
+	}).optional()
+});
+/** 消费侧提供者连接状态（M1 六态 + 网关未运行时的 stopped）。 */
+const PROVIDER_STATE_SCHEMA = z.enum([
+	"stopped",
+	"not-connected",
+	"connected-unauthed",
+	"direct",
+	"relay",
+	"offline",
+	"key-all-invalid"
+]);
+const CONSUMER_PROVIDER_STATUS_SCHEMA = z.object({
+	endpointId: z.string(),
+	alias: z.string(),
+	state: PROVIDER_STATE_SCHEMA,
+	/** 该提供者授权目录内的服务（脱敏 detail）。 */
+	services: z.array(SERVICE_ENTRY_SCHEMA),
+	/** serviceId -> 本地端口（pinned 或 default；网关运行时为实际监听端口）。 */
+	ports: z.record(z.string(), z.number().int().min(0).max(65535)),
+	servedCount: z.number().int().min(0),
+	bufferOverflows: z.number().int().min(0),
+	lastError: z.string().optional()
+});
+const API_FORM_SCHEMA = z.enum([
+	"openai-completions",
+	"anthropic-messages",
+	"gemini-native"
+]);
+const PRESET_SCHEMA = z.strictObject({
+	id: z.string().min(1).max(128),
+	label: z.string().min(1).max(256),
+	apiForm: API_FORM_SCHEMA,
+	baseUrl: z.string().min(1).max(2048),
+	/** 图标源 id（models.dev logos 覆写；缺省取 id）。 */
+	iconId: z.string().min(1).max(128).optional(),
+	/** 惯用环境变量名（仅用于 $env 注入建议与文档；本地运行时模板无此字段）。 */
+	keyEnv: z.string().min(1).max(256).optional(),
+	/** 使用方本地端口建议（避开 <1024 特权段）。 */
+	defaultPort: z.number().int().min(1024).max(65535),
+	/** 官方域名集（exact/suffix 建议的生成源）。 */
+	matchDomains: z.array(z.string().min(1).max(256)).min(1).max(16),
+	/** 按标准路由（展开进服务；本地前缀由 form 派生）。 */
+	routes: z.array(SERVICE_ROUTE_SCHEMA).max(3).optional(),
+	notes: z.string().max(2048).optional(),
+	/** 出处（精选集为调研 URL；models.dev 长尾为 "models.dev"）。 */
+	source: z.string().min(1).max(512),
+	/** apiForm 未经厂商文档核实（models.dev npm 推断）时长尾条目置 true。 */
+	unverified: z.boolean().optional()
+});
+const SECRET_NAME_SCHEMA = z.string().min(1).max(128).regex(/^[a-z0-9][a-z0-9._-]*$/, "lowercase letters, digits, dot, dash, underscore");
+/** 密钥库清单条目（仅名称与开关——值由设计不跨 RPC）。 */
+const SECRET_ENTRY_SCHEMA = z.strictObject({
+	name: SECRET_NAME_SCHEMA,
+	createdAt: z.number().int().min(0),
+	updatedAt: z.number().int().min(0),
+	/** 注入时自动拼 "Bearer "（默认 true；Owner 2026-09-10：值默认是裸 key）。 */
+	bearerPrefix: z.boolean()
+});
+const WRITER_AGENT_SCHEMA = z.enum([
+	"codex",
+	"claude-code",
+	"cursor",
+	"cline",
+	"continue"
+]);
+/** 写手目标描述：serviceId（从消费方存储解析端口）或显式 port，二选一。 */
+const WRITER_TARGET_SCHEMA = z.strictObject({
+	serviceId: z.string().min(1).max(128).optional(),
+	port: z.number().int().min(1).max(65535).optional()
+}).refine((v) => v.serviceId !== void 0 !== (v.port !== void 0), { message: "exactly one of serviceId or port is required" });
+const WRITER_PREVIEW_SCHEMA = z.strictObject({
+	agent: WRITER_AGENT_SCHEMA,
+	target: WRITER_TARGET_SCHEMA
+});
+const WRITER_APPLY_SCHEMA = z.strictObject({
+	agent: WRITER_AGENT_SCHEMA,
+	target: WRITER_TARGET_SCHEMA,
+	/** preview 返回的确认令牌（sha256(diff)）：apply 只写入用户看过的那份 diff。 */
+	confirmToken: z.string().regex(/^[0-9a-f]{64}$/)
+});
+/** 按标准测试的结果（消费侧 wire 链路 / 提供方 route 直打共用形状）。 */
+const SERVICE_TEST_RESULT_SCHEMA = z.strictObject({
+	ok: z.boolean(),
+	latencyMs: z.number().int().min(0),
+	request: z.strictObject({
+		method: z.literal("POST"),
+		url: z.string(),
+		model: z.string().optional()
+	}),
+	modelSource: z.enum([
+		"explicit",
+		"models.dev",
+		"none"
+	]).optional(),
+	/** upstream 响应状态码（拿到响应即有；传输失败缺席）。 */
+	httpStatus: z.number().int().min(100).max(599).optional(),
+	error: z.string().optional(),
+	/** 响应正文摘录（成功=模型回复/错误体；截断）。 */
+	bodyExcerpt: z.string().optional()
+});
+const SETTINGS_SCHEMA = z.strictObject({
+	theme: z.enum([
+		"dark",
+		"light",
+		"system"
+	]),
+	/** false 时预设列表不含 models.dev 长尾（断网/隐私偏好）。 */
+	modelsDevEnabled: z.boolean(),
+	/** relay 入口列表（provider/consumer 共用；null = 未配置，走 SDK 默认）。 */
+	relayUrls: z.array(z.string().min(1).max(2048)).max(8).nullable()
+});
+const SHARE_CREATE_INPUT_SCHEMA = z.strictObject({
+	group: z.string().min(1).max(256),
+	/** TTL 毫秒（1s..30d；缺省 60min——范围校验复用 link.ts 常量语义）。 */
+	ttlMs: z.number().int().min(1e3).max(2592e6).optional()
+});
+const PRESET_APPLY_INPUT_SCHEMA = z.strictObject({
+	presetId: z.string().min(1).max(128),
+	/** 服务名（缺省取 preset.id）。 */
+	name: z.string().min(1).max(256).optional(),
+	/** 显式端口（缺省取 preset.defaultPort；上游特权端口时必填——store 校验兜底）。 */
+	port: z.number().int().min(1).max(65535).optional(),
+	/** 密钥库名（选中时 rewrite 写入 $secret:<name>，优先于 keyEnv）。 */
+	secretName: SECRET_NAME_SCHEMA.optional(),
+	/** 注入建议的 $env 变量名（缺省取 preset.keyEnv；无 keyEnv 且未显式给出则不注入）。 */
+	keyEnv: z.string().min(1).max(256).optional()
+});
+/** 提供方状态快照（引擎运行值 + 磁盘存储摘要，二合一）。 */
+const PROVIDER_STATUS_SCHEMA = z.object({
+	running: z.boolean(),
+	alias: z.string().optional(),
+	endpointId: z.string().optional(),
+	fabricIdHex: z.string().optional(),
+	relayMode: z.string().optional(),
+	relayUrls: z.array(z.string()),
+	sessionCount: z.number().int().min(0),
+	services: z.number().int().min(0),
+	groups: z.number().int().min(0),
+	activeKeys: z.number().int().min(0),
+	revokedKeys: z.number().int().min(0)
+});
+oc.errors(RpcErrorDefinitions).router({
+	provider: {
+		services: {
+			/** 全量服务配置（本机控制面：含 rewrite 原始 $env 引用，无脱敏需要）。 */
+			list: oc.input(z.object({})).output(z.object({ services: z.array(SERVICE_SCHEMA) })),
+			/** 按 name 精确定位单个服务。 */
+			get: oc.input(z.strictObject({ name: z.string().min(1).max(256) })).output(SERVICE_SCHEMA),
+			/** 新增服务（校验同 CLI：defaultPort 特权规则、match 编译检查、重名拒绝）。 */
+			add: oc.input(SERVICE_INPUT_SCHEMA).output(z.object({ service: SERVICE_SCHEMA })),
+			/** 删除服务（连带清出分组引用）。 */
+			remove: oc.input(z.strictObject({ name: z.string().min(1).max(256) })).output(z.object({ removed: z.literal(true) })),
+			/** 上游连通性测试（草稿或已存服务形状；provider-local、不落盘、不计限额）。 */
+			test: oc.input(z.strictObject({
+				upstream: z.string().min(1).max(2048),
+				apiForm: API_FORM_SCHEMA.optional(),
+				secretName: SECRET_NAME_SCHEMA.optional(),
+				model: z.string().min(1).max(256).optional()
+			})).output(z.strictObject({
+				ok: z.boolean(),
+				httpStatus: z.number().int().min(0).max(599).optional(),
+				latencyMs: z.number().int().min(0),
+				model: z.string(),
+				error: z.string().optional(),
+				/** 请求详情（发起过即有）：UI 呈现「发了什么」。 */
+				request: z.strictObject({
+					method: z.literal("POST"),
+					url: z.string(),
+					model: z.string()
+				}).optional(),
+				/** 模型选择来源（explicit / models.dev / upstream-probe）。 */
+				modelSource: z.enum([
+					"explicit",
+					"models.dev",
+					"upstream-probe"
+				]).optional()
+			})),
+			/**
+			* 提供方侧按标准路由测试（Owner 裁决 2026-09-11：与 connect ③ 同形态）：
+			* 最小 AI-API 请求 → 本地路由命中（prefix/pattern + 白名单）→ rewrite
+			* 注入（$secret/$env）→ 直打 upstream。request.url = 改写后的上游 URL。
+			*/
+			testRoute: oc.input(z.strictObject({
+				name: z.string().min(1).max(256),
+				form: ROUTE_FORM_SCHEMA,
+				model: z.string().min(1).max(256).optional(),
+				content: z.string().max(8192).optional(),
+				localPrefix: z.string().min(1).max(2048).optional()
+			})).output(SERVICE_TEST_RESULT_SCHEMA)
+		},
+		secrets: {
+			/** 密钥库清单（仅名称与时间戳；值由设计不跨 RPC）。 */
+			list: oc.input(z.object({})).output(z.object({ secrets: z.array(SECRET_ENTRY_SCHEMA) })),
+			/** 新增/覆写（value 为裸密钥——bearerPrefix 默认 true 时注入自动拼 "Bearer "）。 */
+			set: oc.input(z.strictObject({
+				name: SECRET_NAME_SCHEMA,
+				value: z.string().min(1).max(8192),
+				/** 关闭后按原样注入（非 Bearer 站点）。 */
+				bearerPrefix: z.boolean().optional()
+			})).output(z.object({ secret: SECRET_ENTRY_SCHEMA })),
+			/** 删除（不存在报 NOT_FOUND）。 */
+			remove: oc.input(z.strictObject({ name: SECRET_NAME_SCHEMA })).output(z.object({ removed: z.literal(true) }))
+		},
+		groups: {
+			/** 分组列表（含 limits 与 serviceIds）。 */
+			list: oc.input(z.object({})).output(z.object({ groups: z.array(GROUP_SCHEMA) })),
+			/** 新建分组（可带限额；未知服务名报错——store 校验）。 */
+			add: oc.input(z.strictObject({
+				name: z.string().min(1).max(256),
+				serviceNames: z.array(z.string().min(1).max(256)).max(256),
+				limits: GROUP_LIMITS_SCHEMA.optional()
+			})).output(z.object({ group: GROUP_SCHEMA })),
+			/** 整表替换分组服务引用。 */
+			setServices: oc.input(z.strictObject({
+				name: z.string().min(1).max(256),
+				serviceNames: z.array(z.string().min(1).max(256)).max(256)
+			})).output(z.object({ group: GROUP_SCHEMA })),
+			/** 更新分组限额（省略 limits = 清除为无限）。 */
+			setLimits: oc.input(z.strictObject({
+				name: z.string().min(1).max(256),
+				limits: GROUP_LIMITS_SCHEMA.optional()
+			})).output(z.object({ group: GROUP_SCHEMA })),
+			/** 删除分组（仍有未撤销密钥时 CONFLICT——先 revoke）。 */
+			remove: oc.input(z.strictObject({ name: z.string().min(1).max(256) })).output(z.object({ removed: z.literal(true) }))
+		},
+		keys: {
+			/** 签发（原文仅本次返回；此后只余哈希）。 */
+			issue: oc.input(z.strictObject({ group: z.string().min(1).max(256) })).output(z.object({
+				keyId: z.string(),
+				key: z.string(),
+				createdAt: z.number().int()
+			})),
+			/** 密钥清单（无哈希、无原文）。 */
+			list: oc.input(z.object({})).output(z.object({ keys: z.array(KEY_VIEW_SCHEMA) })),
+			/** 撤销（幂等）。 */
+			revoke: oc.input(z.strictObject({ keyId: z.string().min(1).max(128) })).output(z.object({ key: KEY_VIEW_SCHEMA }))
+		},
+		share: { 
+		/** 组合分享链接（需要 provider daemon 在运行以签发 fabric invite）。 */
+create: oc.input(SHARE_CREATE_INPUT_SCHEMA).output(z.object({
+			link: z.string().min(1),
+			keyId: z.string(),
+			warnings: z.array(z.string())
+		})) },
+		/** 提供方状态（引擎运行值 + 磁盘摘要）。 */
+		status: oc.input(z.object({})).output(PROVIDER_STATUS_SCHEMA),
+		daemon: {
+			/** 启动提供方 daemon（幂等；按数据目录现状装配）。 */
+			start: oc.input(z.object({})).output(z.object({ running: z.literal(true) })),
+			/** 停止提供方 daemon（幂等；在途请求按 M1 语义收敛）。 */
+			stop: oc.input(z.object({})).output(z.object({ running: z.literal(false) }))
+		}
+	},
+	consumer: {
+		import: {
+			/** 分享链接离线预览（不发起任何网络请求）。 */
+			preview: oc.input(z.strictObject({ link: z.string().min(1) })).output(z.object({
+				alias: z.string(),
+				endpointId: z.string(),
+				group: z.string(),
+				keyId: z.string(),
+				relayUrls: z.array(z.string()),
+				services: z.array(z.object({
+					serviceId: z.string(),
+					name: z.string(),
+					defaultPort: z.number().int(),
+					matchCount: z.number().int().min(0)
+				}))
+			})),
+			/** 兑换令牌并入环（老设备复用既有身份，不消耗令牌）。 */
+			apply: oc.input(z.strictObject({ link: z.string().min(1) })).output(z.object({
+				alias: z.string(),
+				endpointId: z.string(),
+				redeemed: z.boolean(),
+				keyAdded: z.boolean(),
+				services: z.array(z.object({
+					serviceId: z.string(),
+					name: z.string(),
+					defaultPort: z.number().int()
+				}))
+			}))
+		},
+		/** fabric 邀请令牌入网（裸 join，不带密钥）。 */
+		join: oc.input(z.strictObject({ invite: z.string().min(1) })).output(z.object({
+			alias: z.string(),
+			endpointId: z.string(),
+			alreadyJoined: z.boolean()
+		})),
+		key: { 
+		/** 裸密钥入环（keyId/group 由下次 AUTH_OK 回填）。 */
+add: oc.input(z.strictObject({
+			key: z.string().min(8).max(256),
+			providerRef: z.string().min(1).max(256)
+		})).output(z.object({
+			alias: z.string(),
+			added: z.boolean()
+		})) },
+		services: { 
+		/**
+		* 消费侧连通测试（M3-r8：③ 步 = test——选协议、选端点、单轮输入框发
+		* 真实 AI 请求）：对本机网关端口按 API 标准发最小请求，走完整 wire 链路；
+		* 凭据由提供方 rewrite 注入，本请求不携带 authorization。
+		* model 缺省时经 models.dev 缓存按 detail.upstream 选最便宜 chat 模型；
+		* content 为单轮提示词（缺省 "ping"）；localPrefix 显式指定端点路径
+		* （缺省取该标准路由规则的本地前缀）。
+		*/
+test: oc.input(z.strictObject({
+			serviceId: z.string().min(1).max(128),
+			form: ROUTE_FORM_SCHEMA,
+			model: z.string().min(1).max(256).optional(),
+			content: z.string().max(8192).optional(),
+			localPrefix: z.string().min(1).max(2048).optional()
+		})).output(SERVICE_TEST_RESULT_SCHEMA) },
+		ports: {
+			/** 全部已导入服务的本地端口清单（pinned/default 标注）。 */
+			list: oc.input(z.object({})).output(z.object({ providers: z.array(z.object({
+				alias: z.string(),
+				endpointId: z.string(),
+				services: z.array(z.object({
+					serviceId: z.string(),
+					name: z.string(),
+					port: z.number().int(),
+					defaultPort: z.number().int(),
+					pinned: z.boolean()
+				}))
+			})) })),
+			/** 持久化端口偏好（运行中网关下次启动生效）。 */
+			set: oc.input(z.strictObject({
+				serviceId: z.string().min(1).max(128),
+				port: z.number().int().min(1).max(65535)
+			})).output(z.object({
+				alias: z.string(),
+				serviceId: z.string(),
+				port: z.number().int()
+			}))
+		},
+		/** 消费侧状态（网关运行时为实时状态机；停止时为 stopped + 存储投影）。 */
+		status: oc.input(z.object({})).output(z.object({
+			gatewayRunning: z.boolean(),
+			providers: z.array(CONSUMER_PROVIDER_STATUS_SCHEMA)
+		})),
+		/** 整环删除（钥环 + fabric 身份目录）。 */
+		forget: oc.input(z.strictObject({ ref: z.string().min(1).max(256) })).output(z.object({
+			alias: z.string(),
+			removed: z.literal(true)
+		})),
+		gateway: {
+			/** 启动本地网关（幂等；物化既有目录监听）。 */
+			start: oc.input(z.object({})).output(z.object({ running: z.literal(true) })),
+			/** 停止本地网关（幂等）。 */
+			stop: oc.input(z.object({})).output(z.object({ running: z.literal(false) }))
+		}
+	},
+	presets: {
+		/** 预设列表（精选 + 可选 models.dev 长尾合流）。 */
+		list: oc.input(z.strictObject({ includeModelsDev: z.boolean().optional() })).output(z.object({
+			curated: z.array(PRESET_SCHEMA),
+			modelsDev: z.array(PRESET_SCHEMA),
+			/** 长尾不可用原因（断网/禁用/无缓存；精选集仍可用）。 */
+			modelsDevError: z.string().optional()
+		})),
+		/** 预设 → 提供方服务（展开 upstream/match/defaultPort/$env 注入；走 services.add 同一校验）。 */
+		applyAsService: oc.input(PRESET_APPLY_INPUT_SCHEMA).output(z.object({
+			service: SERVICE_SCHEMA,
+			/** $env 注入建议（导出提示；值需含完整 header 形态如 "Bearer <key>"）。 */
+			envHint: z.string().optional()
+		})),
+		/** 模型清单（models.dev 缓存；按价格升序，chat 优先，未知价尾排）。
+		*  presetId 二选一：已知预设；或 custom（自定义上游）实时探测 {upstream}/models。 */
+		models: oc.input(z.strictObject({
+			presetId: z.string().min(1).max(128).optional(),
+			upstream: z.string().min(1).max(2048).optional(),
+			secretName: SECRET_NAME_SCHEMA.optional()
+		}).refine((v) => v.presetId !== void 0 !== (v.upstream !== void 0), { message: "exactly one of presetId or upstream is required" })).output(z.strictObject({
+			models: z.array(z.strictObject({
+				id: z.string().min(1).max(256),
+				name: z.string().max(512).optional(),
+				/** input+output 合计 USD/Mtok；未知价省略。 */
+				pricePerMTok: z.number().min(0).optional(),
+				/** 价格已知（排序依据；未知价条目 false）。 */
+				priced: z.boolean(),
+				/** false = embed/image/tts 等非对话模型（id 启发式）。 */
+				chat: z.boolean()
+			})),
+			/** 清单不可用原因（无缓存且拉取失败等）。 */
+			error: z.string().optional()
+		}))
+	},
+	writers: {
+		/** 生成目标 agent 配置的统一 diff 与落盘路径（不写盘）。 */
+		preview: oc.input(WRITER_PREVIEW_SCHEMA).output(z.object({
+			agent: WRITER_AGENT_SCHEMA,
+			path: z.string().min(1),
+			/** 目标文件当前是否已存在（新建 vs 更新）。 */
+			exists: z.boolean(),
+			/** 解析后的本地端点（http://127.0.0.1:<port>）。 */
+			baseUrl: z.string(),
+			/** 统一 diff 文本（无上下文行数的完整 unified diff）。 */
+			diff: z.string(),
+			/** apply 必须原样带回（sha256(diff)）。 */
+			confirmToken: z.string().regex(/^[0-9a-f]{64}$/)
+		})),
+		/** 确认后原子写（confirmToken 不匹配即拒绝；保留其余配置字段）。 */
+		apply: oc.input(WRITER_APPLY_SCHEMA).output(z.object({
+			agent: WRITER_AGENT_SCHEMA,
+			path: z.string(),
+			written: z.literal(true)
+		}))
+	},
+	system: {
+		settings: {
+			/** 读取应用设置（主题/models.dev 开关/relay）。 */
+			get: oc.input(z.object({})).output(SETTINGS_SCHEMA),
+			/** 补丁式更新（仅提交的字段变更）。 */
+			set: oc.input(z.strictObject({
+				theme: z.enum([
+					"dark",
+					"light",
+					"system"
+				]).optional(),
+				modelsDevEnabled: z.boolean().optional(),
+				relayUrls: z.array(z.string().min(1).max(2048)).max(8).nullable().optional()
+			})).output(SETTINGS_SCHEMA)
+		},
+		/** 通知通道常量（前端 ws 订阅地址；与 web-server 实现保持同源）。 */
+		notifyChannels: oc.input(z.object({})).output(z.object({
+			rpcPath: z.literal("/ws/rpc"),
+			notifyPath: z.literal("/ws/notify")
+		}))
+	}
+});
+//#endregion
+//#region src/provider/match-pattern.ts
+var MatchPatternError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "MatchPatternError";
+	}
+};
+/** 花括号组 → 冒号组（兼容两种 URLPattern 文档写法）。 */
+function normalizeMatchPatternSyntax(raw) {
+	return raw.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, ":$1");
+}
+const compiled = /* @__PURE__ */ new Map();
+function compileMatchPattern(raw) {
+	const cached = compiled.get(raw);
+	if (cached !== void 0) return cached;
+	if (typeof URLPattern !== "function") throw new MatchPatternError("URLPattern is unavailable in this runtime");
+	const translated = normalizeMatchPatternSyntax(raw);
+	let pattern;
+	try {
+		pattern = new URLPattern({ pathname: translated });
+	} catch (err) {
+		throw new MatchPatternError(err.message || "invalid urlpattern");
+	}
+	compiled.set(raw, pattern);
+	return pattern;
+}
+/**
+* 匹配请求路径（含可选查询串）。返回捕获组（pathname groups）；未命中返回
+* null。exec 需要完整 URL——以 http://localhost 为基座构造。
+*/
+function matchRequestPath(pattern, pathname, search) {
+	const url = `http://localhost${pathname.startsWith("/") ? pathname : `/${pathname}`}${search === "" ? "" : `?${search}`}`;
+	const result = pattern.exec(url);
+	if (result === null) return null;
+	return { ...result.pathname.groups };
+}
+//#endregion
+//#region src/provider/uri-template.ts
+var UriTemplateError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "UriTemplateError";
+	}
+};
+const OPERATORS = {
+	"": {
+		first: "",
+		sep: ",",
+		named: false,
+		ifemp: "",
+		allowReserved: false
+	},
+	"+": {
+		first: "",
+		sep: ",",
+		named: false,
+		ifemp: "",
+		allowReserved: true
+	},
+	".": {
+		first: ".",
+		sep: ".",
+		named: false,
+		ifemp: "",
+		allowReserved: false
+	},
+	"/": {
+		first: "/",
+		sep: "/",
+		named: false,
+		ifemp: "",
+		allowReserved: false
+	},
+	";": {
+		first: ";",
+		sep: ";",
+		named: true,
+		ifemp: "",
+		allowReserved: false
+	},
+	"?": {
+		first: "?",
+		sep: "&",
+		named: true,
+		ifemp: "=",
+		allowReserved: false
+	},
+	"&": {
+		first: "&",
+		sep: "&",
+		named: true,
+		ifemp: "=",
+		allowReserved: false
+	},
+	"#": {
+		first: "#",
+		sep: ",",
+		named: false,
+		ifemp: "",
+		allowReserved: true
+	}
+};
+const UNRESERVED = /[A-Za-z0-9\-._~]/;
+const RESERVED = /[A-Za-z0-9\-._~:\/\?#\[\]@!\$&'()*+,;=]/;
+function encodeValue(value, allowReserved) {
+	let out = "";
+	for (const ch of value) if (UNRESERVED.test(ch) || allowReserved && RESERVED.test(ch)) out += ch;
+	else for (const byte of new TextEncoder().encode(ch)) out += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+	return out;
+}
+function parseExpression(expr) {
+	const opKey = /^[.+\/;?&#]/.test(expr) ? expr[0] : "";
+	const body = expr.slice(opKey.length);
+	const spec = OPERATORS[opKey];
+	const vars = [];
+	for (const raw of body.split(",")) {
+		const name = raw.replace(/:\d+$/, "").replace(/\*$/, "").trim();
+		if (name === "" || !/^[A-Za-z0-9_.%]+$/.test(name)) throw new UriTemplateError(`invalid variable name '${raw}' in expression '{${expr}}'`);
+		vars.push({ name });
+	}
+	if (vars.length === 0) throw new UriTemplateError(`empty expression '{${expr}}'`);
+	return {
+		op: spec,
+		vars
+	};
+}
+/** 校验模板（写入期 fail-fast 用）：花括号配对 + 全部表达式可解析。 */
+function validateUriTemplate(template) {
+	expandUriTemplate(template, {});
+}
+/** RFC 6570 子集扩展。 */
+function expandUriTemplate(template, vars) {
+	let out = "";
+	let i = 0;
+	while (i < template.length) {
+		const open = template.indexOf("{", i);
+		if (open < 0) {
+			out += template.slice(i);
+			break;
+		}
+		out += template.slice(i, open);
+		const close = template.indexOf("}", open);
+		if (close < 0) throw new UriTemplateError(`unbalanced '{' in template '${template}'`);
+		const { op, vars: specs } = parseExpression(template.slice(open + 1, close));
+		const parts = [];
+		let used = false;
+		for (const { name } of specs) {
+			const raw = vars[name];
+			if (raw === void 0 || raw === "") continue;
+			used = true;
+			const value = encodeValue(raw, op.allowReserved);
+			parts.push(op.named ? `${name}=${value}` : value);
+		}
+		if (used) out += op.first + parts.join(op.sep);
+		i = close + 1;
+	}
+	return out;
+}
+//#endregion
+//#region src/provider/store.ts
+const DIR_MODE = 448;
+const FILE_MODE = 384;
+/** 密钥哈希固定 salt（所有提供方实例一致；防直接彩虹表对照 sk-aifly- 空间）。 */
+const KEY_HASH_SALT = "aifly-provider-key-v1:";
+const KEY_MATERIAL_PREFIX = "sk-aifly-";
+/** 存储层错误（用户面 message 为英文 ASCII，直接透出 CLI）。 */
+var StoreError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "StoreError";
+		this.code = code;
+	}
+};
+const SERVICE_MATCH_STORE_SCHEMA = z.strictObject({
+	type: z.enum([
+		"exact",
+		"suffix",
+		"regex"
+	]),
+	value: z.string().min(1).max(2048)
+});
+const SERVICE_REWRITE_STORE_SCHEMA = z.strictObject({
+	hostHeader: z.string().min(1).max(2048).optional(),
+	pathPrefixStrip: z.string().min(1).max(2048).optional(),
+	pathPrefixAppend: z.string().min(1).max(2048).optional(),
+	headerSet: z.record(z.string().min(1).max(1024), z.string().max(8192)).optional(),
+	headerRemove: z.array(z.string().min(1).max(1024)).max(32).optional()
+});
+/** 路径路由（M3-r7）：按声明顺序命中的转发规则——prefix 模式（默认，
+*  localPrefix → upstreamPrefix）或 pattern 模式（matchPattern URLPattern
+*  + template RFC 6570）。forms 为 AI 层标注（可为空）。 */
+const SERVICE_ROUTE_STORE_SCHEMA = z.strictObject({
+	forms: z.array(z.enum([
+		"openai-chat",
+		"openai-responses",
+		"anthropic"
+	])).max(3),
+	mode: z.enum(["prefix", "pattern"]).optional(),
+	localPrefix: z.string().min(1).max(2048).optional(),
+	upstreamPrefix: z.string().max(2048).optional(),
+	matchPattern: z.string().min(1).max(2048).optional(),
+	template: z.string().min(1).max(2048).optional()
+});
+const SERVICE_STORE_SCHEMA = z.strictObject({
+	serviceId: z.string().min(1).max(128),
+	name: z.string().min(1).max(256),
+	match: z.array(SERVICE_MATCH_STORE_SCHEMA).max(64),
+	upstream: z.string().min(1).max(2048),
+	rewrite: SERVICE_REWRITE_STORE_SCHEMA.optional(),
+	routes: z.array(SERVICE_ROUTE_STORE_SCHEMA).max(3).optional(),
+	defaultPort: z.number().int().min(1).max(65535)
+});
+const GROUP_LIMITS_STORE_SCHEMA = z.strictObject({
+	maxConcurrency: z.number().int().min(1).optional(),
+	dailyRequests: z.number().int().min(1).optional()
+});
+const GROUP_STORE_SCHEMA = z.strictObject({
+	name: z.string().min(1).max(256),
+	serviceIds: z.array(z.string().min(1).max(128)).max(256),
+	limits: GROUP_LIMITS_STORE_SCHEMA.optional()
+});
+const KEY_STORE_SCHEMA = z.strictObject({
+	keyId: z.string().min(1).max(128),
+	group: z.string().min(1).max(256),
+	hash: z.string().regex(/^[0-9a-f]{64}$/, "key hash must be 64 hex chars"),
+	createdAt: z.number().int().min(0),
+	revokedAt: z.number().int().min(0).optional()
+});
+const STORE_FILE_SCHEMA = z.strictObject({
+	revision: z.number().int().min(0),
+	meta: z.strictObject({ alias: z.string().min(1).max(256).optional() }).optional(),
+	services: z.array(SERVICE_STORE_SCHEMA).max(1024),
+	groups: z.array(GROUP_STORE_SCHEMA).max(256),
+	keys: z.array(KEY_STORE_SCHEMA).max(1024)
+});
+function ensurePrivateDir(dir) {
+	mkdirSync(dir, {
+		recursive: true,
+		mode: DIR_MODE
+	});
+	try {
+		chmodSync(dir, DIR_MODE);
+	} catch {}
+}
+/** 原子写：同目录 tmp + rename（失败残留 tmp 不影响旧文件）。 */
+function atomicWriteFileSync(path, contents, mode = FILE_MODE) {
+	const tmp = `${path}.tmp-${randomBytes(4).toString("hex")}`;
+	writeFileSync(tmp, contents, { mode });
+	try {
+		chmodSync(tmp, mode);
+	} catch {}
+	renameSync(tmp, path);
+}
+function hashKeyMaterial(material) {
+	return createHash("sha256").update(KEY_HASH_SALT + material).digest("hex");
+}
+const PRIVILEGED_PORT_MAX = 1023;
+/** 解析并校验上游 URL：http/https、必须有主机名、禁 userinfo/query/fragment。 */
+function parseUpstreamUrl(upstream) {
+	let url;
+	try {
+		url = new URL(upstream);
+	} catch {
+		throw new StoreError("invalid", `error: invalid upstream URL: ${upstream}`);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new StoreError("invalid", "error: upstream URL scheme must be http or https");
+	if (url.username !== "" || url.password !== "") throw new StoreError("invalid", "error: upstream URL must not embed credentials (user:pass@)");
+	if (url.hostname === "") throw new StoreError("invalid", "error: upstream URL must have a hostname");
+	if (url.search !== "" || url.hash !== "") throw new StoreError("invalid", "error: upstream URL must not contain query or fragment");
+	return url;
+}
+/** 上游生效端口（显式或缺省scheme端口）。 */
+function upstreamEffectivePort(url) {
+	if (url.port !== "") return Number(url.port);
+	return url.protocol === "https:" ? 443 : 80;
+}
+var ProviderStore = class ProviderStore {
+	dataDir;
+	data;
+	constructor(dataDir, data) {
+		this.dataDir = dataDir;
+		this.data = data;
+	}
+	static filePath(dataDir) {
+		return join(dataDir, "services.json");
+	}
+	/** 打开（不存在则初始化空存储）；损坏/非法文件抛 StoreError(corrupt)。 */
+	static open(dataDir) {
+		ensurePrivateDir(dataDir);
+		const path = ProviderStore.filePath(dataDir);
+		if (!existsSync(path)) return new ProviderStore(dataDir, {
+			revision: 0,
+			services: [],
+			groups: [],
+			keys: []
+		});
+		let raw;
+		try {
+			raw = readFileSync(path, "utf8");
+		} catch (err) {
+			throw new StoreError("corrupt", `error: cannot read ${path}: ${err.message}`);
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			throw new StoreError("corrupt", `error: ${path} is not valid JSON (fix or remove it manually)`);
+		}
+		const result = STORE_FILE_SCHEMA.safeParse(parsed);
+		if (!result.success) throw new StoreError("corrupt", `error: ${path} failed validation: ${result.error.message}`);
+		return new ProviderStore(dataDir, result.data);
+	}
+	/** 当前文件 revision（watcher 判重入用）。 */
+	get revision() {
+		return this.data.revision;
+	}
+	listServices() {
+		return this.data.services.map((s) => ({ ...s }));
+	}
+	getService(serviceId) {
+		const found = this.data.services.find((s) => s.serviceId === serviceId);
+		return found === void 0 ? void 0 : { ...found };
+	}
+	getServiceByName(name) {
+		const found = this.data.services.find((s) => s.name === name);
+		return found === void 0 ? void 0 : { ...found };
+	}
+	addService(input) {
+		const name = input.name.trim();
+		if (name === "" || name.length > 256) throw new StoreError("invalid", "error: service name must be 1..256 chars");
+		if (this.data.services.some((s) => s.name === name)) throw new StoreError("duplicate", `error: service '${name}' already exists`);
+		if (input.match.length === 0) throw new StoreError("invalid", "error: service must declare at least one match rule");
+		if (input.match.length > 64) throw new StoreError("invalid", "error: service match rules exceed 64 entries");
+		for (const rule of input.match) if (rule.type === "regex") try {
+			new RegExp(rule.value);
+		} catch (err) {
+			throw new StoreError("invalid", `error: invalid regex '${rule.value}': ${err.message}`);
+		}
+		const upstreamUrl = parseUpstreamUrl(input.upstream);
+		let defaultPort;
+		if (input.defaultPort === void 0) {
+			const eff = upstreamEffectivePort(upstreamUrl);
+			if (eff <= PRIVILEGED_PORT_MAX) throw new StoreError("invalid", `error: upstream port ${eff} is privileged; declare an explicit consumer-side default port (--port <n>)`);
+			defaultPort = eff;
+		} else {
+			if (!Number.isInteger(input.defaultPort) || input.defaultPort < 1 || input.defaultPort > 65535) throw new StoreError("invalid", "error: default port must be an integer in 1..65535");
+			defaultPort = input.defaultPort;
+		}
+		const rewrite = input.rewrite === void 0 ? void 0 : normalizeRewrite(input.rewrite);
+		const routes = normalizeRoutes(input.routes);
+		let serviceId;
+		do
+			serviceId = randomZ32(8);
+		while (this.data.services.some((s) => s.serviceId === serviceId));
+		const service = {
+			serviceId,
+			name,
+			match: input.match.map((m) => ({ ...m })),
+			upstream: upstreamUrl.href,
+			rewrite,
+			...routes !== void 0 ? { routes } : {},
+			defaultPort
+		};
+		this.data.services.push(service);
+		this.save();
+		return { ...service };
+	}
+	removeService(name) {
+		const idx = this.data.services.findIndex((s) => s.name === name);
+		if (idx < 0) throw new StoreError("not-found", `error: service '${name}' not found`);
+		const [removed] = this.data.services.splice(idx, 1);
+		for (const group of this.data.groups) group.serviceIds = group.serviceIds.filter((id) => id !== removed.serviceId);
+		this.save();
+	}
+	listGroups() {
+		return this.data.groups.map((g) => ({
+			...g,
+			serviceIds: [...g.serviceIds]
+		}));
+	}
+	getGroup(name) {
+		const found = this.data.groups.find((g) => g.name === name);
+		return found === void 0 ? void 0 : {
+			...found,
+			serviceIds: [...found.serviceIds],
+			limits: found.limits ? { ...found.limits } : void 0
+		};
+	}
+	/** 组内服务视图（引用不存在的服务Id 自动跳过——防手工编辑残留）。 */
+	groupServices(groupName) {
+		const group = this.getGroup(groupName);
+		if (group === void 0) return [];
+		const out = [];
+		for (const id of group.serviceIds) {
+			const svc = this.getService(id);
+			if (svc !== void 0) out.push(svc);
+		}
+		return out;
+	}
+	addGroup(name, serviceNames, limits) {
+		const trimmed = name.trim();
+		if (trimmed === "" || trimmed.length > 256) throw new StoreError("invalid", "error: group name must be 1..256 chars");
+		if (this.data.groups.some((g) => g.name === trimmed)) throw new StoreError("duplicate", `error: group '${trimmed}' already exists`);
+		const serviceIds = this.resolveServiceIds(serviceNames);
+		if (limits !== void 0) validateLimits(limits);
+		const group = {
+			name: trimmed,
+			serviceIds,
+			limits: limits === void 0 ? void 0 : { ...limits }
+		};
+		this.data.groups.push(group);
+		this.save();
+		return {
+			...group,
+			serviceIds: [...serviceIds]
+		};
+	}
+	/** 更新既有分组的服务引用（整表替换；未知服务名报错）。 */
+	setGroupServices(name, serviceNames) {
+		const group = this.data.groups.find((g) => g.name === name);
+		if (group === void 0) throw new StoreError("not-found", `error: group '${name}' not found`);
+		group.serviceIds = this.resolveServiceIds(serviceNames);
+		this.save();
+		return {
+			...group,
+			serviceIds: [...group.serviceIds]
+		};
+	}
+	/** 更新分组限额（undefined = 清除限额变无限）。 */
+	setGroupLimits(name, limits) {
+		const group = this.data.groups.find((g) => g.name === name);
+		if (group === void 0) throw new StoreError("not-found", `error: group '${name}' not found`);
+		if (limits !== void 0) validateLimits(limits);
+		group.limits = limits === void 0 ? void 0 : { ...limits };
+		this.save();
+		return {
+			...group,
+			serviceIds: [...group.serviceIds]
+		};
+	}
+	/** 删除分组（仍有未撤销密钥时拒绝——孤儿密钥会以 key_all_invalid 形态困扰
+	*  持钥消费方；先 revoke 再删。Owner 验收 2026-09-10：group 管理对齐 keys）。 */
+	removeGroup(name) {
+		const index = this.data.groups.findIndex((g) => g.name === name);
+		if (index === -1) throw new StoreError("not-found", `error: group '${name}' not found`);
+		const activeKeys = this.data.keys.filter((k) => k.group === name && k.revokedAt === void 0);
+		if (activeKeys.length > 0) throw new StoreError("conflict", `error: group '${name}' still has ${activeKeys.length} active key(s) - revoke them first`);
+		this.data.groups.splice(index, 1);
+		this.save();
+	}
+	resolveServiceIds(serviceNames) {
+		const serviceIds = [];
+		for (const svcName of serviceNames) {
+			const svc = this.getServiceByName(svcName);
+			if (svc === void 0) throw new StoreError("not-found", `error: service '${svcName}' not found`);
+			if (!serviceIds.includes(svc.serviceId)) serviceIds.push(svc.serviceId);
+		}
+		return serviceIds;
+	}
+	listKeys() {
+		return this.data.keys.map((k) => ({ ...k }));
+	}
+	/** 签发：原文仅本次返回，存储只落哈希。 */
+	issueKey(groupName) {
+		if (this.getGroup(groupName) === void 0) throw new StoreError("not-found", `error: group '${groupName}' not found`);
+		let keyId;
+		do
+			keyId = randomZ32(8);
+		while (this.data.keys.some((k) => k.keyId === keyId));
+		const key = KEY_MATERIAL_PREFIX + randomZ32(32);
+		const createdAt = Date.now();
+		this.data.keys.push({
+			keyId,
+			group: groupName,
+			hash: hashKeyMaterial(key),
+			createdAt
+		});
+		this.save();
+		return {
+			keyId,
+			key,
+			createdAt
+		};
+	}
+	/** 撤销（幂等：已撤销为 no-op）。 */
+	revokeKey(keyId) {
+		const found = this.data.keys.find((k) => k.keyId === keyId);
+		if (found === void 0) throw new StoreError("not-found", `error: key '${keyId}' not found`);
+		if (found.revokedAt === void 0) {
+			found.revokedAt = Date.now();
+			this.save();
+		}
+		return { ...found };
+	}
+	/**
+	* 校验密钥原文：SHA-256(salt+原文) 后对全表 timingSafeEqual 扫描（不因命中
+	* 提前退出，时序与表内容无关节）。命中后按 revokedAt 区分 valid/revoked。
+	*/
+	verifyKey(material) {
+		const digest = Buffer.from(hashKeyMaterial(material), "hex");
+		let match;
+		for (const record of this.data.keys) {
+			const stored = Buffer.from(record.hash, "hex");
+			if (digest.length === stored.length && timingSafeEqual(digest, stored)) match = record;
+		}
+		if (match === void 0) return { status: "invalid" };
+		const located = {
+			keyId: match.keyId,
+			group: match.group
+		};
+		return match.revokedAt === void 0 ? {
+			status: "valid",
+			...located
+		} : {
+			status: "revoked",
+			...located
+		};
+	}
+	get alias() {
+		return this.data.meta?.alias;
+	}
+	setAlias(alias) {
+		const trimmed = alias.trim();
+		if (trimmed === "" || trimmed.length > 256) throw new StoreError("invalid", "error: alias must be 1..256 chars");
+		this.data.meta = {
+			...this.data.meta ?? {},
+			alias: trimmed
+		};
+		this.save();
+	}
+	/** 只读快照（引擎/测试）。 */
+	snapshot() {
+		return JSON.parse(JSON.stringify(this.data));
+	}
+	save() {
+		this.data.revision += 1;
+		atomicWriteFileSync(ProviderStore.filePath(this.dataDir), `${JSON.stringify(this.data, null, 2)}\n`);
+	}
+};
+function validateLimits(limits) {
+	for (const [key, value] of Object.entries(limits)) if (value !== void 0 && (!Number.isInteger(value) || value < 1)) throw new StoreError("invalid", `error: limit '${key}' must be a positive integer`);
+}
+/**
+* 路由表规范化（M3-r7）：空表→undefined；模式字段按 mode 归一——
+* prefix：localPrefix 补 / 去尾斜杠（缺省按首个 form 规范前缀）+ upstreamPrefix；
+* pattern：matchPattern 编译校验（{name}→:name 兼容翻译）+ template RFC 6570
+* 解析校验（写入期 fail-fast，运行期零重复解析）。不做语义限制。
+*/
+function normalizeRoutes(routes) {
+	if (routes === void 0) return void 0;
+	const cleaned = routes.filter((r) => r !== null && r !== void 0);
+	if (cleaned.length === 0) return void 0;
+	const out = [];
+	for (const route of cleaned) {
+		const forms = [...new Set(route.forms ?? [])];
+		if (route.mode === "pattern") {
+			const matchPattern = route.matchPattern?.trim() ?? "";
+			const template = route.template?.trim() ?? "";
+			if (matchPattern === "" || template === "") throw new StoreError("invalid", "error: pattern route requires matchPattern and template");
+			try {
+				compileMatchPattern(matchPattern);
+			} catch (err) {
+				throw new StoreError("invalid", `error: invalid matchPattern '${matchPattern}': ${err.message}`);
+			}
+			try {
+				validateUriTemplate(template);
+			} catch (err) {
+				throw new StoreError("invalid", `error: invalid template '${template}': ${err.message}`);
+			}
+			out.push({
+				forms,
+				mode: "pattern",
+				matchPattern,
+				template
+			});
+			continue;
+		}
+		let local = route.localPrefix?.trim() ?? "";
+		if (local !== "") {
+			if (!local.startsWith("/")) local = `/${local}`;
+			local = local.replace(/\/+$/, "");
+		}
+		if (local === "") local = ROUTE_LOCAL_PREFIX[forms[0] ?? "openai-chat"];
+		let up = route.upstreamPrefix?.trim() ?? "";
+		if (up !== "") {
+			if (!up.startsWith("/")) up = `/${up}`;
+			up = up.replace(/\/+$/, "");
+		}
+		out.push({
+			forms,
+			localPrefix: local,
+			upstreamPrefix: up
+		});
+	}
+	return out;
+}
+function normalizeRewrite(rewrite) {
+	const out = {};
+	if (rewrite.hostHeader !== void 0) {
+		if (rewrite.hostHeader.trim() === "") throw new StoreError("invalid", "error: rewrite hostHeader must not be empty");
+		out.hostHeader = rewrite.hostHeader.trim();
+	}
+	for (const field of ["pathPrefixStrip", "pathPrefixAppend"]) {
+		const value = rewrite[field];
+		if (value === void 0) continue;
+		const norm = value.startsWith("/") ? value : `/${value}`;
+		if (norm === "/") throw new StoreError("invalid", `error: rewrite ${field} must not be '/'`);
+		out[field] = norm;
+	}
+	if (rewrite.headerSet !== void 0) {
+		const headerSet = {};
+		for (const [name, value] of Object.entries(rewrite.headerSet)) {
+			const lower = name.toLowerCase();
+			if (lower === "") throw new StoreError("invalid", "error: rewrite headerSet name must not be empty");
+			headerSet[lower] = value;
+		}
+		out.headerSet = headerSet;
+	}
+	if (rewrite.headerRemove !== void 0) out.headerRemove = [...new Set(rewrite.headerRemove.map((n) => n.toLowerCase()))];
+	return out;
+}
+//#endregion
+//#region src/cli/commands/provider/common.ts
+function resolveDataDir(flag, home = homedir()) {
+	if (flag === void 0 || flag === "") return join(home, ".aifly", "provider");
+	return flag;
+}
+/** relay 解析（flag > AIFLY_RELAY env > config file）；exactOptionalPropertyTypes 安全组装。 */
+function resolvedRelayUrls(options, home) {
+	const input = {};
+	if (Array.isArray(options.relay)) input.flag = options.relay;
+	const env = process.env.AIFLY_RELAY;
+	if (env !== void 0) input.env = env;
+	input.file = loadConfig(home);
+	return resolveRelayUrls(input);
+}
+function str(value) {
+	if (typeof value === "string") return value;
+}
+function multi(value) {
+	if (Array.isArray(value)) return value;
+	if (typeof value === "string") return [value];
+	return [];
+}
+function requireString(value, label) {
+	if (value === void 0 || value === "") throw new UsageError(`error: missing required option --${label}`);
+	return value;
+}
+function parsePositiveInt(raw, label) {
+	const n = Number(raw);
+	if (!Number.isInteger(n) || n < 1 || n > Number.MAX_SAFE_INTEGER) throw new UsageError(`error: invalid ${label} value: ${raw} (expected a positive integer)`);
+	return n;
+}
+function parsePortNumber(raw, label) {
+	const n = parsePositiveInt(raw, label);
+	if (n > 65535) throw new UsageError(`error: invalid ${label} value: ${raw} (expected 1..65535)`);
+	return n;
+}
+/** "type:value"（value 为剩余整体；type in exact|suffix|regex）。 */
+function parseMatchSpec(raw) {
+	const idx = raw.indexOf(":");
+	if (idx <= 0) throw new UsageError(`error: invalid --match value: ${raw} (expected <exact|suffix|regex>:<value>)`);
+	const type = raw.slice(0, idx);
+	const value = raw.slice(idx + 1);
+	if (type !== "exact" && type !== "suffix" && type !== "regex") throw new UsageError(`error: invalid --match type: ${type} (expected exact|suffix|regex)`);
+	if (value === "") throw new UsageError(`error: invalid --match value: ${raw} (value must not be empty)`);
+	return {
+		type,
+		value
+	};
+}
+/** "Name=value"（首个 = 分割；Name 小写化）。 */
+function parseHeaderSetSpec(raw) {
+	const idx = raw.indexOf("=");
+	if (idx <= 0) throw new UsageError(`error: invalid --header-set value: ${raw} (expected <name>=<value>, value may be $env:VAR)`);
+	return {
+		name: raw.slice(0, idx).trim().toLowerCase(),
+		value: raw.slice(idx + 1)
+	};
+}
+/** 各命令的 rewrite 组装（仅在存在任一重写选项时构造）。 */
+function buildRewrite(input) {
+	const rewrite = {};
+	if (input.host !== void 0) rewrite.hostHeader = input.host;
+	if (input.strip !== void 0) rewrite.pathPrefixStrip = input.strip;
+	if (input.append !== void 0) rewrite.pathPrefixAppend = input.append;
+	if (input.headerSet.length > 0) {
+		const headerSet = {};
+		for (const h of input.headerSet) headerSet[h.name] = h.value;
+		rewrite.headerSet = headerSet;
+	}
+	if (input.headerRemove.length > 0) rewrite.headerRemove = input.headerRemove;
+	return Object.keys(rewrite).length === 0 ? void 0 : rewrite;
+}
+function openStore(dataDir) {
+	return ProviderStore.open(dataDir);
+}
+//#endregion
+export { expandUriTemplate as _, parseMatchSpec as a, SECRET_NAME_SCHEMA as b, requireString as c, str as d, ProviderStore as f, parseUpstreamUrl as g, ensurePrivateDir as h, parseHeaderSetSpec as i, resolveDataDir as l, atomicWriteFileSync as m, multi as n, parsePortNumber as o, StoreError as p, openStore as r, parsePositiveInt as s, buildRewrite as t, resolvedRelayUrls as u, compileMatchPattern as v, routeLocalPrefix as x, matchRequestPath as y };