@lyogvce/dsh-codex-subscription 0.2.12 → 0.3.0

package/README.md

@@ -11,8 +11,8 @@
 1. **与本机 Codex CLI / Desktop 100% 共享登录态**
    - 直接读取 `$CODEX_HOME/auth.json`（默认 `~/.codex/auth.json`）。
    - 每次请求前检查 `access_token` 的 JWT `exp`：距离过期不足 5 分钟时自动通过单飞锁（Single-flight）向 `https://auth.openai.com/oauth/token` 刷新，并通过 `realpathSync` + 临时文件 `rename` 原子写回 `auth.json`，保证与 Codex CLI 永不互踢下线。
-2. **零网络轮询的本地模型目录发现、防降级保护与可观测性日志**
-   - 直接读取 `~/.codex/models_cache.json`（每次按文件 `mtime` 与大小做微秒级 `stat` 校验，仅在文件变化时重读解析），提取 `visibility === "list"` 的模型及其 `context_window`、`supported_reasoning_levels`（自动将 `ultra` 映射为 DSH 的 `max` 档位）与 `default_verbosity`。
+2. **零网络轮询的本地模型目录实时监听、防降级保护与可观测性日志**
+   - 直接读取并监听 `~/.codex/models_cache.json`（同时结合 `realpathSync` 目录级防抖 `fs.watch` 实时监听与微秒级 `stat` 校验，兼容软链接目录与临时文件 `rename` 原子替换），提取 `visibility === "list"` 的模型及其 `context_window`、`supported_reasoning_levels`（自动将 `ultra` 映射为 DSH 的 `max` 档位）与 `default_verbosity`；当本地模型缓存新增或变更模型时，自动调用 `ctx.llm.emitAdaptersUpdated()` 通知 DSH 桌面端前端立即刷新模型下拉框，无需重启或刷新页面。
    - **防旧版客户端降级污染**：自动将高版本 `models_cache.json` 备份至 `~/.codex/cache/dsh-codex-subscription/models-cache-backup.json`；当外部旧版进程（如 `dsh-subagent-codex` 内置的 `0.153.4`）将 `models_cache.json` 降级覆写为不含新模型的旧缓存时，自动拦截降级并保留高版本模型目录。
    - **可观测性日志**：自动在 `~/.codex/cache/dsh-codex-subscription/plugin.log`（带 512KB 自动滚动截断，忽略纯 `fetched_at` 心跳刷新）记录目录加载（`catalog.load` / `catalog.snapshot`）、降级拦截（`catalog.downgrade_rejected`）、备份恢复（`catalog.backup_restored`）与凭证续期（`auth.refreshed` / `auth.refresh_failed`）事件。
 3. **支持按配置屏蔽模型（`disabledModels`）、自定义上下文窗口（`contextWindows`）与原生重试策略（`retryPolicy`）**
@@ -22,7 +22,7 @@
 4. **原生多轮思考链回放、工具调用与出站指纹净化**
    - 底层复用 DSH 内置的 `PiAiAdapter` 与 `@earendil-works/pi-ai` 的 `openaiCodexProvider()`，固定使用 `sse` 传输（含 `zstd` 请求体压缩、规范化 36 位 RFC 4122 UUID `session-id` 缓存头与 `prompt_cache_key`、`reasoning.encrypted_content` 签名回放与图片自动缩放卸载），并通过自定义 `fetch` 与 `onPayload` 剥除 `OpenAI-Beta: responses=experimental`、静态 `x-client-request-id`、`msg_pi_*` 等非官方指纹。
 5. **Codex 订阅限额内联展示与 ⚡ Fast 极速模式一键切换（`conversation.input.right`）**
-   - 当会话选中 `openai-codex` 模型时，在输入框右下角紧邻模型选择器左侧展示限额胶囊（根据 `wham/usage` 返回的 `limit_window_seconds` 自适应展示 Plus 的 `5h X% · 7d Y%` 双窗口或 Pro 的 `7d X%` 单窗口，内置 60 秒缓存、单飞合并与每轮回复结束自动刷新），点击可展开查看对应窗口进度条、重置倒计时与手动刷新按钮；切换至其他 Provider 模型时自动隐藏。
+   - 当会话选中 `openai-codex` 模型时，在输入框右下角紧邻模型选择器左侧展示限额胶囊（根据 `wham/usage` 返回的 `limit_window_seconds` 自适应展示 Plus 的 `5h X% · 7d Y%` 双窗口或 Pro 的 `7d X%` 单窗口；由模型请求与流完成结算触发、按 60 秒限流在后台自动更新缓存，并由前端周期静默同步，无请求时零远端轮询，点击胶囊直接展开详情弹窗不触发额外请求），弹窗内可查看窗口进度条、重置倒计时与手动刷新按钮；切换至其他 Provider 模型时自动隐藏。
    - **⚡ 会话树级 Fast 极速模式（`service_tier: "priority"`，最高 2x 推理速度，主会话与 Subagent / 智能体团队同开同关）**：每个主会话可在限额弹窗底部独立开关 Fast 模式（不同主会话互不影响，新会话默认继承插件设置中的 `fastMode`，未配置时默认 `false` 关闭），该主会话派生的所有 `subagent`、`subagent_fork`、`workflow` 子任务以及智能体团队成员（`spawn_teammate`）均自动绑定至同一主会话开关，实时联动、同开同关；状态自动持久化至 `~/.codex/cache/dsh-codex-subscription/runtime-state.json`。开启后胶囊显示闪电标识 `⚡`，并在请求体中自动注入 `"service_tier": "priority"`。
 
 ---

package/lib/client.js

@@ -171,7 +171,7 @@ window.__ModuleLoader__.load({
 		function createQuotaStore(options = {}) {
 			const fetchFn = options.fetchImpl ?? globalThis.fetch;
 			const nowFn = options.now ?? Date.now;
-			const ttlMs = options.ttlMs ?? 6e4;
+			const explicitTtlMs = options.ttlMs;
 			let state = {
 				quota: null,
 				defaultFastMode: false,
@@ -273,15 +273,16 @@ window.__ModuleLoader__.load({
 				};
 			}
 			async function refresh(force = false) {
-				if (!force && state.quota !== null && nowFn() - state.quota.fetchedAt < ttlMs) return;
+				if (!force && explicitTtlMs !== void 0 && state.quota !== null && nowFn() - state.quota.fetchedAt < explicitTtlMs) return;
 				if (inflight !== null && (!force || inflightForce)) return inflight;
 				const seq = ++requestSeq;
 				const canReplaceFastAtStart = pendingBySeq.size === 0;
 				const fastEpochAtStart = fastMutationEpoch;
 				inflightForce = force;
-				setState({
+				const showLoading = force || state.quota === null;
+				if (showLoading || state.error !== null) setState({
 					...state,
-					loading: true,
+					loading: showLoading ? true : state.loading,
 					error: null
 				});
 				const url = force ? `${USAGE_ROUTE_PATH}?force=1` : USAGE_ROUTE_PATH;
@@ -489,6 +490,8 @@ window.__ModuleLoader__.load({
 		const NS = "codex-subscription";
 		const SLOT_NAME = "conversation.input.right";
 		const SLOT_ENTRY_ID = "codex-subscription:quota";
+		const ACTIVE_QUOTA_SYNC_INTERVAL_MS = 5e3;
+		const IDLE_QUOTA_SYNC_INTERVAL_MS = 15e3;
 		const zh = {
 			"quota.title": "Codex 订阅限额",
 			"quota.loading": "正在获取 Codex 限额…",
@@ -547,8 +550,8 @@ window.__ModuleLoader__.load({
 					prevRunningRef.current = running;
 					return;
 				}
-				quotaStore.refresh(false);
 				if (sameSession && didTurnFinish(prevRunningRef.current, running)) quotaStore.refresh(true);
+				else if (!sameSession || !running || quotaStore.getSnapshot().quota === null) quotaStore.refresh(false);
 				prevRunningRef.current = running;
 			}, [
 				isCodex,
@@ -556,6 +559,20 @@ window.__ModuleLoader__.load({
 				sessionId,
 				quotaStore
 			]);
+			React.useEffect(() => {
+				if (!isCodex || typeof globalThis.setInterval !== "function") return;
+				const intervalMs = running ? ACTIVE_QUOTA_SYNC_INTERVAL_MS : IDLE_QUOTA_SYNC_INTERVAL_MS;
+				const timer = globalThis.setInterval(() => {
+					quotaStore.refresh(false);
+				}, intervalMs);
+				return () => {
+					globalThis.clearInterval(timer);
+				};
+			}, [
+				isCodex,
+				running,
+				quotaStore
+			]);
 			React.useEffect(() => {
 				if (!open || !isCodex || typeof globalThis.document === "undefined") return;
 				const onPointerDown = (event) => {
@@ -609,9 +626,7 @@ window.__ModuleLoader__.load({
 				"aria-expanded": open,
 				title: `${t("quota.title")} (${pillText})`,
 				onClick: () => {
-					const nextOpen = !open;
-					setOpen(nextOpen);
-					if (nextOpen) quotaStore.refresh(false);
+					setOpen(!open);
 				}
 			}, h("svg", {
 				viewBox: "0 0 14 14",

package/lib/index.d.ts

@@ -160,17 +160,22 @@ interface UsageFetcherOptions {
   readonly now?: (() => number) | undefined;
   readonly ttlMs?: number | undefined;
   readonly minForceIntervalMs?: number | undefined;
+  readonly autoRefresh?: boolean | undefined;
 }
 declare function parseUsagePayload(raw: unknown, fetchedAt: number): CodexQuotaSnapshot | null;
 declare function createUsageFetcher(options: UsageFetcherOptions): {
   getUsage: (force?: boolean) => Promise<CodexQuotaResponse>;
+  onRequestStart: () => void;
   invalidate: () => void;
+  dispose: () => void;
 };
 //#endregion
 //#region src/index.d.ts
 export declare const name = "codex-subscription";
 export declare const inject: string[];
 export declare const LOG_FILE_NAME = "plugin.log";
+export declare const MODELS_CACHE_FILE_NAME = "models_cache.json";
+export declare const MODELS_CACHE_WATCH_DEBOUNCE_MS = 100;
 export declare const Config: any;
 export declare function apply(ctx: PluginContextLike, config?: Record<string, unknown>): void;
 export declare const __test: Readonly<{

package/lib/index.js

@@ -1,4 +1,4 @@
-import { appendFileSync, chmodSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, chmodSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, watch, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { LlmError, RetryPolicySchema, resolveImageAttachmentAccess, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
@@ -402,15 +402,59 @@ function parseUsagePayload(raw, fetchedAt) {
 		fetchedAt
 	};
 }
+function isWindowResetDue(snapshot, nowMs) {
+	const nowSec = nowMs / 1e3;
+	const fetchedSec = snapshot.fetchedAt / 1e3;
+	const primaryReset = snapshot.primary.resetAt;
+	if (primaryReset !== null && fetchedSec < primaryReset && nowSec >= primaryReset) return true;
+	const secondaryReset = snapshot.secondary?.resetAt ?? null;
+	if (secondaryReset !== null && fetchedSec < secondaryReset && nowSec >= secondaryReset) return true;
+	return false;
+}
 function createUsageFetcher(options) {
 	const fetchFn = options.fetchImpl ?? globalThis.fetch;
 	const nowFn = options.now ?? Date.now;
 	const ttlMs = options.ttlMs ?? 6e4;
 	const minForceIntervalMs = options.minForceIntervalMs ?? 5e3;
+	const autoRefresh = options.autoRefresh === true;
 	let cached;
-	let stale = false;
+	let lastAttemptAt;
+	let hasConsumer = false;
+	let dirtyRevision = 0;
+	let fetchedRevision = 0;
 	let inflight;
+	let trailingTimer;
+	let disposed = false;
+	const isStale = () => dirtyRevision > fetchedRevision;
+	function clearTrailingTimer() {
+		if (trailingTimer !== void 0) {
+			clearTimeout(trailingTimer);
+			trailingTimer = void 0;
+		}
+	}
+	function scheduleBackgroundRefresh(deferIfCached = false) {
+		if (!autoRefresh || !hasConsumer || disposed || !isStale() || inflight !== void 0) return;
+		const baseTime = cached?.fetchedAt ?? lastAttemptAt;
+		if (baseTime === void 0) {
+			runSingleFlight();
+			return;
+		}
+		const ageMs = Math.max(0, nowFn() - baseTime);
+		if (!deferIfCached && ageMs >= ttlMs) {
+			runSingleFlight();
+			return;
+		}
+		if (trailingTimer !== void 0) return;
+		const delayMs = deferIfCached ? Math.max(1, ageMs >= ttlMs ? ttlMs : ttlMs - ageMs) : Math.max(1, ttlMs - ageMs);
+		trailingTimer = setTimeout(() => {
+			trailingTimer = void 0;
+			if (disposed || !isStale()) return;
+			runSingleFlight();
+		}, delayMs);
+		trailingTimer.unref?.();
+	}
 	async function fetchFresh() {
+		const revAtStart = dirtyRevision;
 		try {
 			const creds = await options.resolveCredentials();
 			const headers = options.buildHeaders({
@@ -423,24 +467,28 @@ function createUsageFetcher(options) {
 				headers,
 				signal: AbortSignal.timeout(USAGE_FETCH_TIMEOUT_MS)
 			});
+			const finishedAt = nowFn();
+			lastAttemptAt = finishedAt;
+			fetchedRevision = Math.max(fetchedRevision, revAtStart);
 			if (!response.ok) return {
 				ok: false,
 				error: `Codex 限额查询失败 (HTTP ${response.status})`,
 				...cached !== void 0 ? { quota: cached } : {}
 			};
-			const parsed = parseUsagePayload(await response.json(), nowFn());
+			const parsed = parseUsagePayload(await response.json(), finishedAt);
 			if (parsed === null) return {
 				ok: false,
 				error: "Codex 限额响应格式无法解析",
 				...cached !== void 0 ? { quota: cached } : {}
 			};
 			cached = parsed;
-			stale = false;
 			return {
 				ok: true,
 				quota: parsed
 			};
 		} catch (error) {
+			lastAttemptAt = nowFn();
+			fetchedRevision = Math.max(fetchedRevision, revAtStart);
 			return {
 				ok: false,
 				error: safeErrorMessage(error),
@@ -448,26 +496,52 @@ function createUsageFetcher(options) {
 			};
 		}
 	}
+	function runSingleFlight() {
+		clearTrailingTimer();
+		if (!inflight) inflight = fetchFresh().finally(() => {
+			inflight = void 0;
+			if (autoRefresh && !disposed && isStale()) scheduleBackgroundRefresh();
+		});
+		return inflight;
+	}
 	return {
+		onRequestStart() {
+			dirtyRevision += 1;
+			scheduleBackgroundRefresh(true);
+		},
 		invalidate() {
-			stale = true;
+			dirtyRevision += 1;
+			scheduleBackgroundRefresh(false);
+		},
+		dispose() {
+			disposed = true;
+			clearTrailingTimer();
 		},
 		async getUsage(force = false) {
-			if (!stale && cached !== void 0) {
-				const ageMs = nowFn() - cached.fetchedAt;
-				if (!force && ageMs < ttlMs) return {
-					ok: true,
-					quota: cached
-				};
-				if (force && ageMs >= 0 && ageMs < minForceIntervalMs) return {
+			hasConsumer = true;
+			if (cached !== void 0) {
+				const nowMs = nowFn();
+				const ageMs = nowMs - cached.fetchedAt;
+				const stale = isStale();
+				const resetDue = isWindowResetDue(cached, nowMs);
+				if (!force) {
+					if (ageMs >= 0 && ageMs < ttlMs && (!stale || autoRefresh)) {
+						if (stale) scheduleBackgroundRefresh(false);
+						return {
+							ok: true,
+							quota: cached
+						};
+					}
+					if (autoRefresh && !stale && !resetDue) return {
+						ok: true,
+						quota: cached
+					};
+				} else if (!stale && ageMs >= 0 && ageMs < minForceIntervalMs) return {
 					ok: true,
 					quota: cached
 				};
 			}
-			if (!inflight) inflight = fetchFresh().finally(() => {
-				inflight = void 0;
-			});
-			return inflight;
+			return runSingleFlight();
 		}
 	};
 }
@@ -704,6 +778,8 @@ function createAuthManager(options) {
 const name = "codex-subscription";
 const inject = ["llm"];
 const LOG_FILE_NAME = "plugin.log";
+const MODELS_CACHE_FILE_NAME = "models_cache.json";
+const MODELS_CACHE_WATCH_DEBOUNCE_MS = 100;
 const STREAM_IDLE_TIMEOUT_MS = 3e5;
 const MAX_REQUEST_IMAGE_BYTES = 20971520;
 const REQUEST_IMAGE_PIXEL_BUDGET = 4194304;
@@ -711,6 +787,27 @@ const REQUEST_IMAGE_MAX_BYTES = 1048576;
 const MAX_LOG_FILE_BYTES = 524288;
 const MAX_PERSISTED_SESSIONS = 200;
 const MAX_PERSISTED_PARENTS = 1e3;
+function resolveModelsCacheWatchTargets(codexHome) {
+	const dirs = new Set();
+	const fileNames = new Set([MODELS_CACHE_FILE_NAME]);
+	try {
+		dirs.add(realpathSync(codexHome));
+	} catch {
+		try {
+			if (statSync(codexHome).isDirectory()) dirs.add(codexHome);
+		} catch {}
+	}
+	const cachePath = join(codexHome, MODELS_CACHE_FILE_NAME);
+	try {
+		const realCachePath = realpathSync(cachePath);
+		dirs.add(dirname(realCachePath));
+		fileNames.add(basename(realCachePath));
+	} catch {}
+	return {
+		dirs: [...dirs],
+		fileNames
+	};
+}
 function resolvePluginCacheDir(codexHome) {
 	return join(codexHome, PLUGIN_CACHE_DIR_NAME);
 }
@@ -840,7 +937,8 @@ var CodexPiAiAdapter = class extends PiAiAdapter {
 function apply(ctx, config = {}) {
 	const baseProvider = openaiCodexProvider();
 	const baseModels = baseProvider.getModels();
-	const getCodexHome = () => resolveCodexHome();
+	const boundCodexHome = resolveCodexHome();
+	const getCodexHome = () => boundCodexHome;
 	const getConfigFastMode = () => readVolatile(config.fastMode, false) === true;
 	const getDisabledModels = () => readVolatile(config.disabledModels, DEFAULT_DISABLED_MODELS);
 	const getContextWindows = () => readVolatile(config.contextWindows, {});
@@ -993,7 +1091,77 @@ function apply(ctx, config = {}) {
 	let rawRevision = 0;
 	let activeRetryPolicy = resolveConfiguredRetryPolicy();
 	let currentState;
+	let adapterRegistered = false;
 	const catalogByProfiles = new WeakMap();
+	const activeWatchers = new Map();
+	let watchedFileNames = new Set([MODELS_CACHE_FILE_NAME]);
+	let watchDebounceTimer;
+	let watcherDisposed = false;
+	const closeModelsCacheWatchers = () => {
+		if (watchDebounceTimer !== void 0) {
+			clearTimeout(watchDebounceTimer);
+			watchDebounceTimer = void 0;
+		}
+		for (const watcher of activeWatchers.values()) try {
+			watcher.close();
+		} catch {}
+		activeWatchers.clear();
+	};
+	const scheduleModelsCacheCheck = () => {
+		if (watcherDisposed) return;
+		if (watchDebounceTimer !== void 0) clearTimeout(watchDebounceTimer);
+		watchDebounceTimer = setTimeout(() => {
+			watchDebounceTimer = void 0;
+			if (watcherDisposed) return;
+			try {
+				if (!statSync(getCodexHome()).isDirectory()) {
+					watcherDisposed = true;
+					closeModelsCacheWatchers();
+					return;
+				}
+			} catch {
+				watcherDisposed = true;
+				closeModelsCacheWatchers();
+				return;
+			}
+			syncModelsCacheWatchers();
+			ensureSnapshot();
+		}, 100);
+		watchDebounceTimer.unref?.();
+	};
+	const syncModelsCacheWatchers = () => {
+		if (watcherDisposed) return;
+		const { dirs, fileNames } = resolveModelsCacheWatchTargets(getCodexHome());
+		watchedFileNames = fileNames;
+		const nextDirSet = new Set(dirs);
+		for (const [dir, watcher] of activeWatchers.entries()) if (!nextDirSet.has(dir)) {
+			try {
+				watcher.close();
+			} catch {}
+			activeWatchers.delete(dir);
+		}
+		for (const dir of nextDirSet) {
+			if (activeWatchers.has(dir)) continue;
+			try {
+				const watcher = watch(dir, { persistent: false }, (_eventType, rawFilename) => {
+					if (watcherDisposed) return;
+					if (rawFilename != null) {
+						const name = typeof rawFilename === "string" ? rawFilename : String(rawFilename);
+						if (name !== "" && !watchedFileNames.has(name)) return;
+					}
+					scheduleModelsCacheCheck();
+				});
+				watcher.on("error", () => {
+					try {
+						watcher.close();
+					} catch {}
+					activeWatchers.delete(dir);
+				});
+				watcher.unref?.();
+				activeWatchers.set(dir, watcher);
+			} catch {}
+		}
+	};
 	const requestTokenAuth = Object.freeze({
 		name: "Codex CLI auth.json token",
 		async resolve({ credential }) {
@@ -1007,7 +1175,7 @@ function apply(ctx, config = {}) {
 	});
 	function wrapOptions(catalog, model, options = {}) {
 		const modelMeta = catalog.metadataById.get(model?.id);
-		const { temperature: _temperature, sessionId, onPayload, ...rest } = options;
+		const { temperature: _temperature, sessionId, onPayload, onProviderStreamEvent, ...rest } = options;
 		const initiatorId = (ctx.get?.("agents"))?.currentInitiator?.()?.id;
 		const normalizedSessionId = normalizeCodexSessionId(sessionId) ?? normalizeCodexSessionId(initiatorId);
 		const wireSessionId = toCodexWireSessionId(normalizedSessionId);
@@ -1023,12 +1191,18 @@ function apply(ctx, config = {}) {
 			}),
 			async onPayload(payload, requestModel) {
 				return sanitizeCodexPayload(await onPayload?.(payload, requestModel) ?? payload, modelMeta, getEffectiveFastMode(normalizedSessionId));
+			},
+			async onProviderStreamEvent(event, eventModel) {
+				await onProviderStreamEvent?.(event, eventModel);
+				const eventType = event !== null && typeof event === "object" ? event.type : void 0;
+				if (eventType === "response.completed" || eventType === "response.done" || eventType === "response.incomplete") usageFetcher.invalidate();
 			}
 		};
 	}
 	const usageFetcher = createUsageFetcher({
 		resolveCredentials: () => authManager.resolveCredentials(),
-		buildHeaders: (authHeaders) => buildCodexHeaders(authHeaders, ensureSnapshot().catalog.clientVersion)
+		buildHeaders: (authHeaders) => buildCodexHeaders(authHeaders, ensureSnapshot().catalog.clientVersion),
+		autoRefresh: true
 	});
 	function createSnapshotPiProvider(snapshotCatalog) {
 		return Object.freeze({
@@ -1041,19 +1215,20 @@ function apply(ctx, config = {}) {
 			}),
 			getModels: () => snapshotCatalog.models,
 			stream: (model, context, options) => {
-				usageFetcher.invalidate();
+				usageFetcher.onRequestStart();
 				return baseProvider.stream(model, context, wrapOptions(snapshotCatalog, model, options));
 			},
 			streamSimple: (model, context, options) => {
-				usageFetcher.invalidate();
+				usageFetcher.onRequestStart();
 				return baseProvider.streamSimple(model, context, wrapOptions(snapshotCatalog, model, options));
 			}
 		});
 	}
-	function ensureSnapshot() {
+	function ensureSnapshot(options) {
+		const prevCatalogSig = currentState?.catalogSig;
 		const retryPolicy = activeRetryPolicy;
 		const codexHome = getCodexHome();
-		const cachePath = join(codexHome, "models_cache.json");
+		const cachePath = join(codexHome, MODELS_CACHE_FILE_NAME);
 		const disabled = getDisabledModels();
 		const contextWindows = getContextWindows();
 		const setActiveRaw = (next) => {
@@ -1172,6 +1347,11 @@ function apply(ctx, config = {}) {
 				retryPolicySig
 			});
 		}
+		if (adapterRegistered && !watcherDisposed) syncModelsCacheWatchers();
+		if (adapterRegistered && options?.notifyAdaptersUpdated !== false && prevCatalogSig !== void 0 && nextCatalogSig !== prevCatalogSig) {
+			committedState = currentState;
+			ctx.llm.emitAdaptersUpdated?.();
+		}
 		return currentState;
 	}
 	const adapter = new CodexPiAiAdapter({
@@ -1202,8 +1382,26 @@ function apply(ctx, config = {}) {
 		const snapProfiles = snapshot?.profiles;
 		return ((snapProfiles !== void 0 ? catalogByProfiles.get(snapProfiles) : void 0) ?? ensureSnapshot().catalog).metadataById.get(modelId);
 	});
-	let committedState = ensureSnapshot();
+	let committedState = ensureSnapshot({ notifyAdaptersUpdated: false });
 	const registration = ctx.llm.registerAdapter([PROVIDER], adapter);
+	adapterRegistered = true;
+	if (typeof ctx.effect === "function") ctx.effect(() => {
+		watcherDisposed = false;
+		syncModelsCacheWatchers();
+		return () => {
+			watcherDisposed = true;
+			closeModelsCacheWatchers();
+			usageFetcher.dispose();
+		};
+	}, "codex-subscription: models_cache watcher");
+	else {
+		syncModelsCacheWatchers();
+		ctx.on?.("dispose", () => {
+			watcherDisposed = true;
+			closeModelsCacheWatchers();
+			usageFetcher.dispose();
+		});
+	}
 	const mountUsageRoute = (connCtx) => {
 		const connection = connCtx.get?.("connection");
 		const registerFetch = connection?.fetch?.register;
@@ -1284,7 +1482,7 @@ function apply(ctx, config = {}) {
 		activeRetryPolicy = candidateRetryPolicy;
 		let nextState;
 		try {
-			nextState = ensureSnapshot();
+			nextState = ensureSnapshot({ notifyAdaptersUpdated: false });
 			if (nextState.retryPolicySig !== prevCommitted.retryPolicySig) {
 				registration.replace([PROVIDER]);
 				committedState = nextState;
@@ -1326,4 +1524,4 @@ const __test = Object.freeze({
 	createUsageFetcher
 });
 //#endregion
-export { BACKUP_CACHE_FILE_NAME, Config, LOG_FILE_NAME, PLUGIN_CACHE_DIR_NAME, RUNTIME_STATE_FILE_NAME, __test, apply, inject, name };
+export { BACKUP_CACHE_FILE_NAME, Config, LOG_FILE_NAME, MODELS_CACHE_FILE_NAME, MODELS_CACHE_WATCH_DEBOUNCE_MS, PLUGIN_CACHE_DIR_NAME, RUNTIME_STATE_FILE_NAME, __test, apply, inject, name };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lyogvce/dsh-codex-subscription",
-  "version": "0.2.12",
+  "version": "0.3.0",
   "description": "复用本机 ~/.codex 订阅凭证与 models_cache.json 模型缓存，在 DSH 中通过 SSE 直连调用 Codex 模型。",
   "type": "module",
   "main": "./lib/index.js",
@@ -50,17 +50,6 @@
     "tsdown": "0.23.0",
     "typescript": "5.9.3"
   },
-  "scripts": {
-    "build": "tsdown",
-    "dev": "tsdown --watch",
-    "typecheck": "tsc --noEmit",
-    "pretest": "pnpm build",
-    "test": "node --test tests/*.test.mjs",
-    "test:isolation": "./tools/test-isolation.sh",
-    "verify": "pnpm typecheck && pnpm test && pnpm test:isolation",
-    "prepack": "pnpm build",
-    "prepublishOnly": "pnpm verify"
-  },
   "publishConfig": {
     "access": "public"
   },
@@ -71,5 +60,14 @@
     "codex",
     "openai-codex",
     "subscription"
-  ]
-}
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "pretest": "pnpm build",
+    "test": "node --test tests/*.test.mjs",
+    "test:isolation": "./tools/test-isolation.sh",
+    "verify": "pnpm typecheck && pnpm test && pnpm test:isolation"
+  }
+}