@openclaw/codex 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/{plugin-app-cache-key-DztPafOA.js → plugin-app-cache-key-C3H2CVp6.js}

@@ -1,11 +1,11 @@
-import { K as resolveCodexAppServerHomeDir } from "./shared-client-DTbvH-XV.js";
-import { w as resolveCodexAppServerUserHomeDir } from "./session-binding-BXpo9ymA.js";
+import { A as resolveCodexAppServerUserHomeDir } from "./session-binding-DPxIvMgE.js";
+import { dt as resolveCodexAppServerLocalHomeDir, ut as resolveCodexAppServerHomeDir } from "./shared-client-kIBbGjk4.js";
 import { createRequire } from "node:module";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { readPluginPackageVersion } from "openclaw/plugin-sdk/extension-shared";
 import { isFutureDateTimestampMs, resolveDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { OPENCLAW_VERSION, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash } from "node:crypto";
-import { readPluginPackageVersion } from "openclaw/plugin-sdk/extension-shared";
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/codex/src/app-server/app-inventory-cache.ts
 /**
@@ -370,7 +370,7 @@ function resolveCodexAppServerConnectionHome(start, agentDir) {
 	if (start.transport === "unix" && (!start.url || start.url === "unix://")) return resolveCodexAppServerUserHomeDir(start.env ?? process.env);
 	if (start.transport !== "stdio") return null;
 	if (start.homeScope === "user") return resolveCodexAppServerUserHomeDir(process.env);
-	return agentDir ? resolveCodexAppServerHomeDir(agentDir) : null;
+	return agentDir ? resolveCodexAppServerLocalHomeDir(start, agentDir) : null;
 }
 /** Serializes app-server endpoint identity, including credential fingerprints. */
 function resolveCodexPluginAppCacheEndpoint(appServer) {

package/dist/plugin-marketplace-discovery-CzrGJdCR.js

@@ -0,0 +1,385 @@
+import { P as isCodexFastServiceTier, o as isCodexAppServerNativeAuthProfile, r as bindingStoreKey, s as normalizeCodexAppServerBindingModelProvider } from "./session-binding-DPxIvMgE.js";
+import { a as getLeasedSharedCodexAppServerClient, l as releaseLeasedSharedCodexAppServerClient } from "./shared-client-kIBbGjk4.js";
+import { g as resolveCodexAppServerRequestModelSelection, v as resolveCodexBindingModelProviderFallback } from "./thread-lifecycle-Bu1BTDXr.js";
+import { r as formatCodexDisplayText } from "./command-formatters-B1AEz8ZA.js";
+import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-I5Bo-AsX.js";
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
+import { patchSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { ModelSelectionLockedError, applyModelOverrideWithAuthProfileCompatibility } from "openclaw/plugin-sdk/model-session-runtime";
+//#region extensions/codex/src/command-authorization.ts
+const CODEX_NATIVE_EXECUTION_AUTH_ERROR = "Only an owner or operator.admin can control Codex native execution.";
+function canMutateCodexHost(ctx) {
+	return ctx.senderIsOwner === true || ctx.gatewayClientScopes?.includes("operator.admin") === true;
+}
+//#endregion
+//#region extensions/codex/src/conversation-control.ts
+const CODEX_CONVERSATION_CONTROL_STATE = Symbol.for("openclaw.codex.conversationControl");
+function getActiveTurns() {
+	const globalState = globalThis;
+	globalState[CODEX_CONVERSATION_CONTROL_STATE] ??= /* @__PURE__ */ new Map();
+	return globalState[CODEX_CONVERSATION_CONTROL_STATE];
+}
+function trackCodexConversationActiveTurn(active) {
+	const activeTurns = getActiveTurns();
+	const key = bindingStoreKey(active.identity);
+	activeTurns.set(key, active);
+	return () => {
+		if (activeTurns.get(key)?.turnId === active.turnId) activeTurns.delete(key);
+	};
+}
+function readCodexConversationActiveTurn(identity) {
+	return getActiveTurns().get(bindingStoreKey(identity));
+}
+async function stopCodexConversationTurn(params) {
+	const active = readCodexConversationActiveTurn(params.identity);
+	if (!active) return {
+		stopped: false,
+		message: "No active Codex run to stop."
+	};
+	const lookup = buildBindingLookup(params);
+	const binding = await params.bindingStore.read(params.identity);
+	if (binding?.threadId !== active.threadId) return {
+		stopped: false,
+		message: "The active Codex run no longer matches this session binding."
+	};
+	const connection = resolveCodexBindingAppServerConnection({
+		binding,
+		authProfileId: binding?.authProfileId,
+		pluginConfig: params.pluginConfig
+	});
+	const runtime = connection.appServer;
+	const client = active.client ?? await getLeasedSharedCodexAppServerClient({
+		startOptions: runtime.start,
+		timeoutMs: runtime.requestTimeoutMs,
+		authProfileId: connection.clientAuthProfileId,
+		...lookup
+	});
+	try {
+		await client.request("turn/interrupt", {
+			threadId: active.threadId,
+			turnId: active.turnId
+		}, { timeoutMs: runtime.requestTimeoutMs });
+	} finally {
+		if (!active.client) releaseLeasedSharedCodexAppServerClient(client);
+	}
+	return {
+		stopped: true,
+		message: "Codex stop requested."
+	};
+}
+async function steerCodexConversationTurn(params) {
+	const active = readCodexConversationActiveTurn(params.identity);
+	const text = params.message.trim();
+	if (!text) return {
+		steered: false,
+		message: "Usage: /codex steer <message>"
+	};
+	if (!active) return {
+		steered: false,
+		message: "No active Codex run to steer."
+	};
+	const lookup = buildBindingLookup(params);
+	const binding = await params.bindingStore.read(params.identity);
+	if (binding?.threadId !== active.threadId) return {
+		steered: false,
+		message: "The active Codex run no longer matches this session binding."
+	};
+	const connection = resolveCodexBindingAppServerConnection({
+		binding,
+		authProfileId: binding?.authProfileId,
+		pluginConfig: params.pluginConfig
+	});
+	const runtime = connection.appServer;
+	const client = active.client ?? await getLeasedSharedCodexAppServerClient({
+		startOptions: runtime.start,
+		timeoutMs: runtime.requestTimeoutMs,
+		authProfileId: connection.clientAuthProfileId,
+		...lookup
+	});
+	try {
+		await client.request("turn/steer", {
+			threadId: active.threadId,
+			expectedTurnId: active.turnId,
+			input: [{
+				type: "text",
+				text,
+				text_elements: []
+			}]
+		}, { timeoutMs: runtime.requestTimeoutMs });
+	} finally {
+		if (!active.client) releaseLeasedSharedCodexAppServerClient(client);
+	}
+	return {
+		steered: true,
+		message: "Sent steer message to Codex."
+	};
+}
+async function setCodexConversationModel(params) {
+	const model = params.model.trim();
+	if (!model) return "Usage: /codex model <model>";
+	const lookup = buildBindingLookup(params);
+	const binding = await requireThreadBinding(params.bindingStore, params.identity);
+	if (binding.connectionScope === "supervision") throw new ModelSelectionLockedError();
+	const modelSelection = resolveCodexAppServerRequestModelSelection({
+		model,
+		modelProvider: resolveConversationControlModelProvider({
+			authProfileId: binding.authProfileId,
+			bindingModel: binding.model,
+			bindingModelProvider: binding.modelProvider,
+			currentModel: model,
+			...lookup
+		}),
+		authProfileId: binding.authProfileId,
+		...lookup
+	});
+	const nextModelProvider = normalizeCodexAppServerBindingModelProvider({
+		authProfileId: binding.authProfileId,
+		modelProvider: modelSelection.modelProvider,
+		...lookup
+	});
+	const nextModel = modelSelection.model;
+	const modelChanged = nextModel !== binding.model || nextModelProvider !== binding.modelProvider;
+	const session = params.session ?? (params.identity.kind === "session" && params.identity.sessionKey ? {
+		agentId: params.identity.agentId,
+		sessionId: params.identity.sessionId,
+		sessionKey: params.identity.sessionKey
+	} : void 0);
+	if (session) {
+		if (!await patchSessionEntry({
+			agentId: session.agentId,
+			storePath: resolveStorePath(params.config?.session?.store, { agentId: session.agentId }),
+			sessionKey: session.sessionKey,
+			requireWriteSuccess: true,
+			replaceEntry: true,
+			update: (entry) => {
+				if (entry.sessionId !== session.sessionId) throw new Error("Codex session changed while applying the model selection.");
+				applyModelOverrideWithAuthProfileCompatibility({
+					cfg: params.config ?? {},
+					agentDir: params.agentDir ?? resolveAgentDir(params.config ?? {}, session.agentId),
+					entry,
+					currentProvider: binding.modelProvider ?? "openai",
+					selection: {
+						provider: nextModelProvider ?? "openai",
+						model: nextModel
+					},
+					markLiveSwitchPending: true
+				});
+				return entry;
+			}
+		})) throw new Error("Codex session changed while applying the model selection.");
+		if (params.identity.kind === "conversation") await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, {
+			model: nextModel,
+			modelProvider: nextModelProvider,
+			...modelChanged && binding.contextEngine?.projection ? { contextEngine: {
+				...binding.contextEngine,
+				projection: void 0
+			} } : {}
+		});
+		else if (modelChanged && binding.contextEngine?.projection) await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, { contextEngine: {
+			...binding.contextEngine,
+			projection: void 0
+		} });
+	} else await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, {
+		model: nextModel,
+		modelProvider: nextModelProvider,
+		...modelChanged && binding.contextEngine?.projection ? { contextEngine: {
+			...binding.contextEngine,
+			projection: void 0
+		} } : {}
+	});
+	return `Codex model set to ${formatCodexDisplayText(nextModel)}.`;
+}
+async function setCodexConversationFastMode(params) {
+	const binding = await requireThreadBinding(params.bindingStore, params.identity);
+	if (params.enabled == null) return `Codex fast mode: ${isCodexFastServiceTier(binding.serviceTier) ? "on" : "off"}.`;
+	const serviceTier = params.enabled ? "priority" : "flex";
+	await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, { serviceTier });
+	return `Codex fast mode ${params.enabled ? "enabled" : "disabled"}.`;
+}
+async function setCodexConversationPermissions(params) {
+	const binding = await requireThreadBinding(params.bindingStore, params.identity);
+	if (!params.mode) return `Codex permissions: ${formatPermissionsMode(binding)}.`;
+	const policy = permissionsForMode(params.mode);
+	await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, {
+		approvalPolicy: policy.approvalPolicy,
+		sandbox: policy.sandbox
+	});
+	return `Codex permissions set to ${params.mode === "yolo" ? "full access" : "default"}.`;
+}
+function parseCodexFastModeArg(arg) {
+	const normalized = arg?.trim().toLowerCase();
+	if (!normalized || normalized === "status") return;
+	if (normalized === "on" || normalized === "true" || normalized === "fast") return true;
+	if (normalized === "off" || normalized === "false" || normalized === "flex") return false;
+}
+function parseCodexPermissionsModeArg(arg) {
+	const normalized = arg?.trim().toLowerCase();
+	if (!normalized || normalized === "status") return;
+	if (normalized === "yolo" || normalized === "full" || normalized === "full-access") return "yolo";
+	if (normalized === "default" || normalized === "guardian") return "default";
+}
+function formatPermissionsMode(binding) {
+	return binding.approvalPolicy === "never" && binding.sandbox === "danger-full-access" ? "full access" : "default";
+}
+async function requireThreadBinding(bindingStore, identity) {
+	const binding = await bindingStore.read(identity);
+	if (!binding?.threadId) throw new Error("No Codex thread is attached to this OpenClaw session yet.");
+	return binding;
+}
+async function patchThreadBinding(bindingStore, identity, threadId, patch) {
+	if (!await bindingStore.mutate(identity, {
+		kind: "patch",
+		threadId,
+		patch
+	})) throw new Error("Codex thread binding changed while applying the control update.");
+}
+function buildBindingLookup(params) {
+	const agentDir = params.agentDir?.trim();
+	return {
+		...agentDir ? { agentDir } : {},
+		...params.config ? { config: params.config } : {}
+	};
+}
+function resolveConversationControlModelProvider(params) {
+	const modelProvider = resolveCodexBindingModelProviderFallback({
+		currentModel: params.currentModel,
+		bindingModel: params.bindingModel,
+		bindingModelProvider: params.bindingModelProvider
+	})?.trim();
+	if (!modelProvider || modelProvider.toLowerCase() === "codex") return;
+	if (isCodexAppServerNativeAuthProfile(params) && modelProvider.toLowerCase() === "openai") return;
+	return modelProvider.toLowerCase() === "openai" ? "openai" : modelProvider;
+}
+function permissionsForMode(mode) {
+	return mode === "yolo" ? {
+		approvalPolicy: "never",
+		sandbox: "danger-full-access"
+	} : {
+		approvalPolicy: "on-request",
+		sandbox: "workspace-write"
+	};
+}
+//#endregion
+//#region extensions/codex/src/plugin-marketplace-discovery.ts
+/** Read-only discovery of Codex-owned local, curated, and remote plugin marketplaces. */
+const PLUGIN_SEGMENT_PATTERN = /^[A-Za-z0-9_-]+$/;
+const MAX_PLUGIN_DESCRIPTION_LENGTH = 160;
+const SUPPLEMENTAL_MARKETPLACE_KINDS = [
+	"workspace-directory",
+	"shared-with-me",
+	"created-by-me-remote",
+	"vertical"
+];
+/** Validates the same identifier segments required by Codex's stable PluginId parser. */
+function parseCodexPluginMarketplaceId(value) {
+	const separator = value.lastIndexOf("@");
+	if (separator <= 0 || separator === value.length - 1) return;
+	const pluginName = value.slice(0, separator);
+	const marketplaceName = value.slice(separator + 1);
+	return PLUGIN_SEGMENT_PATTERN.test(pluginName) && PLUGIN_SEGMENT_PATTERN.test(marketplaceName) ? {
+		pluginName,
+		marketplaceName
+	} : void 0;
+}
+/** Lists local/global first and separately requests workspace, shared, and personal catalogs. */
+async function discoverCodexMarketplacePlugins(params) {
+	const requestParams = { cwds: [params.workspaceDir] };
+	const primary = await params.request(requestParams);
+	const warnings = (primary.marketplaceLoadErrors ?? []).map((error) => boundedCatalogText(error.message));
+	const marketplaces = [...primary.marketplaces];
+	try {
+		const supplemental = await params.request({
+			...requestParams,
+			marketplaceKinds: [...SUPPLEMENTAL_MARKETPLACE_KINDS]
+		});
+		marketplaces.push(...supplemental.marketplaces);
+		warnings.push(...(supplemental.marketplaceLoadErrors ?? []).map((error) => boundedCatalogText(error.message)));
+	} catch (error) {
+		let recoveredSupplementalMarketplace = false;
+		for (const kind of SUPPLEMENTAL_MARKETPLACE_KINDS) try {
+			const supplemental = await params.request({
+				...requestParams,
+				marketplaceKinds: [kind]
+			});
+			marketplaces.push(...supplemental.marketplaces);
+			recoveredSupplementalMarketplace ||= supplemental.marketplaces.length > 0;
+			warnings.push(...(supplemental.marketplaceLoadErrors ?? []).map((loadError) => boundedCatalogText(loadError.message)));
+		} catch (kindError) {
+			warnings.push(boundedCatalogText(`${kind} marketplace unavailable: ${kindError instanceof Error ? kindError.message : String(kindError)}`));
+		}
+		if (!recoveredSupplementalMarketplace && warnings.length === 0) warnings.push(boundedCatalogText(`Additional marketplaces could not be listed: ${error instanceof Error ? error.message : String(error)}`));
+	}
+	const discovered = /* @__PURE__ */ new Map();
+	const ambiguous = /* @__PURE__ */ new Set();
+	for (const marketplace of marketplaces) {
+		if (!PLUGIN_SEGMENT_PATTERN.test(marketplace.name)) continue;
+		for (const summary of marketplace.plugins) {
+			const pluginName = pluginSlug(summary, marketplace.name);
+			if (!pluginName) continue;
+			const id = `${pluginName}@${marketplace.name}`;
+			if (ambiguous.has(id)) continue;
+			const previous = discovered.get(id);
+			const next = {
+				id,
+				pluginName,
+				marketplaceName: marketplace.name,
+				installed: summary.installed,
+				enabled: summary.enabled,
+				available: summary.availability !== "DISABLED_BY_ADMIN" && summary.installPolicy !== "NOT_AVAILABLE",
+				...summary.installPolicy ? { installPolicy: summary.installPolicy } : {},
+				...summary.authPolicy ? { authPolicy: summary.authPolicy } : {},
+				...marketplace.path ? { marketplacePath: marketplace.path } : {},
+				...summary.remotePluginId?.trim() ? {
+					remotePluginId: summary.remotePluginId.trim(),
+					mustShowInstallationInterstitial: summary.mustShowInstallationInterstitial ?? null
+				} : {},
+				summaryId: summary.id
+			};
+			const description = pluginDescription(summary);
+			if (description) next.description = description;
+			if (previous && (previous.marketplacePath !== next.marketplacePath || previous.remotePluginId !== next.remotePluginId)) {
+				discovered.delete(id);
+				ambiguous.add(id);
+				warnings.push(`Multiple discovered plugins share ${id}; installation requires a unique identity.`);
+				continue;
+			}
+			if (!previous) discovered.set(id, next);
+			else {
+				const preferred = !previous.installed && next.installed || !previous.enabled && next.installed && next.enabled ? next : previous;
+				discovered.set(id, {
+					...preferred,
+					available: previous.available && next.available,
+					...preferred.remotePluginId ? { mustShowInstallationInterstitial: previous.mustShowInstallationInterstitial === true || next.mustShowInstallationInterstitial === true ? true : previous.mustShowInstallationInterstitial === false && next.mustShowInstallationInterstitial === false ? false : null } : {},
+					...previous.installPolicy === "NOT_AVAILABLE" || next.installPolicy === "NOT_AVAILABLE" ? { installPolicy: "NOT_AVAILABLE" } : {}
+				});
+			}
+		}
+	}
+	return {
+		plugins: [...discovered.values()].toSorted((left, right) => left.id.localeCompare(right.id)),
+		warnings
+	};
+}
+function pluginSlug(summary, marketplaceName) {
+	const qualified = parseCodexPluginMarketplaceId(summary.id);
+	if (qualified?.marketplaceName === marketplaceName) return qualified.pluginName;
+	const identitySegment = summary.id.split("/").at(-1);
+	if (identitySegment && PLUGIN_SEGMENT_PATTERN.test(identitySegment)) return identitySegment;
+	return PLUGIN_SEGMENT_PATTERN.test(summary.name) ? summary.name : void 0;
+}
+function pluginDescription(summary) {
+	const description = asOptionalRecord(summary.interface)?.shortDescription;
+	if (typeof description !== "string") return;
+	return boundedCatalogText(description) || void 0;
+}
+function boundedCatalogText(value) {
+	let sanitized = "";
+	for (const character of value) {
+		const codePoint = character.codePointAt(0);
+		sanitized += codePoint !== void 0 && (codePoint <= 31 || codePoint >= 127 && codePoint <= 159) ? " " : character;
+	}
+	return sanitized.replace(/\s+/g, " ").trim().slice(0, MAX_PLUGIN_DESCRIPTION_LENGTH);
+}
+//#endregion
+export { parseCodexPermissionsModeArg as a, setCodexConversationModel as c, stopCodexConversationTurn as d, trackCodexConversationActiveTurn as f, parseCodexFastModeArg as i, setCodexConversationPermissions as l, canMutateCodexHost as m, parseCodexPluginMarketplaceId as n, readCodexConversationActiveTurn as o, CODEX_NATIVE_EXECUTION_AUTH_ERROR as p, formatPermissionsMode as r, setCodexConversationFastMode as s, discoverCodexMarketplacePlugins as t, steerCodexConversationTurn as u };

package/dist/{computer-use-CYEc8U3w.js → plugin-metadata-cache-CNJPj4_b.js}

@@ -1,7 +1,7 @@
-import { C as isCodexAppServerIndeterminateRequestCancellationError, G as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, S as isCodexAppServerConnectionClosedError, _ as acquireCodexNativeConfigFence, a as getLeasedSharedCodexAppServerClient, l as releaseLeasedSharedCodexAppServerClient, u as resolveCodexNativeConfigFenceKey, w as isCodexAppServerIndeterminateTransportError } from "./shared-client-DTbvH-XV.js";
-import { g as resolveCodexAppServerRuntimeOptions, v as resolveCodexComputerUseConfig } from "./session-binding-BXpo9ymA.js";
-import { n as describeControlFailure } from "./capabilities-BFDTVYr4.js";
-import { r as requestCodexAppServerJson } from "./request-qKh331yu.js";
+import { g as resolveCodexAppServerRuntimeOptions, v as resolveCodexComputerUseConfig } from "./session-binding-DPxIvMgE.js";
+import { M as isCodexAppServerConnectionClosedError, N as isCodexAppServerIndeterminateRequestCancellationError, P as isCodexAppServerIndeterminateTransportError, a as getLeasedSharedCodexAppServerClient, l as releaseLeasedSharedCodexAppServerClient, lt as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, u as resolveCodexNativeConfigFenceKey, v as acquireCodexNativeConfigFence } from "./shared-client-kIBbGjk4.js";
+import { n as describeControlFailure } from "./capabilities-CybGI1oz.js";
+import { r as requestCodexAppServerJson } from "./request-BRl5_UfX.js";
 import { existsSync } from "node:fs";
 import { runExec } from "openclaw/plugin-sdk/process-runtime";
 //#region extensions/codex/src/app-server/computer-use-process-repair.ts
@@ -690,4 +690,104 @@ function resolveComputerUseConfig(params) {
 	});
 }
 //#endregion
-export { killStaleComputerUseMcpChildren as a, runCodexComputerUseLiveTest as i, installCodexComputerUse as n, readCodexComputerUseStatus as r, ensureCodexComputerUse as t };
+//#region extensions/codex/src/app-server/plugin-metadata-cache.ts
+const CODEX_PLUGIN_METADATA_CACHE_TTL_MS = 3600 * 1e3;
+/** Process-local plugin metadata cache with coalesced loads per query. */
+var CodexPluginMetadataCache = class {
+	constructor(nowMs = Date.now) {
+		this.nowMs = nowMs;
+		this.entries = /* @__PURE__ */ new Map();
+		this.inFlight = /* @__PURE__ */ new Map();
+		this.generations = /* @__PURE__ */ new Map();
+		this.clearGeneration = 0;
+	}
+	/** Returns a fresh cached snapshot without issuing a request. */
+	read(appCacheKey, queryKind, requestParams, catalogScope) {
+		const entryKey = buildMetadataCacheEntryKey(appCacheKey, queryKind, requestParams, catalogScope);
+		const entry = this.entries.get(entryKey);
+		if (!entry) return;
+		if (entry.expiresAtMs <= this.nowMs()) {
+			this.entries.delete(entryKey);
+			return;
+		}
+		return entry.snapshot;
+	}
+	/** Returns a fresh snapshot or coalesces one catalog or installed-plugin request. */
+	async load(params) {
+		const entryKey = buildMetadataCacheEntryKey(params.appCacheKey, params.queryKind, params.requestParams, params.catalogScope);
+		const cached = this.read(params.appCacheKey, params.queryKind, params.requestParams, params.catalogScope);
+		if (cached) return cached;
+		const pending = this.inFlight.get(entryKey);
+		if (pending) try {
+			return await pending.promise;
+		} catch {
+			if (this.inFlight.get(entryKey) === pending) this.inFlight.delete(entryKey);
+			return await this.load(params);
+		}
+		const generation = this.generations.get(params.appCacheKey) ?? 0;
+		const clearGeneration = this.clearGeneration;
+		const promise = (async () => {
+			const method = params.queryKind === "installed" ? "plugin/installed" : "plugin/list";
+			const response = await params.request(method, params.requestParams);
+			const snapshot = {
+				appCacheKey: params.appCacheKey,
+				queryKind: params.queryKind,
+				response
+			};
+			if (generation === (this.generations.get(params.appCacheKey) ?? 0) && clearGeneration === this.clearGeneration && !hasMarketplaceLoadErrors(response) && (params.cacheable?.(response) ?? true)) this.entries.set(entryKey, {
+				snapshot,
+				expiresAtMs: this.nowMs() + CODEX_PLUGIN_METADATA_CACHE_TTL_MS
+			});
+			return snapshot;
+		})();
+		this.inFlight.set(entryKey, {
+			appCacheKey: params.appCacheKey,
+			promise
+		});
+		try {
+			return await promise;
+		} finally {
+			if (this.inFlight.get(entryKey)?.promise === promise) this.inFlight.delete(entryKey);
+		}
+	}
+	/** Invalidates all plugin metadata queries for one app-server runtime. */
+	invalidate(appCacheKey) {
+		this.generations.set(appCacheKey, (this.generations.get(appCacheKey) ?? 0) + 1);
+		for (const [entryKey, entry] of this.entries) if (entry.snapshot.appCacheKey === appCacheKey) this.entries.delete(entryKey);
+		for (const [entryKey, pending] of this.inFlight) if (pending.appCacheKey === appCacheKey) this.inFlight.delete(entryKey);
+	}
+	/** Clears snapshots and prevents late in-flight loads from repopulating them. */
+	clear() {
+		this.clearGeneration += 1;
+		this.generations.clear();
+		this.entries.clear();
+		this.inFlight.clear();
+	}
+};
+/** Shared plugin metadata cache used by Codex app-server runtime paths. */
+const defaultCodexPluginMetadataCache = new CodexPluginMetadataCache();
+function hasMarketplaceLoadErrors(response) {
+	return response.marketplaceLoadErrors.length > 0;
+}
+function buildMetadataCacheEntryKey(appCacheKey, queryKind, requestParams, catalogScope) {
+	if (queryKind !== "installed") {
+		const listParams = requestParams;
+		const entry = [
+			appCacheKey,
+			queryKind,
+			listParams?.cwds ?? [],
+			Array.from(new Set(listParams?.marketplaceKinds ?? [])).toSorted(),
+			...catalogScope ? [catalogScope] : []
+		];
+		return JSON.stringify(entry);
+	}
+	const installedParams = requestParams;
+	return JSON.stringify([
+		appCacheKey,
+		queryKind,
+		installedParams?.cwds ?? [],
+		Array.from(new Set(installedParams?.installSuggestionPluginNames ?? [])).toSorted()
+	]);
+}
+//#endregion
+export { runCodexComputerUseLiveTest as a, readCodexComputerUseStatus as i, ensureCodexComputerUse as n, killStaleComputerUseMcpChildren as o, installCodexComputerUse as r, defaultCodexPluginMetadataCache as t };