@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

package/dist/{plugin-metadata-cache-CNJPj4_b.js → plugin-metadata-cache-CulOABwu.js}

@@ -1,91 +1,11 @@
-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 { P as resolveCodexAppServerHomeDir, i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig } from "./config-Cxw3Cl3k.js";
+import { At as reconcileCodexComputerUseStartArtifacts, G as isCodexAppServerConnectionClosedError, K as isCodexAppServerIndeterminateRequestCancellationError, O as acquireCodexNativeConfigFence, S as waitForCodexAppServerClientDesktopGenerationDrain, Ut as resolveCodexManagedBundledMarketplacePath, Wt as assertNotSymlink, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, p as readCodexAppServerClientProcessIdentity, q as isCodexAppServerIndeterminateTransportError, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-kNkljY-R.js";
+import { l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand } from "./managed-binary-ZkGodW19.js";
+import { i as requestCodexAppServerJson } from "./request-CCm4LaED.js";
+import { n as describeControlFailure } from "./capabilities-CGm_94eL.js";
+import fs from "node:fs/promises";
+import path from "node:path";
 import { existsSync } from "node:fs";
-import { runExec } from "openclaw/plugin-sdk/process-runtime";
-//#region extensions/codex/src/app-server/computer-use-process-repair.ts
-const COMPUTER_USE_PROCESS_LIST_TIMEOUT_MS = 2e3;
-const COMPUTER_USE_PROCESS_LIST_MAX_BUFFER_BYTES = 5 * 1024 * 1024;
-function scopedRepairUnavailableStatus() {
-	return {
-		attempted: false,
-		killedPids: [],
-		warnings: ["Computer Use auto-repair skipped because no scoped Codex app-server process was available."],
-		message: "Computer Use stale child repair requires a scoped local app-server PID."
-	};
-}
-async function killStaleComputerUseMcpChildren(options = {}) {
-	if (process.platform !== "darwin") return {
-		attempted: true,
-		killedPids: [],
-		warnings: [`Computer Use stale child repair is currently macOS-only, not ${process.platform}.`],
-		message: "Computer Use stale child repair skipped on this platform."
-	};
-	if (!options.ancestorPid || !Number.isSafeInteger(options.ancestorPid) || options.ancestorPid <= 0) return scopedRepairUnavailableStatus();
-	let stdout;
-	try {
-		stdout = (await runExec("/bin/ps", ["-axo", "pid=,ppid=,command="], {
-			logOutput: false,
-			maxBuffer: COMPUTER_USE_PROCESS_LIST_MAX_BUFFER_BYTES,
-			timeoutMs: COMPUTER_USE_PROCESS_LIST_TIMEOUT_MS
-		})).stdout;
-	} catch (error) {
-		return {
-			attempted: true,
-			killedPids: [],
-			warnings: [`Could not list processes for Computer Use repair: ${describeControlFailure(error)}`],
-			message: "Computer Use stale child repair could not inspect running processes."
-		};
-	}
-	const killedPids = [];
-	const warnings = [];
-	const processInfos = parsePsOutput(stdout);
-	for (const processInfo of processInfos) {
-		if (!isStaleComputerUseMcpChild(processInfo.command)) continue;
-		if (!isDescendantOfPid(processInfo.pid, options.ancestorPid, processInfos)) continue;
-		try {
-			process.kill(processInfo.pid, "SIGTERM");
-			killedPids.push(processInfo.pid);
-		} catch (error) {
-			warnings.push(`Could not terminate stale Computer Use MCP child pid ${processInfo.pid}: ${describeControlFailure(error)}`);
-		}
-	}
-	return {
-		attempted: true,
-		killedPids,
-		warnings,
-		message: killedPids.length === 0 ? "No stale Computer Use MCP children were found under the scoped Codex app-server process." : `Terminated ${killedPids.length} stale Computer Use MCP child process${killedPids.length === 1 ? "" : "es"} under the scoped Codex app-server process.`
-	};
-}
-function parsePsOutput(stdout) {
-	return stdout.split(/\r?\n/u).flatMap((line) => {
-		const match = /^\s*(\d+)\s+(\d+)\s+(.+)$/u.exec(line);
-		if (!match) return [];
-		return [{
-			pid: Number(match[1]),
-			ppid: Number(match[2]),
-			command: match[3] ?? ""
-		}];
-	}).filter((processInfo) => Number.isSafeInteger(processInfo.pid) && processInfo.pid > 0 && Number.isSafeInteger(processInfo.ppid) && processInfo.ppid >= 0);
-}
-function isStaleComputerUseMcpChild(command) {
-	return command.includes("SkyComputerUseClient") && /(?:^|\s)mcp(?:\s|$)/u.test(command);
-}
-function isDescendantOfPid(pid, ancestorPid, processInfos) {
-	const parents = new Map(processInfos.map((processInfo) => [processInfo.pid, processInfo.ppid]));
-	const seen = /* @__PURE__ */ new Set();
-	let current = pid;
-	while (!seen.has(current)) {
-		seen.add(current);
-		const parent = parents.get(current);
-		if (!parent || parent <= 0) return false;
-		if (parent === ancestorPid) return true;
-		current = parent;
-	}
-	return false;
-}
-//#endregion
 //#region extensions/codex/src/app-server/computer-use.ts
 /**
 * Computer Use plugin/MCP readiness checks and optional install flow for Codex
@@ -99,8 +19,9 @@ var CodexComputerUseSetupError = class extends Error {
 	}
 };
 const CURATED_MARKETPLACE_POLL_INTERVAL_MS = 2e3;
+const BUNDLED_MARKETPLACE_NAME = "openai-bundled";
 const COMPUTER_USE_MARKETPLACE_NAME_PRIORITY = [
-	"openai-bundled",
+	BUNDLED_MARKETPLACE_NAME,
 	"openai-curated",
 	"openai-api-curated",
 	"openai-curated-remote",
@@ -172,71 +93,96 @@ async function installCodexComputerUse(params = {}) {
 }
 async function inspectCodexComputerUse(params) {
 	if (!params.installPlugin) return await inspectCodexComputerUseWithoutFence(params);
-	const runtime = params.client ? void 0 : resolveCodexAppServerRuntimeOptions({
+	const resolvedRuntime = resolveCodexAppServerRuntimeOptions({
 		pluginConfig: params.pluginConfig,
 		managedCommandOrder: "desktop-first"
 	});
-	const fenceKey = resolveCodexNativeConfigFenceKey({
-		client: params.client,
-		startOptions: runtime?.start,
-		agentDir: params.agentDir,
-		config: params.config
-	});
-	if (!fenceKey) return await inspectCodexComputerUseWithoutFence(params);
-	const release = await acquireCodexNativeConfigFence(fenceKey, {
-		signal: params.signal,
-		timeoutMs: params.timeoutMs ?? runtime?.requestTimeoutMs,
-		timeoutMessage: "Codex Computer Use install timed out waiting for native config",
-		abortMessage: "Codex Computer Use install aborted waiting for native config"
-	});
-	let releaseFenceOnReturn = true;
+	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;
 	try {
 		let client = params.client;
 		if (!client && !params.request) {
-			if (!runtime) throw new Error("Computer Use install could not resolve its app-server runtime");
 			client = await getLeasedSharedCodexAppServerClient({
-				startOptions: runtime.start,
+				startOptions: resolvedRuntime.start,
 				pluginConfig: params.pluginConfig,
-				timeoutMs: params.timeoutMs ?? runtime.requestTimeoutMs,
+				timeoutMs: remainingTimeoutMs(),
 				config: params.config,
 				agentDir: params.agentDir,
 				abandonSignal: params.signal
 			});
 			leasedClient = client;
 		}
-		try {
-			return await inspectCodexComputerUseWithoutFence({
-				...params,
-				...client ? {
-					client,
-					timeoutMs: params.timeoutMs ?? runtime?.requestTimeoutMs
-				} : {}
+		const explicitManagedInstall = client && !resolveCodexComputerUseConfig({ pluginConfig: params.pluginConfig }).autoInstall ? await resolveExplicitManagedComputerUseInstallContext({
+			...params,
+			client
+		}) : void 0;
+		if (explicitManagedInstall) {
+			await waitForCodexAppServerClientDesktopGenerationDrain({
+				client: explicitManagedInstall.client,
+				timeoutMs: remainingTimeoutMs(),
+				...params.signal ? { signal: params.signal } : {}
 			});
-		} catch (error) {
-			if (client && (isCodexAppServerIndeterminateRequestCancellationError(error) || isCodexAppServerIndeterminateTransportError(error) || isCodexAppServerConnectionClosedError(error))) {
-				releaseFenceOnReturn = false;
-				await client.closeAndRunAfterExit(release, "Computer Use config mutation");
+			assertCodexAppServerClientStartSelectionCurrent({ client: explicitManagedInstall.client });
+		}
+		const inspectionParams = {
+			...params,
+			...client ? { client } : {},
+			timeoutMs: remainingTimeoutMs(),
+			...explicitManagedInstall ? { explicitManagedInstall } : {}
+		};
+		const fenceKey = resolveCodexNativeConfigFenceKey({
+			client,
+			startOptions: resolvedRuntime.start,
+			agentDir: params.agentDir,
+			config: params.config
+		});
+		if (!fenceKey) return await inspectCodexComputerUseWithoutFence(inspectionParams);
+		const release = await acquireCodexNativeConfigFence(fenceKey, {
+			signal: params.signal,
+			timeoutMs: remainingTimeoutMs(),
+			timeoutMessage: "Codex Computer Use install timed out waiting for native config",
+			abortMessage: "Codex Computer Use install aborted waiting for native config"
+		});
+		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;
 			}
-			throw error;
 		} finally {
-			if (leasedClient) releaseLeasedSharedCodexAppServerClient(leasedClient);
+			if (releaseFenceOnReturn) release();
 		}
 	} finally {
-		if (releaseFenceOnReturn) release();
+		if (leasedClient) releaseLeasedSharedCodexAppServerClient(leasedClient);
 	}
 }
 async function inspectCodexComputerUseWithoutFence(params) {
 	const request = createComputerUseRequest(params);
-	const repairComputerUseMcpChildren = params.repairComputerUseMcpChildren ?? (params.client ? () => killStaleComputerUseMcpChildren({ ancestorPid: params.client?.getTransportPid() }) : void 0);
-	if (params.installPlugin) await request("experimentalFeature/enablement/set", { enablement: { plugins: true } });
+	if (params.installPlugin) {
+		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 managedCodexHome = managedMarketplacePath ? params.client?.getRuntimeIdentity()?.codexHome : void 0;
+	if (params.installPlugin && managedCodexHome) await assertNotSymlink(path.join(managedCodexHome, "config.toml"), "Codex config");
 	const marketplace = await resolveMarketplaceRef({
 		request,
 		config: params.computerUseConfig,
 		allowAdd: params.installPlugin,
 		signal: params.signal,
-		defaultBundledMarketplacePath: params.defaultBundledMarketplacePath,
-		defaultBundledMarketplacePathCandidates: params.defaultBundledMarketplacePathCandidates
+		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.`);
 	const pluginInspection = await ensureComputerUsePlugin({
@@ -251,9 +197,59 @@ async function inspectCodexComputerUseWithoutFence(params) {
 		config: params.computerUseConfig,
 		plugin: pluginInspection.plugin,
 		installPlugin: params.installPlugin,
-		repairComputerUseMcpChildren
+		releaseNativeConfigFence: params.releaseNativeConfigFence
 	});
 }
+async function prepareExplicitManagedComputerUseInstall(params) {
+	const context = params.explicitManagedInstall;
+	if (!context) return;
+	await reconcileCodexComputerUseStartArtifacts({
+		startOptions: {
+			transport: "stdio",
+			command: context.command,
+			commandSource: "resolved-managed",
+			args: ["app-server"],
+			headers: {},
+			env: { CODEX_HOME: context.codexHome }
+		},
+		agentDir: context.agentDir,
+		pluginConfig: { computerUse: {
+			...params.computerUseConfig,
+			autoInstall: true
+		} },
+		ownsIsolatedCodexHome: true,
+		desktopGeneration: context.desktopGeneration,
+		forceCacheRefresh: true,
+		assertCurrent: () => assertCodexAppServerClientStartSelectionCurrent({ client: context.client })
+	});
+}
+async function resolveExplicitManagedComputerUseInstallContext(params) {
+	if (!params.agentDir) return;
+	const codexHome = params.client.getRuntimeIdentity()?.codexHome;
+	const processIdentity = readCodexAppServerClientProcessIdentity(params.client);
+	const command = processIdentity?.nativeCommand ?? (processIdentity && isManagedCodexDesktopCommand(processIdentity.command, "darwin") ? processIdentity.command : void 0);
+	if (!codexHome || !command) return;
+	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.realpath(codexHome).catch(() => void 0), fs.realpath(expectedHome).catch(() => void 0)]);
+	if (!actualRealHome || actualRealHome !== expectedRealHome) return;
+	return {
+		client: params.client,
+		agentDir: params.agentDir,
+		codexHome,
+		command,
+		desktopGeneration
+	};
+}
+async function resolveClientManagedBundledMarketplacePath(client, agentDir) {
+	const codexHome = client?.getRuntimeIdentity()?.codexHome;
+	if (!codexHome || !agentDir) return;
+	const [actualRealHome, expectedRealHome] = await Promise.all([fs.realpath(codexHome).catch(() => void 0), fs.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) {
@@ -315,10 +311,10 @@ async function readComputerUseTools(params) {
 		reason: "ready",
 		message: "Computer Use is ready."
 	});
+	params.releaseNativeConfigFence?.();
 	const { liveTest, repair } = await runCodexComputerUseLiveTest({
 		request: params.request,
-		config: params.config,
-		repairComputerUseMcpChildren: params.repairComputerUseMcpChildren
+		config: params.config
 	});
 	const compatibilityStartupAllowed = !liveTest.ok && !params.config.strictReadiness;
 	return {
@@ -348,8 +344,6 @@ async function runCodexComputerUseLiveTest(params) {
 			threadId = (await params.request("thread/start", {
 				input: [],
 				developerInstructions: COMPUTER_USE_LIVE_TEST_THREAD_NAME,
-				sandbox: "danger-full-access",
-				approvalPolicy: "never",
 				ephemeral: true
 			}, { timeoutMs: params.config.liveTestTimeoutMs })).thread.id;
 			await params.request("mcpServer/tool/call", {
@@ -366,19 +360,19 @@ async function runCodexComputerUseLiveTest(params) {
 					attempts: attempt + 1,
 					timeoutMs: params.config.liveTestTimeoutMs,
 					retried: attempt > 0,
-					repaired: Boolean(repair?.attempted),
+					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;
-			if (attempt >= COMPUTER_USE_LIVE_TEST_RETRY_COUNT) break;
-			if (params.config.autoRepair) repair = params.repairComputerUseMcpChildren ? await params.repairComputerUseMcpChildren() : scopedRepairUnavailableStatus();
 		} 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 {
@@ -389,7 +383,7 @@ async function runCodexComputerUseLiveTest(params) {
 			attempts: 2,
 			timeoutMs: params.config.liveTestTimeoutMs,
 			retried: true,
-			repaired: Boolean(repair?.attempted),
+			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
@@ -397,6 +391,25 @@ async function runCodexComputerUseLiveTest(params) {
 		...repair ? { repair } : {}
 	};
 }
+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 })]);
 }
@@ -417,6 +430,12 @@ async function resolveMarketplaceRef(params) {
 	let candidates = await listComputerUseMarketplaceCandidates(params.request, params.config);
 	const bundledMarketplacePath = resolveBundledComputerUseMarketplacePath(params);
 	if (candidates.length === 0 && bundledMarketplacePath && shouldAddBundledComputerUseMarketplace(params)) {
+		if (params.managedCodexHome) await migrateLegacyBundledMarketplaceSource({
+			request: params.request,
+			bundledMarketplacePath,
+			legacySources: params.defaultBundledMarketplacePathCandidates,
+			userConfigPath: path.join(params.managedCodexHome, "config.toml")
+		});
 		const added = await params.request("marketplace/add", { source: bundledMarketplacePath });
 		preferredMarketplaceName ??= added.marketplaceName;
 		candidates = await listComputerUseMarketplaceCandidates(params.request, params.config);
@@ -441,6 +460,16 @@ async function resolveMarketplaceRef(params) {
 	const marketplace = candidates[0];
 	return marketplace ? { marketplace } : {};
 }
+async function migrateLegacyBundledMarketplaceSource(params) {
+	const response = await params.request("config/read", { includeLayers: false });
+	const bundled = response.config.marketplaces?.[BUNDLED_MARKETPLACE_NAME];
+	const sourceOrigin = response.origins[`marketplaces.${BUNDLED_MARKETPLACE_NAME}.source`];
+	if (bundled?.source_type !== "local" || !bundled.source || sourceOrigin?.name.type !== "user" || sourceOrigin.name.profile !== null || path.resolve(sourceOrigin.name.file) !== path.resolve(params.userConfigPath)) return;
+	const configuredSource = path.resolve(bundled.source);
+	if (configuredSource === path.resolve(params.bundledMarketplacePath)) return;
+	if (!(params.legacySources ?? resolveMacOSDesktopCodexBundledMarketplaceCandidates()).some((source) => path.resolve(source) === configuredSource)) return;
+	await params.request("marketplace/remove", { marketplaceName: BUNDLED_MARKETPLACE_NAME });
+}
 async function listComputerUseMarketplaceCandidates(request, config) {
 	return findComputerUseMarketplaces(await request("plugin/list", { cwds: [] }), config.pluginName);
 }
@@ -453,6 +482,7 @@ function shouldAddBundledComputerUseMarketplace(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) {
@@ -790,4 +820,4 @@ function buildMetadataCacheEntryKey(appCacheKey, queryKind, requestParams, catal
 	]);
 }
 //#endregion
-export { runCodexComputerUseLiveTest as a, readCodexComputerUseStatus as i, ensureCodexComputerUse as n, killStaleComputerUseMcpChildren as o, installCodexComputerUse as r, defaultCodexPluginMetadataCache as t };
+export { runCodexComputerUseLiveTest as a, readCodexComputerUseStatus as i, ensureCodexComputerUse as n, installCodexComputerUse as r, defaultCodexPluginMetadataCache as t };