@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/{plugin-metadata-cache-DsS5buNa.mjs → plugin-metadata-cache-DsjsL1dr.mjs}

@@ -1,20 +1,198 @@
-import { h as resolveCodexAppServerHomeDir } from "./config-security-BRQ2mgW9.mjs";
-import { c as isCodexAppServerIndeterminateTransportError, o as isCodexAppServerConnectionClosedError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-vXs2929Q.mjs";
-import { o as resolveCodexComputerUseConfig } from "./config-options-BsanJ8QG.mjs";
-import { l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand } from "./managed-binary-DP6Rib3P.mjs";
-import { n as describeControlFailure } from "./capabilities-_vXcZGSx.mjs";
-import { i as requestCodexAppServerJson } from "./request-BioXJLYa.mjs";
-import "./config-CedDWjM-.mjs";
-import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-CeAhl_h4.mjs";
-import { $ as assertNotSymlink, D as acquireCodexNativeConfigFence, Q as resolveCodexManagedBundledMarketplacePath, Y as reconcileCodexComputerUseStartArtifacts, b as waitForCodexAppServerClientDesktopGenerationDrain, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, p as readCodexAppServerClientProcessIdentity, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-BpTtuLQ5.mjs";
-import { existsSync } from "node:fs";
+import { t as resolveCodexAppServerHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
+import { o as resolveCodexComputerUseConfig } from "./config-options-CzyWLTJt.mjs";
+import { d as resolveMacOSDesktopCodexBundledMarketplaceCandidates, t as isManagedCodexDesktopCommand } from "./managed-binary-kiWRhNRE.mjs";
+import { n as describeControlFailure } from "./capabilities-B3WEZl4e.mjs";
+import { r as requestCodexAppServerClientJson } from "./request-BHZ1nz8d.mjs";
+import "./config-DKhXquav.mjs";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-C0NbLms1.mjs";
+import { $ as reconcileCodexComputerUseStartArtifacts, O as acquireCodexNativeConfigFence, at as isLegacyCodexComputerUsePluginDisabled, b as withLeasedCodexAppServerClientStartSelectionRetry, c as getLeasedSharedCodexAppServerClient, ct as assertNotSymlink, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, it as hasLegacyCodexComputerUseMcpPolicy, nt as resolveBundledComputerUseMarketplacePath, ot as resolveManagedCodexComputerUseConfig, p as readCodexAppServerClientProcessIdentity, rt as resolveClientManagedBundledMarketplacePath, st as ensureCodexComputerUseSharedPluginCache, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError, y as waitForCodexAppServerClientDesktopGenerationDrain } from "./shared-client-DqyTMYug.mjs";
+import { c as isCodexAppServerIndeterminateTransportError, o as isCodexAppServerConnectionClosedError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-N0JpgSzF.mjs";
+import { r as CodexAppServerUnsafeSubscriptionError, u as retireUnsafeCodexTurnClientBestEffort } from "./attempt-client-cleanup-DOP-cW5j.mjs";
 import path from "node:path";
-import fs$1 from "node:fs/promises";
+import fs from "node:fs/promises";
+import { toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+//#region extensions/codex/src/app-server/computer-use-readiness.ts
+/** Computer Use readiness probes and their native subscription lifecycle. */
+function createComputerUseRequest(params) {
+	const assertCurrent = params.assertCurrent;
+	if (params.request) {
+		const request = params.request;
+		if (!assertCurrent) return request;
+		return async (method, requestParams, options) => {
+			if (method !== "thread/unsubscribe") assertCurrent();
+			return await request(method, requestParams, options);
+		};
+	}
+	const client = params.client;
+	if (!client) throw new Error("Computer Use setup requires an acquired app-server client");
+	return async (method, requestParams, options) => await client.request(method, requestParams, {
+		timeoutMs: options?.timeoutMs ?? params.timeoutMs,
+		signal: options?.signal ?? params.signal,
+		...method === "thread/unsubscribe" ? {} : { assertCurrent }
+	});
+}
+const COMPUTER_USE_LIVE_TEST_RETRY_COUNT = 1;
+const COMPUTER_USE_LIVE_TEST_THREAD_NAME = "OpenClaw Computer Use readiness probe";
+const COMPUTER_USE_LIST_APPS_TOOL = "list_apps";
+const COMPUTER_USE_UNIFIED_JS_TOOL = "js";
+const COMPUTER_USE_UNIFIED_JS_PROBE = "await cua.getState();";
+async function runCodexComputerUseLiveTest(params) {
+	const startedAt = Date.now();
+	let lastError;
+	let repair;
+	const probe = resolveComputerUseLiveTestProbe(params.tools);
+	for (let attempt = 0; attempt <= COMPUTER_USE_LIVE_TEST_RETRY_COUNT; attempt += 1) {
+		let threadId;
+		let outcome;
+		try {
+			threadId = (await params.request("thread/start", {
+				input: [],
+				developerInstructions: COMPUTER_USE_LIVE_TEST_THREAD_NAME,
+				ephemeral: true
+			}, { timeoutMs: params.config.liveTestTimeoutMs })).thread.id;
+			if ((await params.request("mcpServer/tool/call", {
+				threadId,
+				server: params.config.mcpServerName,
+				tool: probe.tool,
+				arguments: probe.arguments
+			}, { timeoutMs: params.config.toolCallTimeoutMs })).isError === true) throw new Error(`Computer Use readiness tool ${params.config.mcpServerName}.${probe.tool} returned an error result`);
+			outcome = {
+				ok: true,
+				liveTest: {
+					status: "passed",
+					ok: true,
+					attempted: true,
+					attempts: attempt + 1,
+					timeoutMs: params.config.liveTestTimeoutMs,
+					retried: attempt > 0,
+					repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
+					durationMs: Math.max(0, Date.now() - startedAt),
+					message: "Computer Use live test passed."
+				}
+			};
+		} catch (error) {
+			outcome = {
+				ok: false,
+				error
+			};
+		}
+		let cleanupError;
+		if (threadId) try {
+			await cleanupComputerUseProbeThread(params, threadId);
+		} catch (error) {
+			cleanupError = toErrorObject(error, "Computer Use readiness cleanup failed");
+		}
+		if (!outcome.ok && (params.signal?.aborted || isCodexAppServerStartSelectionChangedError(outcome.error))) throw toErrorObject(outcome.error, "Computer Use live test failed");
+		if (cleanupError) throw cleanupError;
+		if (outcome.ok) return {
+			liveTest: outcome.liveTest,
+			...repair ? { repair } : {}
+		};
+		lastError = outcome.error;
+		if (attempt < COMPUTER_USE_LIVE_TEST_RETRY_COUNT && params.config.autoRepair) repair = await repairComputerUseMcpRuntime(params.request, params.config);
+	}
+	const errorMessage = describeControlFailure(lastError);
+	return {
+		liveTest: {
+			status: "failed",
+			ok: false,
+			attempted: true,
+			attempts: 2,
+			timeoutMs: params.config.liveTestTimeoutMs,
+			retried: true,
+			repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
+			durationMs: Math.max(0, Date.now() - startedAt),
+			message: `Computer Use live test failed after 2 attempts: ${errorMessage}`,
+			error: errorMessage
+		},
+		...repair ? { repair } : {}
+	};
+}
+function resolveComputerUseLiveTestProbe(tools) {
+	if (tools?.includes(COMPUTER_USE_UNIFIED_JS_TOOL) && !tools.includes(COMPUTER_USE_LIST_APPS_TOOL)) return {
+		tool: COMPUTER_USE_UNIFIED_JS_TOOL,
+		arguments: { code: COMPUTER_USE_UNIFIED_JS_PROBE }
+	};
+	return {
+		tool: COMPUTER_USE_LIST_APPS_TOOL,
+		arguments: {}
+	};
+}
+async function repairComputerUseMcpRuntime(request, config) {
+	try {
+		await request("config/mcpServer/reload", void 0, { timeoutMs: config.liveTestTimeoutMs });
+		return {
+			attempted: true,
+			killedPids: [],
+			warnings: [],
+			message: "Reloaded Computer Use MCP servers through Codex app-server."
+		};
+	} catch (error) {
+		const message = `Could not reload Computer Use MCP servers: ${describeControlFailure(error)}`;
+		return {
+			attempted: true,
+			killedPids: [],
+			warnings: [message],
+			message
+		};
+	}
+}
+async function cleanupComputerUseProbeThread(params, threadId) {
+	try {
+		await params.request("thread/unsubscribe", { threadId }, {
+			timeoutMs: params.config.liveTestTimeoutMs,
+			signal: AbortSignal.timeout(params.config.liveTestTimeoutMs)
+		});
+	} catch (error) {
+		if (params.client) await retireUnsafeCodexTurnClientBestEffort(params.client, "Computer Use readiness cleanup");
+		throw new CodexAppServerUnsafeSubscriptionError("Computer Use readiness cleanup failed", { cause: error });
+	}
+}
+function skippedLiveTestStatus(config, message) {
+	return {
+		status: "skipped",
+		ok: false,
+		attempted: false,
+		attempts: 0,
+		timeoutMs: config.liveTestTimeoutMs,
+		retried: false,
+		repaired: false,
+		message
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/computer-use-status.ts
+function unavailableStatus(config, reason, message) {
+	const disabled = reason === "disabled";
+	return {
+		enabled: !disabled,
+		ready: false,
+		reason,
+		installed: reason === "plugin_disabled" ? null : false,
+		pluginEnabled: false,
+		mcpServerAvailable: false,
+		pluginName: config.pluginName,
+		mcpServerName: config.mcpServerName,
+		...!disabled && config.marketplaceName ? { marketplaceName: config.marketplaceName } : {},
+		...!disabled && config.marketplacePath ? { marketplacePath: config.marketplacePath } : {},
+		tools: [],
+		installation: {
+			status: disabled ? "disabled" : reason === "plugin_disabled" ? "unchecked" : reason === "marketplace_missing" ? "marketplace_missing" : "not_installed",
+			ok: false,
+			message
+		},
+		exposure: {
+			status: "skipped",
+			ok: false,
+			message: disabled ? "MCP exposure was not checked because Computer Use is disabled." : "MCP exposure was not checked because Computer Use installation is not ready."
+		},
+		liveTest: skippedLiveTestStatus(config, disabled ? "Computer Use live test was not run because Computer Use is disabled." : "Computer Use live test was not run because installation is not ready."),
+		warnings: [],
+		message
+	};
+}
+//#endregion
 //#region extensions/codex/src/app-server/computer-use.ts
-/**
-* Computer Use plugin/MCP readiness checks and optional install flow for Codex
-* app-server sessions.
-*/
 var CodexComputerUseSetupError = class extends Error {
 	constructor(status) {
 		super(status.message);
@@ -31,53 +209,50 @@ const COMPUTER_USE_MARKETPLACE_NAME_PRIORITY = [
 	"openai-curated-remote",
 	"local"
 ];
-const COMPUTER_USE_LIVE_TEST_RETRY_COUNT = 1;
-const COMPUTER_USE_LIVE_TEST_THREAD_NAME = "OpenClaw Computer Use readiness probe";
-const COMPUTER_USE_LIST_APPS_TOOL = "list_apps";
-const COMPUTER_USE_UNIFIED_JS_TOOL = "js";
-const COMPUTER_USE_UNIFIED_JS_PROBE = "await cua.getState();";
 /** Reads Computer Use readiness without installing or mutating app-server state. */
 async function readCodexComputerUseStatus(params = {}) {
 	const config = resolveComputerUseConfig(params);
-	if (!config.enabled) return disabledStatus(config);
+	if (!config.enabled) return unavailableStatus(config, "disabled", "Computer Use is disabled.");
 	try {
 		return await inspectCodexComputerUse({
 			...params,
 			computerUseConfig: config,
-			installPlugin: false
+			runLiveTest: true,
+			installMode: "none"
 		});
 	} catch (error) {
 		return unavailableStatus(config, "check_failed", `Computer Use check failed: ${describeControlFailure(error)}`);
 	}
 }
 /**
-* Ensures Computer Use is ready when enabled, optionally installing when config
-* allows safe auto-install.
+* Ensures installation and MCP exposure before a turn, optionally installing when
+* config allows safe auto-install. Only strict startup waits for a live probe.
 */
 async function ensureCodexComputerUse(params = {}) {
 	const config = resolveComputerUseConfig(params);
-	if (!config.enabled) return disabledStatus(config);
+	if (!config.enabled) return unavailableStatus(config, "disabled", "Computer Use is disabled.");
 	const status = await inspectCodexComputerUse({
 		...params,
 		computerUseConfig: config,
-		installPlugin: false
+		runLiveTest: config.strictReadiness,
+		installMode: "none",
+		refreshSharedCache: config.autoInstall
 	});
 	if (status.ready) return status;
-	if (isNonStrictLiveTestStartupAllowed(status, config)) return status;
 	if (config.autoInstall) {
 		const blockedAutoInstallStatus = blockUnsafeAutoInstallStatus(config);
 		if (blockedAutoInstallStatus) throw new CodexComputerUseSetupError(blockedAutoInstallStatus);
 		const installedStatus = await inspectCodexComputerUse({
 			...params,
 			computerUseConfig: config,
-			installPlugin: true
+			runLiveTest: config.strictReadiness,
+			installMode: "automatic",
+			refreshSharedCache: true
 		});
-		if (isNonStrictLiveTestStartupAllowed(installedStatus, config)) return installedStatus;
 		if (!installedStatus.ready) throw new CodexComputerUseSetupError(installedStatus);
 		return installedStatus;
 	}
-	if (!status.ready) throw new CodexComputerUseSetupError(status);
-	return status;
+	throw new CodexComputerUseSetupError(status);
 }
 /** Forces Computer Use plugin installation and returns the ready status. */
 async function installCodexComputerUse(params = {}) {
@@ -93,13 +268,13 @@ async function installCodexComputerUse(params = {}) {
 	const status = await inspectCodexComputerUse({
 		...params,
 		computerUseConfig: config,
-		installPlugin: true
+		runLiveTest: true,
+		installMode: "explicit"
 	});
 	if (!status.ready) throw new CodexComputerUseSetupError(status);
 	return status;
 }
 async function inspectCodexComputerUse(params) {
-	if (!params.installPlugin) return await inspectCodexComputerUseWithoutFence(params);
 	const resolvedRuntime = resolveCodexAppServerRuntimeOptions({
 		pluginConfig: params.pluginConfig,
 		managedCommandOrder: "desktop-first"
@@ -107,19 +282,57 @@ async function inspectCodexComputerUse(params) {
 	const operationTimeoutMs = params.timeoutMs ?? resolvedRuntime.requestTimeoutMs;
 	const deadline = operationTimeoutMs > 0 ? Date.now() + operationTimeoutMs : void 0;
 	const remainingTimeoutMs = () => deadline === void 0 ? operationTimeoutMs : Math.max(1, deadline - Date.now());
-	let leasedClient;
+	const clientOptions = {
+		startOptions: resolvedRuntime.start,
+		pluginConfig: params.pluginConfig,
+		config: params.config,
+		agentDir: params.agentDir,
+		abandonSignal: params.signal,
+		assertCurrent: params.assertCurrent
+	};
+	const lease = {};
 	try {
 		let client = params.client;
 		if (!client && !params.request) {
 			client = await getLeasedSharedCodexAppServerClient({
-				startOptions: resolvedRuntime.start,
-				pluginConfig: params.pluginConfig,
-				timeoutMs: remainingTimeoutMs(),
-				config: params.config,
-				agentDir: params.agentDir,
-				abandonSignal: params.signal
+				...clientOptions,
+				timeoutMs: remainingTimeoutMs()
+			});
+			lease.client = client;
+		}
+		if (params.installMode === "none" && !params.refreshSharedCache) {
+			if (!lease.client) return await inspectCodexComputerUseWithoutFence(params);
+			return await withLeasedCodexAppServerClientStartSelectionRetry({
+				lease,
+				options: {
+					...clientOptions,
+					timeoutMs: remainingTimeoutMs()
+				},
+				signal: params.signal,
+				run: async (readClient, requestOptions) => {
+					const { assertCurrent } = requestOptions();
+					return await inspectCodexComputerUseWithoutFence({
+						...params,
+						client: readClient,
+						request: async (method, requestParams, options) => {
+							const scopedOptions = method === "thread/unsubscribe" ? {
+								timeoutMs: options?.timeoutMs ?? operationTimeoutMs,
+								signal: options?.signal,
+								assertCurrent
+							} : requestOptions();
+							return await requestCodexAppServerClientJson({
+								client: readClient,
+								method,
+								requestParams,
+								config: params.config,
+								timeoutMs: Math.min(options?.timeoutMs ?? operationTimeoutMs, scopedOptions.timeoutMs),
+								signal: scopedOptions.signal,
+								assertCurrent: scopedOptions.assertCurrent
+							});
+						}
+					});
+				}
 			});
-			leasedClient = client;
 		}
 		const explicitManagedInstall = client && !resolveCodexComputerUseConfig({ pluginConfig: params.pluginConfig }).autoInstall ? await resolveExplicitManagedComputerUseInstallContext({
 			...params,
@@ -154,56 +367,78 @@ async function inspectCodexComputerUse(params) {
 		});
 		let releaseFenceOnReturn = true;
 		try {
-			try {
-				return await inspectCodexComputerUseWithoutFence({
-					...inspectionParams,
-					releaseNativeConfigFence: release
-				});
-			} catch (error) {
-				if (client && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error) || isCodexAppServerConnectionClosedError(error))) {
-					releaseFenceOnReturn = false;
-					await client.closeAndRunAfterExit(release, "Computer Use config mutation");
-				}
-				throw error;
+			return await inspectCodexComputerUseWithoutFence({
+				...inspectionParams,
+				releaseNativeConfigFence: release
+			});
+		} catch (error) {
+			if (client && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error) || isCodexAppServerConnectionClosedError(error))) {
+				releaseFenceOnReturn = false;
+				await client.closeAndRunAfterExit(release, "Computer Use config mutation");
 			}
+			throw error;
 		} finally {
 			if (releaseFenceOnReturn) release();
 		}
 	} finally {
-		if (leasedClient) releaseLeasedSharedCodexAppServerClient(leasedClient);
+		if (lease.client) releaseLeasedSharedCodexAppServerClient(lease.client);
 	}
 }
 async function inspectCodexComputerUseWithoutFence(params) {
 	const request = createComputerUseRequest(params);
-	if (params.installPlugin) {
+	if (params.installMode !== "none") {
 		if (!resolveCodexComputerUseConfig({ pluginConfig: params.pluginConfig }).autoInstall) await prepareExplicitManagedComputerUseInstall(params);
-		await request("experimentalFeature/enablement/set", { enablement: { plugins: true } });
 	}
-	const managedMarketplacePath = await resolveClientManagedBundledMarketplacePath(params.client, params.agentDir);
+	const managedMarketplacePath = await resolveClientManagedBundledMarketplacePath(params.client?.getRuntimeIdentity()?.codexHome, params.agentDir);
 	const managedCodexHome = managedMarketplacePath ? params.client?.getRuntimeIdentity()?.codexHome : void 0;
-	if (params.installPlugin && managedCodexHome) await assertNotSymlink(path.join(managedCodexHome, "config.toml"), "Codex config");
+	let computerUseConfig = await resolveManagedCodexComputerUseConfig(params.computerUseConfig, managedMarketplacePath);
+	const nativeDisableStatus = computerUseConfig !== params.computerUseConfig && params.installMode !== "explicit" ? unavailableStatus(params.computerUseConfig, "plugin_disabled", "Computer Use is disabled by native plugin policy. Run /codex computer-use install for explicit recovery, or enable computer-use@openai-bundled in native Codex config for automatic replacement.") : void 0;
+	if (computerUseConfig !== params.computerUseConfig) {
+		const nativeConfig = await request("config/read", { includeLayers: false });
+		if (nativeDisableStatus && isLegacyCodexComputerUsePluginDisabled(nativeConfig.config)) return nativeDisableStatus;
+		if (hasLegacyCodexComputerUseMcpPolicy(nativeConfig.config)) computerUseConfig = params.computerUseConfig;
+	}
+	if (params.installMode !== "none") await request("experimentalFeature/enablement/set", { enablement: { plugins: true } });
+	if (params.installMode !== "none" && managedCodexHome) await assertNotSymlink(path.join(managedCodexHome, "config.toml"), "Codex config");
 	const marketplace = await resolveMarketplaceRef({
 		request,
-		config: params.computerUseConfig,
-		allowAdd: params.installPlugin,
+		config: computerUseConfig,
+		allowAdd: params.installMode !== "none",
 		signal: params.signal,
 		defaultBundledMarketplacePath: params.defaultBundledMarketplacePath ?? managedMarketplacePath,
 		defaultBundledMarketplacePathCandidates: params.defaultBundledMarketplacePathCandidates,
 		managedCodexHome
 	});
-	if (!marketplace.marketplace) return unavailableStatus(params.computerUseConfig, "marketplace_missing", marketplace.message ?? `No Codex marketplace containing ${params.computerUseConfig.pluginName} is registered. Configure computerUse.marketplaceSource or computerUse.marketplacePath, then run /codex computer-use install.`);
+	if (!marketplace.marketplace) return unavailableStatus(computerUseConfig, "marketplace_missing", marketplace.message ?? `No Codex marketplace containing ${computerUseConfig.pluginName} is registered. Configure computerUse.marketplaceSource or computerUse.marketplacePath, then run /codex computer-use install.`);
 	const pluginInspection = await ensureComputerUsePlugin({
 		request,
-		config: params.computerUseConfig,
+		config: computerUseConfig,
 		marketplace: marketplace.marketplace,
-		installPlugin: params.installPlugin
+		nativeDisableStatus,
+		installPlugin: params.installMode !== "none"
 	});
 	if (!pluginInspection.ok) return pluginInspection.status;
+	if (params.refreshSharedCache && computerUseConfig !== params.computerUseConfig && managedCodexHome && managedMarketplacePath && params.agentDir && params.client) {
+		const client = params.client;
+		await ensureCodexComputerUseSharedPluginCache({
+			codexHome: managedCodexHome,
+			ownershipRoot: params.agentDir,
+			bundledMarketplacePath: managedMarketplacePath,
+			config: computerUseConfig,
+			assertCurrent: () => {
+				params.assertCurrent?.();
+				assertCodexAppServerClientStartSelectionCurrent({ client });
+			}
+		});
+	}
 	return await readComputerUseTools({
 		request,
-		config: params.computerUseConfig,
+		client: params.client,
+		signal: params.signal,
+		config: computerUseConfig,
 		plugin: pluginInspection.plugin,
-		installPlugin: params.installPlugin,
+		runLiveTest: params.runLiveTest,
+		installPlugin: params.installMode !== "none",
 		releaseNativeConfigFence: params.releaseNativeConfigFence
 	});
 }
@@ -227,7 +462,10 @@ async function prepareExplicitManagedComputerUseInstall(params) {
 		ownsIsolatedCodexHome: true,
 		desktopGeneration: context.desktopGeneration,
 		forceCacheRefresh: true,
-		assertCurrent: () => assertCodexAppServerClientStartSelectionCurrent({ client: context.client })
+		assertCurrent: () => {
+			params.assertCurrent?.();
+			assertCodexAppServerClientStartSelectionCurrent({ client: context.client });
+		}
 	});
 }
 async function resolveExplicitManagedComputerUseInstallContext(params) {
@@ -239,7 +477,7 @@ async function resolveExplicitManagedComputerUseInstallContext(params) {
 	const desktopGeneration = readCodexAppServerClientDesktopGeneration(params.client);
 	if (!desktopGeneration) throw new Error("Codex Computer Use install requires a desktop-generation-bound client; reconnect and retry.");
 	const expectedHome = resolveCodexAppServerHomeDir(params.agentDir);
-	const [actualRealHome, expectedRealHome] = await Promise.all([fs$1.realpath(codexHome).catch(() => void 0), fs$1.realpath(expectedHome).catch(() => void 0)]);
+	const [actualRealHome, expectedRealHome] = await Promise.all([fs.realpath(codexHome).catch(() => void 0), fs.realpath(expectedHome).catch(() => void 0)]);
 	if (!actualRealHome || actualRealHome !== expectedRealHome) return;
 	return {
 		client: params.client,
@@ -249,29 +487,18 @@ async function resolveExplicitManagedComputerUseInstallContext(params) {
 		desktopGeneration
 	};
 }
-async function resolveClientManagedBundledMarketplacePath(client, agentDir) {
-	const codexHome = client?.getRuntimeIdentity()?.codexHome;
-	if (!codexHome || !agentDir) return;
-	const [actualRealHome, expectedRealHome] = await Promise.all([fs$1.realpath(codexHome).catch(() => void 0), fs$1.realpath(resolveCodexAppServerHomeDir(agentDir)).catch(() => void 0)]);
-	if (!actualRealHome || actualRealHome !== expectedRealHome) return;
-	const managedPath = resolveCodexManagedBundledMarketplacePath(codexHome);
-	return existsSync(managedPath) ? managedPath : void 0;
-}
 async function ensureComputerUsePlugin(params) {
 	let plugin = await readComputerUsePlugin(params.request, params.marketplace, params.config.pluginName);
-	if (!plugin.summary.installed || !plugin.summary.enabled) {
-		if (!params.installPlugin) return {
+	if (params.nativeDisableStatus) {
+		const nativeConfig = await params.request("config/read", { includeLayers: false });
+		if (isLegacyCodexComputerUsePluginDisabled(nativeConfig.config)) return {
 			ok: false,
-			status: statusFromPlugin({
-				config: params.config,
-				plugin,
-				tools: [],
-				reason: pluginSetupReason(plugin),
-				message: pluginSetupMessage(params.config, plugin)
-			})
+			status: params.nativeDisableStatus
 		};
+	}
+	if (params.installPlugin && (!plugin.summary.installed || !plugin.summary.enabled)) {
 		await params.request("plugin/install", pluginRequestParams(params.marketplace, params.config.pluginName));
-		await reloadMcpServers(params.request);
+		await params.request("config/mcpServer/reload", void 0);
 		plugin = await readComputerUsePlugin(params.request, params.marketplace, params.config.pluginName);
 	}
 	if (!plugin.summary.installed || !plugin.summary.enabled) return {
@@ -280,8 +507,8 @@ async function ensureComputerUsePlugin(params) {
 			config: params.config,
 			plugin,
 			tools: [],
-			reason: pluginSetupReason(plugin),
-			message: pluginSetupMessage(params.config, plugin)
+			reason: plugin.summary.installed ? "plugin_disabled" : "plugin_not_installed",
+			message: plugin.summary.installed ? `Computer Use is installed, but the ${params.config.pluginName} plugin is disabled. Run /codex computer-use install or enable computerUse.autoInstall to re-enable it.` : "Computer Use is available but not installed. Run /codex computer-use install or enable computerUse.autoInstall."
 		})
 	};
 	return {
@@ -293,7 +520,7 @@ async function readComputerUseTools(params) {
 	let server = await readMcpServerStatus(params.request, params.config.mcpServerName);
 	let tools = Object.keys(server?.tools ?? {}).toSorted();
 	if ((!server || tools.length === 0) && params.installPlugin) {
-		await reloadMcpServers(params.request);
+		await params.request("config/mcpServer/reload", void 0);
 		server = await readMcpServerStatus(params.request, params.config.mcpServerName);
 		tools = Object.keys(server?.tools ?? {}).toSorted();
 	}
@@ -318,9 +545,12 @@ async function readComputerUseTools(params) {
 		reason: "ready",
 		message: "Computer Use is ready."
 	});
+	if (!params.runLiveTest) return status;
 	params.releaseNativeConfigFence?.();
 	const { liveTest, repair } = await runCodexComputerUseLiveTest({
 		request: params.request,
+		client: params.client,
+		signal: params.signal,
 		config: params.config,
 		tools
 	});
@@ -339,99 +569,6 @@ async function readComputerUseTools(params) {
 		message: liveTest.ok ? "Computer Use is ready." : compatibilityStartupAllowed ? `${liveTest.message} Startup is allowed because computerUse.strictReadiness is false.` : liveTest.message
 	};
 }
-function isNonStrictLiveTestStartupAllowed(status, config) {
-	return !config.strictReadiness && status.reason === "live_test_failed" && status.installed && status.pluginEnabled && status.mcpServerAvailable && status.installation.ok && status.exposure.ok;
-}
-async function runCodexComputerUseLiveTest(params) {
-	const startedAt = Date.now();
-	let lastError;
-	let repair;
-	const probe = resolveComputerUseLiveTestProbe(params.tools);
-	for (let attempt = 0; attempt <= COMPUTER_USE_LIVE_TEST_RETRY_COUNT; attempt += 1) {
-		let threadId;
-		try {
-			threadId = (await params.request("thread/start", {
-				input: [],
-				developerInstructions: COMPUTER_USE_LIVE_TEST_THREAD_NAME,
-				ephemeral: true
-			}, { timeoutMs: params.config.liveTestTimeoutMs })).thread.id;
-			if ((await params.request("mcpServer/tool/call", {
-				threadId,
-				server: params.config.mcpServerName,
-				tool: probe.tool,
-				arguments: probe.arguments
-			}, { timeoutMs: params.config.toolCallTimeoutMs })).isError === true) throw new Error(`Computer Use readiness tool ${params.config.mcpServerName}.${probe.tool} returned an error result`);
-			return {
-				liveTest: {
-					status: "passed",
-					ok: true,
-					attempted: true,
-					attempts: attempt + 1,
-					timeoutMs: params.config.liveTestTimeoutMs,
-					retried: attempt > 0,
-					repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
-					durationMs: Math.max(0, Date.now() - startedAt),
-					message: "Computer Use live test passed."
-				},
-				...repair ? { repair } : {}
-			};
-		} catch (error) {
-			if (isCodexAppServerStartSelectionChangedError(error)) throw error;
-			lastError = error;
-		} finally {
-			if (threadId) await cleanupComputerUseProbeThread(params.request, threadId, params.config);
-		}
-		if (attempt < COMPUTER_USE_LIVE_TEST_RETRY_COUNT && params.config.autoRepair) repair = await repairComputerUseMcpRuntime(params.request, params.config);
-	}
-	const errorMessage = describeControlFailure(lastError);
-	return {
-		liveTest: {
-			status: "failed",
-			ok: false,
-			attempted: true,
-			attempts: 2,
-			timeoutMs: params.config.liveTestTimeoutMs,
-			retried: true,
-			repaired: Boolean(repair?.attempted && repair.warnings.length === 0),
-			durationMs: Math.max(0, Date.now() - startedAt),
-			message: `Computer Use live test failed after 2 attempts: ${errorMessage}`,
-			error: errorMessage
-		},
-		...repair ? { repair } : {}
-	};
-}
-function resolveComputerUseLiveTestProbe(tools) {
-	if (tools?.includes(COMPUTER_USE_UNIFIED_JS_TOOL) && !tools.includes(COMPUTER_USE_LIST_APPS_TOOL)) return {
-		tool: COMPUTER_USE_UNIFIED_JS_TOOL,
-		arguments: { code: COMPUTER_USE_UNIFIED_JS_PROBE }
-	};
-	return {
-		tool: COMPUTER_USE_LIST_APPS_TOOL,
-		arguments: {}
-	};
-}
-async function repairComputerUseMcpRuntime(request, config) {
-	try {
-		await request("config/mcpServer/reload", void 0, { timeoutMs: config.liveTestTimeoutMs });
-		return {
-			attempted: true,
-			killedPids: [],
-			warnings: [],
-			message: "Reloaded Computer Use MCP servers through Codex app-server."
-		};
-	} catch (error) {
-		const message = `Could not reload Computer Use MCP servers: ${describeControlFailure(error)}`;
-		return {
-			attempted: true,
-			killedPids: [],
-			warnings: [message],
-			message
-		};
-	}
-}
-async function cleanupComputerUseProbeThread(request, threadId, config) {
-	await Promise.allSettled([request("thread/unsubscribe", { threadId }, { timeoutMs: config.liveTestTimeoutMs }), request("thread/archive", { threadId }, { timeoutMs: config.liveTestTimeoutMs })]);
-}
 async function resolveMarketplaceRef(params) {
 	let preferredMarketplaceName = params.config.marketplaceName;
 	if (params.config.marketplaceSource && params.allowAdd) {
@@ -503,11 +640,6 @@ function blockUnsafeAutoInstallStatus(config) {
 function shouldAddBundledComputerUseMarketplace(params) {
 	return params.allowAdd && !params.config.marketplaceSource && !params.config.marketplacePath && !params.config.marketplaceName && Boolean(resolveBundledComputerUseMarketplacePath(params));
 }
-function resolveBundledComputerUseMarketplacePath(params) {
-	if (params.defaultBundledMarketplacePath) return existsSync(params.defaultBundledMarketplacePath) ? params.defaultBundledMarketplacePath : void 0;
-	if (!params.defaultBundledMarketplacePathCandidates) return;
-	return resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath({ candidates: params.defaultBundledMarketplacePathCandidates });
-}
 function findComputerUseMarketplaces(listed, pluginName) {
 	return listed.marketplaces.flatMap((marketplace) => {
 		const plugin = marketplace.plugins.find((candidate) => candidate.name === pluginName || candidate.id === pluginName || candidate.id === `${pluginName}@${marketplace.name}`);
@@ -572,9 +704,6 @@ async function readMcpServerStatus(request, serverName) {
 		cursor = response.nextCursor;
 	} while (cursor);
 }
-async function reloadMcpServers(request) {
-	await request("config/mcpServer/reload", void 0);
-}
 function pluginRequestParams(marketplace, pluginName) {
 	return marketplace.kind === "local" ? {
 		marketplacePath: marketplace.path,
@@ -584,13 +713,6 @@ function pluginRequestParams(marketplace, pluginName) {
 		pluginName: marketplace.remotePluginId
 	};
 }
-function pluginSetupReason(plugin) {
-	return plugin.summary.installed ? "plugin_disabled" : "plugin_not_installed";
-}
-function pluginSetupMessage(config, plugin) {
-	if (!plugin.summary.installed) return "Computer Use is available but not installed. Run /codex computer-use install or enable computerUse.autoInstall.";
-	return `Computer Use is installed, but the ${config.pluginName} plugin is disabled. Run /codex computer-use install or enable computerUse.autoInstall to re-enable it.`;
-}
 function statusFromPlugin(params) {
 	return {
 		enabled: true,
@@ -607,131 +729,26 @@ function statusFromPlugin(params) {
 		installation: installationStatusFromPlugin(params.plugin, params.message),
 		exposure: exposureStatusFromTools(params.config, params.tools),
 		liveTest: skippedLiveTestStatus(params.config, "Computer Use live test was not run."),
-		warnings: pluginWarnings(params.plugin),
+		warnings: params.plugin.summary.source?.type === "remote" ? ["Computer Use plugin is resolved from a remote marketplace; live local bundles are preferred."] : [],
 		message: params.message
 	};
 }
-function disabledStatus(config) {
-	return {
-		enabled: false,
-		ready: false,
-		reason: "disabled",
-		installed: false,
-		pluginEnabled: false,
-		mcpServerAvailable: false,
-		pluginName: config.pluginName,
-		mcpServerName: config.mcpServerName,
-		tools: [],
-		installation: {
-			status: "disabled",
-			ok: false,
-			message: "Computer Use is disabled."
-		},
-		exposure: {
-			status: "skipped",
-			ok: false,
-			message: "MCP exposure was not checked because Computer Use is disabled."
-		},
-		liveTest: skippedLiveTestStatus(config, "Computer Use live test was not run because Computer Use is disabled."),
-		warnings: [],
-		message: "Computer Use is disabled."
-	};
-}
-function unavailableStatus(config, reason, message) {
-	return {
-		enabled: true,
-		ready: false,
-		reason,
-		installed: false,
-		pluginEnabled: false,
-		mcpServerAvailable: false,
-		pluginName: config.pluginName,
-		mcpServerName: config.mcpServerName,
-		...config.marketplaceName ? { marketplaceName: config.marketplaceName } : {},
-		...config.marketplacePath ? { marketplacePath: config.marketplacePath } : {},
-		tools: [],
-		installation: {
-			status: reason === "marketplace_missing" ? "marketplace_missing" : "not_installed",
-			ok: false,
-			message
-		},
-		exposure: {
-			status: "skipped",
-			ok: false,
-			message: "MCP exposure was not checked because Computer Use installation is not ready."
-		},
-		liveTest: skippedLiveTestStatus(config, "Computer Use live test was not run because installation is not ready."),
-		warnings: [],
-		message
-	};
-}
 function installationStatusFromPlugin(plugin, message) {
-	if (!plugin.summary.installed) return {
-		status: "not_installed",
-		ok: false,
-		message
-	};
-	if (!plugin.summary.enabled) return {
-		status: "installed_disabled",
-		ok: false,
-		message
-	};
+	const installed = plugin.summary.installed && plugin.summary.enabled;
 	return {
-		status: "installed",
-		ok: true,
-		message: "Computer Use plugin is installed and enabled."
+		status: !plugin.summary.installed ? "not_installed" : installed ? "installed" : "installed_disabled",
+		ok: installed,
+		message: installed ? "Computer Use plugin is installed and enabled." : message
 	};
 }
 function exposureStatusFromTools(config, tools) {
-	if (tools.length === 0) return {
-		status: "missing",
-		ok: false,
-		message: `Computer Use MCP server ${config.mcpServerName} is not exposed.`
-	};
+	const available = tools.length > 0;
 	return {
-		status: "available",
-		ok: true,
-		message: `Computer Use MCP server ${config.mcpServerName} exposes ${tools.length} tools.`
+		status: available ? "available" : "missing",
+		ok: available,
+		message: available ? `Computer Use MCP server ${config.mcpServerName} exposes ${tools.length} tools.` : `Computer Use MCP server ${config.mcpServerName} is not exposed.`
 	};
 }
-function skippedLiveTestStatus(config, message) {
-	return {
-		status: "skipped",
-		ok: false,
-		attempted: false,
-		attempts: 0,
-		timeoutMs: config.liveTestTimeoutMs,
-		retried: false,
-		repaired: false,
-		message
-	};
-}
-function pluginWarnings(plugin) {
-	const warnings = [];
-	const source = plugin.summary.source;
-	if (source && typeof source === "object" && "type" in source && source.type === "remote") warnings.push("Computer Use plugin is resolved from a remote marketplace; live local bundles are preferred.");
-	return warnings;
-}
-function createComputerUseRequest(params) {
-	if (params.request) return params.request;
-	if (params.client) return async (method, requestParams, options) => await params.client.request(method, requestParams, {
-		timeoutMs: options?.timeoutMs ?? params.timeoutMs,
-		signal: params.signal
-	});
-	const runtime = resolveCodexAppServerRuntimeOptions({
-		pluginConfig: params.pluginConfig,
-		managedCommandOrder: "desktop-first"
-	});
-	return async (method, requestParams, options) => await requestCodexAppServerJson({
-		method,
-		requestParams,
-		timeoutMs: options?.timeoutMs ?? params.timeoutMs ?? runtime.requestTimeoutMs,
-		pluginConfig: params.pluginConfig,
-		startOptions: runtime.start,
-		config: params.config,
-		agentDir: params.agentDir
-	});
-}
 function resolveComputerUseConfig(params) {
 	const overrides = params.forceEnable ? {
 		...params.overrides,
@@ -745,7 +762,6 @@ function resolveComputerUseConfig(params) {
 //#endregion
 //#region extensions/codex/src/app-server/plugin-metadata-cache.ts
 const CODEX_PLUGIN_METADATA_CACHE_TTL_MS = 36e5;
-/** Process-local plugin metadata cache with coalesced loads per query. */
 var CodexPluginMetadataCache = class {
 	constructor(nowMs = Date.now) {
 		this.nowMs = nowMs;
@@ -754,7 +770,6 @@ var CodexPluginMetadataCache = class {
 		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);
@@ -787,7 +802,7 @@ var CodexPluginMetadataCache = class {
 				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, {
+			if (generation === (this.generations.get(params.appCacheKey) ?? 0) && clearGeneration === this.clearGeneration && response.marketplaceLoadErrors.length === 0 && (params.cacheable?.(response) ?? true)) this.entries.set(entryKey, {
 				snapshot,
 				expiresAtMs: this.nowMs() + CODEX_PLUGIN_METADATA_CACHE_TTL_MS
 			});
@@ -803,7 +818,6 @@ var CodexPluginMetadataCache = class {
 			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);
@@ -817,11 +831,7 @@ var CodexPluginMetadataCache = class {
 		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;
@@ -843,4 +853,4 @@ function buildMetadataCacheEntryKey(appCacheKey, queryKind, requestParams, catal
 	]);
 }
 //#endregion
-export { runCodexComputerUseLiveTest as a, readCodexComputerUseStatus as i, ensureCodexComputerUse as n, installCodexComputerUse as r, defaultCodexPluginMetadataCache as t };
+export { createComputerUseRequest as a, readCodexComputerUseStatus as i, ensureCodexComputerUse as n, runCodexComputerUseLiveTest as o, installCodexComputerUse as r, defaultCodexPluginMetadataCache as t };