@openclaw/codex 2026.5.12 → 2026.5.14-beta.2

package/dist/index.js

@@ -2,12 +2,11 @@ import { createCodexAppServerAgentHarness } from "./harness.js";
 import { o as readCodexPluginConfig, s as resolveCodexAppServerRuntimeOptions, t as CODEX_PLUGINS_MARKETPLACE_NAME } from "./config-0rd3LnKg.js";
 import { buildCodexMediaUnderstandingProvider } from "./media-understanding-provider.js";
 import { buildCodexProvider } from "./provider.js";
-import { r as describeControlFailure, t as requestCodexAppServerJson } from "./request-ohCy5ASa.js";
-import { r as formatCodexDisplayText } from "./command-formatters-Ttwc_kgX.js";
-import { l as resolveCodexAppServerAuthProfileIdForAgent, s as resolveCodexAppServerAuthAccountCacheKey, u as resolveCodexAppServerEnvApiKeyCacheKey } from "./shared-client-Cr6W-a2G.js";
-import { n as handleCodexConversationInboundClaim, t as handleCodexConversationBindingResolved } from "./conversation-binding-CKofEetY.js";
-import { a as defaultCodexAppInventoryCache, n as pluginReadParams, t as ensureCodexPluginActivation } from "./plugin-activation-PXGqUjwY.js";
-import { t as buildCodexPluginAppCacheKey } from "./plugin-app-cache-key-B7eU8fNZ.js";
+import { i as describeControlFailure, n as buildCodexPluginAppCacheKey, t as requestCodexAppServerJson } from "./request-CKYiRqsN.js";
+import { r as formatCodexDisplayText } from "./command-formatters-DRJaVHhN.js";
+import { c as resolveCodexAppServerAuthAccountCacheKey, d as resolveCodexAppServerEnvApiKeyCacheKey, i as getSharedCodexAppServerClient, t as clearSharedCodexAppServerClientAndWait, u as resolveCodexAppServerAuthProfileIdForAgent } from "./shared-client-BwUqd3lh.js";
+import { a as resolveCodexCliSessionForBindingOnNode, c as handleCodexConversationInboundClaim, i as listCodexCliSessionsOnNode, n as createCodexCliSessionNodeInvokePolicies, o as resumeCodexCliSessionOnNode, s as handleCodexConversationBindingResolved, t as createCodexCliSessionNodeHostCommands } from "./node-cli-sessions-CiexDHeV.js";
+import { a as defaultCodexAppInventoryCache, n as pluginReadParams, t as ensureCodexPluginActivation } from "./plugin-activation-aQOmRQwA.js";
 import { resolveLivePluginConfigObject } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import os from "node:os";
@@ -39,7 +38,7 @@ async function handleCodexCommand(ctx, options = {}) {
 	}
 }
 async function loadDefaultCodexSubcommandHandler() {
-	const { handleCodexSubcommand } = await import("./command-handlers-BYf_veEb.js");
+	const { handleCodexSubcommand } = await import("./command-handlers-CXxykxjq.js");
 	return handleCodexSubcommand;
 }
 //#endregion
@@ -124,7 +123,7 @@ async function discoverPluginDirs(codexHome) {
 				manifestPath,
 				sourceKind: "cache",
 				migratable: false,
-				message: "Cached Codex plugin bundle found. Review manually unless the plugin is also installed in the source Codex app-server inventory."
+				message: "Cached Codex plugin bundle found. Review manually unless the plugin is also installed in the source Codex app-server inventory"
 			});
 			return;
 		}
@@ -412,7 +411,7 @@ async function discoverCodexSource(inputOrOptions) {
 	const hooksPath = path.join(codexHome, "hooks", "hooks.json");
 	const codexSkills = await discoverSkillDirs({
 		root: codexSkillsDir,
-		sourceLabel: "Codex CLI skill",
+		sourceLabel: "Codex skill",
 		excludeSystem: true
 	});
 	const personalAgentSkills = await discoverSkillDirs({
@@ -431,13 +430,13 @@ async function discoverCodexSource(inputOrOptions) {
 		id: "archive:config.toml",
 		path: configPath,
 		relativePath: "config.toml",
-		message: "Codex config is archived for manual review; it is not activated automatically."
+		message: "Codex config is archived for manual review; it is not activated automatically"
 	});
 	if (await exists(hooksPath)) archivePaths.push({
 		id: "archive:hooks/hooks.json",
 		path: hooksPath,
 		relativePath: "hooks/hooks.json",
-		message: "Codex native hooks are archived for manual review because they can execute commands."
+		message: "Codex native hooks are archived for manual review because they can execute commands"
 	});
 	const skills = [...codexSkills, ...personalAgentSkills].toSorted((a, b) => a.source.localeCompare(b.source));
 	const high = Boolean(codexSkills.length || plugins.length || archivePaths.length);
@@ -725,12 +724,8 @@ async function buildCodexMigrationPlan(ctx) {
 	}));
 	const warnings = [
 		...items.some((item) => item.status === "conflict") ? ["Conflicts were found. Re-run with --overwrite to replace conflicting migration targets after item-level backups."] : [],
-		...source.plugins.some((plugin) => plugin.migratable) ? ["Codex source-installed openai-curated plugins are planned for native activation; cached plugin bundles remain manual-review only."] : [],
-		...source.plugins.some((plugin) => plugin.migratable && plugin.apps && plugin.apps.length > 0) && !shouldVerifyPluginApps(ctx) ? ["Codex app-backed plugins were planned without source app accessibility verification. Re-run with --verify-plugin-apps to force a fresh source app/list check before planning native plugin activation."] : [],
-		...source.plugins.some((plugin) => plugin.sourceKind === "cache") ? ["Codex cached plugin bundles remain manual-review only."] : [],
 		...source.pluginDiscoveryError ? [`Codex app-server plugin inventory discovery failed: ${source.pluginDiscoveryError}. Cached plugin bundles, if any, are advisory only.`] : [],
-		...source.plugins.some((plugin) => plugin.migrationBlock?.code === "codex_subscription_required") ? [codexPluginMigrationSubscriptionWarning()] : [],
-		...source.archivePaths.length > 0 ? ["Codex config and hook files are archive-only. They are preserved in the migration report, not loaded into OpenClaw automatically."] : []
+		...source.plugins.some((plugin) => plugin.migrationBlock?.code === "codex_subscription_required") ? [codexPluginMigrationSubscriptionWarning()] : []
 	];
 	return {
 		providerId: "codex",
@@ -752,6 +747,11 @@ async function buildCodexMigrationPlan(ctx) {
 //#region extensions/codex/src/migration/apply.ts
 const CODEX_PLUGIN_AUTH_REQUIRED_REASON = "auth_required";
 const CODEX_PLUGIN_NOT_SELECTED_REASON = "not selected for migration";
+const CODEX_CONFIG_PATCH_MODE_RETURN = "return";
+const CODEX_PLUGIN_LOAD_WARNING = "Some Codex plugins could not be migrated. Run `openclaw migrate codex` after onboarding.";
+const TARGET_CODEX_MARKETPLACE_DISCOVERY_POLL_MS = 250;
+const TARGET_CODEX_MARKETPLACE_DISCOVERY_TIMEOUT_MS = 3e4;
+const TARGET_CODEX_MARKETPLACE_DISCOVERY_TIMEOUT_ENV = "OPENCLAW_CODEX_MIGRATION_PLUGIN_LIST_TIMEOUT_MS";
 var CodexPluginConfigConflictError = class extends Error {
 	constructor(reason) {
 		super(reason);
@@ -759,6 +759,26 @@ var CodexPluginConfigConflictError = class extends Error {
 		this.name = "CodexPluginConfigConflictError";
 	}
 };
+function shouldReturnCodexPluginConfigPatch(ctx) {
+	return ctx.providerOptions?.configPatchMode === CODEX_CONFIG_PATCH_MODE_RETURN;
+}
+function prepareTargetCodexAppServer(ctx) {
+	const appServer = resolveTargetCodexAppServer(ctx);
+	const targets = resolveCodexMigrationTargets(ctx);
+	const ready = getSharedCodexAppServerClient({
+		startOptions: appServer.start,
+		timeoutMs: 6e4,
+		agentDir: targets.agentDir,
+		config: ctx.config
+	}).then(() => void 0, () => void 0);
+	return { async dispose() {
+		await ready;
+		await clearSharedCodexAppServerClientAndWait({
+			exitTimeoutMs: 2e3,
+			forceKillDelayMs: 250
+		});
+	} };
+}
 async function applyCodexMigrationPlan(params) {
 	const plan = params.plan ?? await buildCodexMigrationPlan(params.ctx);
 	const reportDir = params.ctx.reportDir ?? path.join(params.ctx.stateDir, "migration", "codex");
@@ -786,6 +806,10 @@ async function applyCodexMigrationPlan(params) {
 		backupPath: params.ctx.backupPath,
 		reportDir
 	};
+	if (items.some(isCodexPluginLoadWarningItem)) {
+		result.warnings = [...new Set([...result.warnings ?? [], CODEX_PLUGIN_LOAD_WARNING])];
+		result.nextSteps = [...new Set([CODEX_PLUGIN_LOAD_WARNING, ...result.nextSteps ?? []])];
+	}
 	await writeMigrationReport(result, { title: "Codex Migration Report" });
 	return result;
 }
@@ -804,14 +828,14 @@ async function applyCodexPluginInstallItem(ctx, item) {
 		const result = await ensureCodexPluginActivation({
 			identity: policy,
 			installEvenIfActive: true,
-			request: async (method, requestParams) => await requestCodexAppServerJson({
+			request: async (method, requestParams) => await requestTargetCodexAppServerJson({
 				method,
 				requestParams,
 				timeoutMs: 6e4,
 				startOptions: appServer.start,
 				agentDir: resolveCodexMigrationTargets(ctx).agentDir,
 				config: ctx.config,
-				isolated: true
+				isolated: false
 			}),
 			appCache: defaultCodexAppInventoryCache,
 			appCacheKey
@@ -839,6 +863,16 @@ async function applyCodexPluginInstallItem(ctx, item) {
 				appsNeedingAuth: sanitizeAppsNeedingAuth(result.installResponse?.appsNeedingAuth ?? [])
 			}
 		};
+		if (result.reason === "plugin_missing" || result.reason === "marketplace_missing") return {
+			...item,
+			status: "warning",
+			reason: result.reason,
+			message: `Codex plugin "${policy.pluginName}" could not be migrated automatically`,
+			details: {
+				...baseDetails,
+				warningReason: CODEX_PLUGIN_LOAD_WARNING
+			}
+		};
 		return {
 			...item,
 			status: "error",
@@ -846,10 +880,22 @@ async function applyCodexPluginInstallItem(ctx, item) {
 			details: baseDetails
 		};
 	} catch (error) {
+		if (isCodexPluginInventoryLoadError(error)) return {
+			...item,
+			status: "warning",
+			reason: "plugin_inventory_unavailable",
+			message: `Codex plugin "${policy.pluginName}" could not be migrated automatically`,
+			details: {
+				...item.details,
+				code: "plugin_inventory_unavailable",
+				warningReason: CODEX_PLUGIN_LOAD_WARNING,
+				diagnostic: formatCodexMigrationError(error)
+			}
+		};
 		return {
 			...item,
 			status: "error",
-			reason: error instanceof Error ? error.message : String(error),
+			reason: formatCodexMigrationError(error),
 			details: {
 				...item.details,
 				code: "plugin_install_failed"
@@ -857,9 +903,51 @@ async function applyCodexPluginInstallItem(ctx, item) {
 		};
 	}
 }
+function isCodexPluginInventoryLoadError(error) {
+	return formatCodexMigrationError(error).includes("codex app-server plugin/list timed out");
+}
+function formatCodexMigrationError(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 function resolveTargetCodexAppServer(ctx) {
 	return resolveCodexAppServerRuntimeOptions({ pluginConfig: readCodexPluginConfig(ctx.config) });
 }
+async function requestTargetCodexAppServerJson(params) {
+	if (params.method !== "plugin/list") return await requestCodexAppServerJson(params);
+	const deadline = Date.now() + params.timeoutMs;
+	const discoveryTimeoutMs = targetCodexMarketplaceDiscoveryTimeoutMs();
+	const discoveryDeadline = Math.min(deadline, Date.now() + discoveryTimeoutMs);
+	let lastResponse;
+	let attempt = 0;
+	do {
+		attempt += 1;
+		const remainingMs = Math.max(1, discoveryDeadline - Date.now());
+		lastResponse = await requestCodexAppServerJson({
+			...params,
+			timeoutMs: remainingMs
+		});
+		if (hasOpenAiCuratedMarketplace(lastResponse)) return lastResponse;
+		if (Date.now() >= discoveryDeadline) return lastResponse;
+		await sleep(Math.min(TARGET_CODEX_MARKETPLACE_DISCOVERY_POLL_MS, discoveryDeadline - Date.now()));
+	} while (Date.now() < discoveryDeadline);
+	return lastResponse;
+}
+function hasOpenAiCuratedMarketplace(response) {
+	if (!response || typeof response !== "object" || !("marketplaces" in response)) return false;
+	const marketplaces = response.marketplaces;
+	return Array.isArray(marketplaces) && marketplaces.some((marketplace) => marketplace && typeof marketplace === "object" && marketplace.name === "openai-curated");
+}
+function targetCodexMarketplaceDiscoveryTimeoutMs() {
+	const configured = Number(process.env[TARGET_CODEX_MARKETPLACE_DISCOVERY_TIMEOUT_ENV]);
+	if (Number.isFinite(configured) && configured >= 0) return configured;
+	return TARGET_CODEX_MARKETPLACE_DISCOVERY_TIMEOUT_MS;
+}
+function isCodexPluginLoadWarningItem(item) {
+	return item.kind === "plugin" && item.action === "install" && item.status === "warning" && item.details?.warningReason === CODEX_PLUGIN_LOAD_WARNING;
+}
+async function sleep(ms) {
+	await new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function buildTargetCodexPluginAppCacheKey(ctx) {
 	const targets = resolveCodexMigrationTargets(ctx);
 	const appServer = resolveTargetCodexAppServer(ctx);
@@ -884,11 +972,23 @@ async function buildTargetCodexPluginAppCacheKey(ctx) {
 async function applyCodexPluginConfigItem(ctx, item, appliedItems) {
 	const entries = appliedItems.map(readAppliedPluginConfigEntry).filter((entry) => entry !== void 0);
 	if (entries.length === 0) return markMigrationItemSkipped(item, "no selected Codex plugins");
+	const returnPatch = shouldReturnCodexPluginConfigPatch(ctx);
 	const configApi = ctx.runtime?.config;
-	if (!configApi?.current || !configApi.mutateConfigFile) return markMigrationItemError(item, "config runtime unavailable");
-	const currentConfig = configApi.current();
+	const currentConfig = returnPatch ? ctx.config : configApi?.current?.();
+	if (!currentConfig) return markMigrationItemError(item, "config runtime unavailable");
 	const value = buildCodexPluginsConfigValue(entries, { config: currentConfig });
 	if (!ctx.overwrite && hasCodexPluginConfigConflict(currentConfig, value)) return markMigrationItemConflict(item, MIGRATION_REASON_TARGET_EXISTS);
+	const migratedItem = {
+		...item,
+		status: "migrated",
+		details: {
+			...item.details,
+			path: [...CODEX_PLUGIN_CONFIG_PATH],
+			value
+		}
+	};
+	if (returnPatch) return migratedItem;
+	if (!configApi?.mutateConfigFile) return markMigrationItemError(item, "config runtime unavailable");
 	try {
 		await configApi.mutateConfigFile({
 			base: "runtime",
@@ -898,15 +998,7 @@ async function applyCodexPluginConfigItem(ctx, item, appliedItems) {
 				writeMigrationConfigPath(draft, CODEX_PLUGIN_CONFIG_PATH, value);
 			}
 		});
-		return {
-			...item,
-			status: "migrated",
-			details: {
-				...item.details,
-				path: [...CODEX_PLUGIN_CONFIG_PATH],
-				value
-			}
-		};
+		return migratedItem;
 	} catch (error) {
 		if (error instanceof CodexPluginConfigConflictError) return markMigrationItemConflict(item, error.reason);
 		return markMigrationItemError(item, error instanceof Error ? error.message : String(error));
@@ -979,6 +1071,9 @@ function buildCodexMigrationProvider(params = {}) {
 			};
 		},
 		plan: buildCodexMigrationPlan,
+		prepareApply(ctx) {
+			return prepareTargetCodexAppServer(ctx);
+		},
 		async apply(ctx, plan) {
 			return await applyCodexMigrationPlan({
 				ctx,
@@ -1000,8 +1095,28 @@ var codex_default = definePluginEntry({
 		api.registerProvider(buildCodexProvider({ pluginConfig: api.pluginConfig }));
 		api.registerMediaUnderstandingProvider(buildCodexMediaUnderstandingProvider({ pluginConfig: api.pluginConfig }));
 		api.registerMigrationProvider(buildCodexMigrationProvider({ runtime: api.runtime }));
-		api.registerCommand(createCodexCommand({ pluginConfig: api.pluginConfig }));
-		api.on("inbound_claim", (event, ctx) => handleCodexConversationInboundClaim(event, ctx, { pluginConfig: resolveCurrentPluginConfig() }));
+		for (const command of createCodexCliSessionNodeHostCommands()) api.registerNodeHostCommand(command);
+		for (const policy of createCodexCliSessionNodeInvokePolicies()) api.registerNodeInvokePolicy(policy);
+		api.registerCommand(createCodexCommand({
+			pluginConfig: api.pluginConfig,
+			deps: {
+				listCodexCliSessionsOnNode: (params) => listCodexCliSessionsOnNode({
+					runtime: api.runtime,
+					...params
+				}),
+				resolveCodexCliSessionForBindingOnNode: (params) => resolveCodexCliSessionForBindingOnNode({
+					runtime: api.runtime,
+					...params
+				})
+			}
+		}));
+		api.on("inbound_claim", (event, ctx) => handleCodexConversationInboundClaim(event, ctx, {
+			pluginConfig: resolveCurrentPluginConfig(),
+			resumeCodexCliSessionOnNode: (params) => resumeCodexCliSessionOnNode({
+				runtime: api.runtime,
+				...params
+			})
+		}));
 		api.onConversationBindingResolved?.(handleCodexConversationBindingResolved);
 	}
 });

package/dist/media-understanding-provider.js

@@ -1,7 +1,7 @@
 import { CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS } from "./provider-catalog.js";
 import { s as resolveCodexAppServerRuntimeOptions } from "./config-0rd3LnKg.js";
 import { i as assertCodexTurnStartResponse, l as readCodexTurnCompletedNotification, o as readCodexErrorNotification, r as assertCodexThreadStartResponse } from "./protocol-validators-CSY0BFBo.js";
-import { i as readModelListResult } from "./models-BmLfrDci.js";
+import { i as readModelListResult } from "./models-GCYf5s8J.js";
 import { t as isJsonObject } from "./protocol-C9UWI98H.js";
 import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
 //#region extensions/codex/media-understanding-provider.ts
@@ -62,7 +62,7 @@ async function runBoundedCodexVisionTurn(params) {
 	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: params.options.pluginConfig });
 	const timeoutMs = Math.max(100, params.timeoutMs);
 	const ownsClient = !params.options.clientFactory;
-	const client = params.options.clientFactory ? await params.options.clientFactory(appServer.start, params.profile) : await import("./shared-client-Cr6W-a2G.js").then((n) => n.i).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
+	const client = params.options.clientFactory ? await params.options.clientFactory(appServer.start, params.profile) : await import("./shared-client-BwUqd3lh.js").then((n) => n.a).then(({ createIsolatedCodexAppServerClient }) => createIsolatedCodexAppServerClient({
 		startOptions: appServer.start,
 		timeoutMs,
 		authProfileId: params.profile

package/dist/{models-BmLfrDci.js → models-GCYf5s8J.js}

@@ -39,7 +39,7 @@ async function listAllCodexAppServerModels(options = {}) {
 async function withCodexAppServerModelClient(options, run) {
 	const timeoutMs = options.timeoutMs ?? 2500;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getSharedCodexAppServerClient } = await import("./shared-client-Cr6W-a2G.js").then((n) => n.i);
+	const { createIsolatedCodexAppServerClient, getSharedCodexAppServerClient } = await import("./shared-client-BwUqd3lh.js").then((n) => n.a);
 	const client = useSharedClient ? await getSharedCodexAppServerClient({
 		startOptions: options.startOptions,
 		timeoutMs,