@openclaw/codex 2026.9.2 → 2026.9.4

package/dist/plugin-marketplace-discovery-P-Vndfqq.js

@@ -0,0 +1,137 @@
+import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-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.";
+const CODEX_HOST_INSPECTION_AUTH_ERROR = "Only an owner or operator.admin can inspect Codex host state.";
+const CODEX_FULL_PERMISSIONS_AUTH_ERROR = "Full Codex permissions require operator.admin. Choose Admin in the Control UI permission picker, or use an admin-authenticated CLI.";
+function hasCodexAdminScope(ctx) {
+	return ctx.gatewayClientScopes?.includes("operator.admin") === true;
+}
+function canMutateCodexHost(ctx) {
+	return ctx.senderIsOwner === true || hasCodexAdminScope(ctx);
+}
+//#endregion
+//#region extensions/codex/src/plugin-marketplace-discovery.ts
+/** Read-only discovery of Codex-owned local, curated, and remote plugin marketplaces. */
+const PLUGIN_NAME_PATTERN = /^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/;
+const MARKETPLACE_NAME_PATTERN = /^[A-Za-z0-9_-]+$/;
+const MAX_PLUGIN_METADATA_LENGTH = 160;
+const SUPPLEMENTAL_MARKETPLACE_KINDS = [
+	"workspace-directory",
+	"shared-with-me",
+	"created-by-me-remote",
+	"vertical"
+];
+function filterCodexMarketplacePlugins(plugins, query, marketplace) {
+	const normalizedQuery = query.trim().toLowerCase();
+	return plugins.filter((plugin) => (!marketplace || plugin.marketplaceName === marketplace) && (!normalizedQuery || `${plugin.id} ${plugin.displayName ?? ""} ${plugin.developerName ?? ""} ${plugin.description ?? ""}`.toLowerCase().includes(normalizedQuery)));
+}
+/** 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_NAME_PATTERN.test(pluginName) && MARKETPLACE_NAME_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 (!MARKETPLACE_NAME_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 pluginInterface = asOptionalRecord(summary.interface);
+			const next = {
+				id,
+				pluginName,
+				marketplaceName: marketplace.name,
+				displayName: boundedCatalogText(pluginInterface?.displayName) || void 0,
+				developerName: boundedCatalogText(pluginInterface?.developerName) || void 0,
+				description: boundedCatalogText(pluginInterface?.shortDescription) || boundedCatalogText(pluginInterface?.longDescription) || void 0,
+				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
+			};
+			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_NAME_PATTERN.test(identitySegment)) return identitySegment;
+	return PLUGIN_NAME_PATTERN.test(summary.name) ? summary.name : void 0;
+}
+function boundedCatalogText(value) {
+	if (typeof value !== "string") return "";
+	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_METADATA_LENGTH);
+}
+//#endregion
+export { CODEX_HOST_INSPECTION_AUTH_ERROR as a, hasCodexAdminScope as c, CODEX_FULL_PERMISSIONS_AUTH_ERROR as i, filterCodexMarketplacePlugins as n, CODEX_NATIVE_EXECUTION_AUTH_ERROR as o, parseCodexPluginMarketplaceId as r, canMutateCodexHost as s, discoverCodexMarketplacePlugins as t };

package/dist/{plugin-metadata-cache-BwCLTY_U.js → plugin-metadata-cache-ClPJpRio.js}

@@ -1,11 +1,15 @@
-import { M as resolveCodexAppServerHomeDir, i as resolveCodexAppServerRuntimeOptions, o as resolveCodexComputerUseConfig } from "./config-CyapYSji.js";
-import { B as isCodexAppServerIndeterminateRequestCancellationError, D as acquireCodexNativeConfigFence, Jt as assertNotSymlink, S as waitForCodexAppServerClientDesktopGenerationDrain, V as isCodexAppServerIndeterminateTransportError, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, p as readCodexAppServerClientProcessIdentity, qt as resolveCodexManagedBundledMarketplacePath, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError, z as isCodexAppServerConnectionClosedError, zt as reconcileCodexComputerUseStartArtifacts } from "./shared-client-CKhX2kFt.js";
-import { c as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand, u as resolveMacOSDesktopCodexBundledMarketplaceCandidates } from "./managed-binary-DcpnJF9x.js";
-import { i as requestCodexAppServerJson } from "./request-C8H22rPi.js";
-import { n as describeControlFailure } from "./capabilities-B1mgvpP8.js";
-import fs from "node:fs/promises";
-import path from "node:path";
+import { o as resolveCodexComputerUseConfig } from "./config-options-CXMq1T-C.js";
+import { s as resolveCodexAppServerHomeDir } from "./protocol-5bh1G-H7.js";
+import { c as isCodexAppServerIndeterminateTransportError, o as isCodexAppServerConnectionClosedError, s as isCodexAppServerIndeterminateRequestCancellationError } from "./client-B57KWPQx.js";
+import { l as resolveMacOSDesktopCodexBundledMarketplaceCandidates, s as resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath, t as isManagedCodexDesktopCommand } from "./managed-binary-D22rNEcR.js";
+import { n as describeControlFailure } from "./capabilities-8vx68WLH.js";
+import { i as requestCodexAppServerJson } from "./request-B7hEkBGq.js";
+import "./config-oIORaQ5T.js";
+import { n as resolveCodexAppServerRuntimeOptions } from "./config-runtime-D0zGNIHu.js";
+import { $ as reconcileCodexComputerUseStartArtifacts, T as acquireCodexNativeConfigFence, b as waitForCodexAppServerClientDesktopGenerationDrain, c as getLeasedSharedCodexAppServerClient, d as readCodexAppServerClientDesktopGeneration, g as resolveCodexNativeConfigFenceKey, h as releaseLeasedSharedCodexAppServerClient, nt as resolveCodexManagedBundledMarketplacePath, p as readCodexAppServerClientProcessIdentity, rt as assertNotSymlink, t as assertCodexAppServerClientStartSelectionCurrent, u as isCodexAppServerStartSelectionChangedError } from "./shared-client-CscigXXL.js";
 import { existsSync } from "node:fs";
+import path from "node:path";
+import fs$1 from "node:fs/promises";
 //#region extensions/codex/src/app-server/computer-use.ts
 /**
 * Computer Use plugin/MCP readiness checks and optional install flow for Codex
@@ -232,7 +236,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.realpath(codexHome).catch(() => void 0), fs.realpath(expectedHome).catch(() => void 0)]);
+	const [actualRealHome, expectedRealHome] = await Promise.all([fs$1.realpath(codexHome).catch(() => void 0), fs$1.realpath(expectedHome).catch(() => void 0)]);
 	if (!actualRealHome || actualRealHome !== expectedRealHome) return;
 	return {
 		client: params.client,
@@ -245,7 +249,7 @@ async function resolveExplicitManagedComputerUseInstallContext(params) {
 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)]);
+	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;
@@ -441,6 +445,7 @@ async function resolveMarketplaceRef(params) {
 		candidates = await listComputerUseMarketplaceCandidates(params.request, params.config);
 	}
 	const waitUntil = marketplaceDiscoveryWaitUntil(params);
+	if (candidates.length === 0 && waitUntil > Date.now() && await codexNativePluginsDisabled(params.request)) return { message: "Codex native plugin support is disabled (features.plugins = false). Enable it in the Codex config, then run /codex computer-use install." };
 	while (candidates.length === 0) {
 		if (Date.now() >= waitUntil) break;
 		await delay(Math.min(CURATED_MARKETPLACE_POLL_INTERVAL_MS, waitUntil - Date.now()), params.signal);
@@ -473,6 +478,9 @@ async function migrateLegacyBundledMarketplaceSource(params) {
 async function listComputerUseMarketplaceCandidates(request, config) {
 	return findComputerUseMarketplaces(await request("plugin/list", { cwds: [] }), config.pluginName);
 }
+async function codexNativePluginsDisabled(request) {
+	return (await request("experimentalFeature/list", {})).data.find(({ name }) => name === "plugins")?.enabled === false;
+}
 function blockUnsafeAutoInstallStatus(config) {
 	if (!config.marketplaceSource) return;
 	return unavailableStatus(config, "auto_install_blocked", "Computer Use auto-install only uses marketplaces Codex app-server has already discovered. Run /codex computer-use install to install from a configured marketplace source.");

package/dist/protocol-5bh1G-H7.js

@@ -0,0 +1,275 @@
+import { i as normalizeCodexServiceTier, m as CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN } from "./config-utils-DujwEnhg.js";
+import { n as normalizeCodexAppServerArgs } from "./launch-args-RXQwn8zV.js";
+import { asNullableRecord, isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { z } from "zod";
+import { buildSecretInputSchema } from "openclaw/plugin-sdk/secret-input";
+import { detectWindowsSpawnCommandInlineArgs } from "openclaw/plugin-sdk/windows-spawn";
+import path from "node:path";
+import { homedir } from "node:os";
+//#region extensions/codex/src/app-server/session-discovery-config.ts
+const codexSessionCatalogHomeSchema = z.union([z.string().trim().min(1), z.object({
+	path: z.string().trim().min(1),
+	label: z.string().trim().min(1).optional()
+}).strict()]);
+const codexSessionCatalogConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	homes: z.array(codexSessionCatalogHomeSchema).optional()
+}).strict();
+const codexDiscoveryConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	timeoutMs: z.number().positive().optional()
+}).strict();
+//#endregion
+//#region extensions/codex/src/app-server/config-parsing.ts
+const DEFAULT_CODEX_COMPUTER_USE_PLUGIN_NAME = "computer-use";
+const DEFAULT_CODEX_COMPUTER_USE_MCP_SERVER_NAME = "computer-use";
+const DEFAULT_CODEX_COMPUTER_USE_MARKETPLACE_DISCOVERY_TIMEOUT_MS = 6e4;
+const DEFAULT_CODEX_COMPUTER_USE_LIVE_TEST_TIMEOUT_MS = 6e4;
+const DEFAULT_CODEX_COMPUTER_USE_TOOL_CALL_TIMEOUT_MS = 6e4;
+const DEFAULT_CODEX_APP_SERVER_NETWORK_PROXY_PROFILE_PREFIX = "openclaw-network";
+const codexAppServerTransportSchema = z.enum([
+	"stdio",
+	"websocket",
+	"unix"
+]);
+const codexAppServerHomeScopeSchema = z.enum(["agent", "user"]);
+const SecretInputSchema = buildSecretInputSchema();
+const codexAppServerPolicyModeSchema = z.enum(["yolo", "guardian"]);
+const codexAppServerApprovalPolicySchema = z.preprocess((value) => value === "on-failure" ? "on-request" : value, z.enum(["never", "on-request"]));
+const codexAppServerSandboxSchema = z.enum([
+	"read-only",
+	"workspace-write",
+	"danger-full-access"
+]);
+const codexAppServerApprovalsReviewerSchema = z.enum([
+	"user",
+	"auto_review",
+	"guardian_subagent"
+]);
+const codexDynamicToolsLoadingSchema = z.enum(["searchable", "direct"]);
+const codexComputerUseHealthIntervalSchema = z.union([
+	z.literal(30),
+	z.literal(60),
+	z.literal(120),
+	z.literal(240)
+]);
+const codexComputerUsePluginCacheModeSchema = z.enum(["shared", "independent"]);
+const codexPluginDestructivePolicySchema = z.union([
+	z.boolean(),
+	z.literal("auto"),
+	z.literal("ask")
+]);
+const codexAppServerServiceTierSchema = z.preprocess((value) => value === null ? null : normalizeCodexServiceTier(value), z.string().trim().min(1).nullable().optional()).optional();
+const codexAppServerExperimentalSchema = z.object({ sandboxExecServer: z.boolean().optional() }).strict();
+const codexAppServerRemoteWorkspaceRootSchema = z.string().trim().min(1);
+const codexAppServerNetworkProxyDomainPermissionSchema = z.enum(["allow", "deny"]);
+const codexAppServerNetworkProxyUnixSocketPermissionSchema = z.enum(["allow", "none"]);
+const codexAppServerNetworkProxySchema = z.object({
+	enabled: z.boolean().optional(),
+	profileName: z.string().trim().min(1).optional(),
+	baseProfile: z.enum(["read-only", "workspace"]).optional(),
+	mode: z.enum(["limited", "full"]).optional(),
+	domains: z.record(z.string(), codexAppServerNetworkProxyDomainPermissionSchema).optional(),
+	unixSockets: z.record(z.string(), codexAppServerNetworkProxyUnixSocketPermissionSchema).optional(),
+	proxyUrl: z.string().trim().min(1).optional(),
+	socksUrl: z.string().trim().min(1).optional(),
+	enableSocks5: z.boolean().optional(),
+	enableSocks5Udp: z.boolean().optional(),
+	allowUpstreamProxy: z.boolean().optional(),
+	allowLocalBinding: z.boolean().optional(),
+	dangerouslyAllowNonLoopbackProxy: z.boolean().optional(),
+	dangerouslyAllowAllUnixSockets: z.boolean().optional()
+}).strict();
+const codexPluginEntryConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	marketplaceName: z.string().regex(CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN).optional(),
+	pluginName: z.string().trim().min(1).optional(),
+	allow_destructive_actions: codexPluginDestructivePolicySchema.optional()
+}).strict();
+const codexPluginsConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	allow_all_plugins: z.boolean().optional(),
+	allow_destructive_actions: codexPluginDestructivePolicySchema.optional(),
+	plugins: z.record(z.string(), codexPluginEntryConfigSchema).optional()
+}).strict();
+const codexSupervisionEndpointSchema = z.union([z.object({
+	id: z.string().optional(),
+	label: z.string().optional(),
+	transport: z.literal("stdio-proxy").optional(),
+	command: z.string().optional(),
+	args: z.array(z.string()).optional(),
+	cwd: z.string().optional()
+}).strict(), z.object({
+	id: z.string().optional(),
+	label: z.string().optional(),
+	transport: z.literal("websocket"),
+	url: z.string(),
+	authTokenEnv: z.string().optional()
+}).strict()]);
+const codexSupervisionConfigSchema = z.object({
+	enabled: z.boolean().optional(),
+	endpoints: z.array(codexSupervisionEndpointSchema).optional(),
+	allowRawTranscripts: z.boolean().optional(),
+	allowWriteControls: z.boolean().optional()
+}).strict();
+const codexPluginConfigSchema = z.object({
+	codexDynamicToolsLoading: codexDynamicToolsLoadingSchema.optional(),
+	codexDynamicToolsExclude: z.array(z.string()).optional(),
+	sessionCatalog: codexSessionCatalogConfigSchema.optional(),
+	discovery: codexDiscoveryConfigSchema.optional(),
+	computerUse: z.object({
+		enabled: z.boolean().optional(),
+		autoInstall: z.boolean().optional(),
+		marketplaceDiscoveryTimeoutMs: z.number().positive().optional(),
+		liveTestTimeoutMs: z.number().positive().optional(),
+		toolCallTimeoutMs: z.number().positive().optional(),
+		healthCheckEnabled: z.boolean().optional(),
+		healthCheckIntervalMinutes: codexComputerUseHealthIntervalSchema.optional(),
+		pluginCacheMode: codexComputerUsePluginCacheModeSchema.optional(),
+		strictReadiness: z.boolean().optional(),
+		autoRepair: z.boolean().optional(),
+		marketplaceSource: z.string().optional(),
+		marketplacePath: z.string().optional(),
+		marketplaceName: z.string().optional(),
+		pluginName: z.string().optional(),
+		mcpServerName: z.string().optional()
+	}).strict().optional(),
+	codexPlugins: z.unknown().optional(),
+	supervision: codexSupervisionConfigSchema.optional(),
+	appServer: z.object({
+		mode: codexAppServerPolicyModeSchema.optional(),
+		transport: codexAppServerTransportSchema.optional(),
+		homeScope: codexAppServerHomeScopeSchema.optional(),
+		command: z.string().optional(),
+		args: z.union([z.array(z.string()), z.string()]).optional(),
+		url: z.string().optional(),
+		authToken: SecretInputSchema.optional(),
+		headers: z.record(z.string(), SecretInputSchema).optional(),
+		clearEnv: z.array(z.string()).optional(),
+		remoteWorkspaceRoot: codexAppServerRemoteWorkspaceRootSchema.optional(),
+		codeModeOnly: z.boolean().optional(),
+		loopDetectionPreToolUseRelay: z.boolean().optional(),
+		requestTimeoutMs: z.number().positive().optional(),
+		approvalPolicy: codexAppServerApprovalPolicySchema.optional(),
+		sandbox: codexAppServerSandboxSchema.optional(),
+		approvalsReviewer: codexAppServerApprovalsReviewerSchema.optional(),
+		serviceTier: codexAppServerServiceTierSchema,
+		networkProxy: codexAppServerNetworkProxySchema.optional(),
+		defaultWorkspaceDir: z.string().optional(),
+		experimental: codexAppServerExperimentalSchema.optional()
+	}).strict().optional()
+}).strict();
+function readCodexPluginConfig(value) {
+	if (asNullableRecord(asNullableRecord(value)?.appServer)?.approvalPolicy === "untrusted") throw new Error("plugins.entries.codex.config.appServer.approvalPolicy=\"untrusted\" is retired; run \"openclaw doctor --fix\" to migrate it to \"on-request\".");
+	const parsed = codexPluginConfigSchema.safeParse(value);
+	if (!parsed.success) return {};
+	const { codexPlugins: rawCodexPlugins, ...config } = parsed.data;
+	const plugins = codexPluginsConfigSchema.safeParse(rawCodexPlugins);
+	if (!plugins.success) return config;
+	return {
+		...config,
+		...plugins.data ? { codexPlugins: plugins.data } : {}
+	};
+}
+function isCodexSandboxExecServerEnabled(pluginConfig, sandbox) {
+	return isCodexRemoteExecPlacementSandbox(sandbox) || readCodexPluginConfig(pluginConfig).appServer?.experimental?.sandboxExecServer === true;
+}
+function isCodexRemoteExecPlacementSandbox(sandbox) {
+	return typeof sandbox === "object" && sandbox !== null && "placementExecutionMode" in sandbox && sandbox.placementExecutionMode === "remote-exec";
+}
+function isCodexPairedNodeRemoteExecPlacementSandbox(sandbox) {
+	return isCodexRemoteExecPlacementSandbox(sandbox) && typeof sandbox === "object" && sandbox !== null && "placementNodeId" in sandbox && typeof sandbox.placementNodeId === "string" && sandbox.placementNodeId.length > 0;
+}
+function assertCodexAppServerCommandHasNoInlineArgs(params) {
+	const inlineArgs = detectWindowsSpawnCommandInlineArgs(params.command);
+	if (!inlineArgs) return;
+	const sourceLabel = params.source === "env" ? "OPENCLAW_CODEX_APP_SERVER_BIN" : "plugins.entries.codex.config.appServer.command";
+	const argsLabel = params.source === "env" ? "OPENCLAW_CODEX_APP_SERVER_ARGS" : "plugins.entries.codex.config.appServer.args";
+	throw new Error(`${sourceLabel} must be only the Codex app-server executable path; "${inlineArgs.executable}" was configured with inline arguments "${inlineArgs.arguments}". Move those arguments to ${argsLabel}, or remove the override to use the managed Codex startup path.`);
+}
+function resolveCodexPluginsPolicy(pluginConfig) {
+	const config = readCodexPluginConfig(pluginConfig).codexPlugins;
+	const configured = config !== void 0;
+	const enabled = config?.enabled === true;
+	const destructivePolicy = resolveCodexPluginDestructivePolicy(config?.allow_destructive_actions ?? true);
+	const pluginPolicies = Object.entries(config?.plugins ?? {}).flatMap(([configKey, entry]) => {
+		if (!isCodexPluginMarketplaceName(entry.marketplaceName) || !entry.pluginName) return [];
+		const entryDestructivePolicy = resolveCodexPluginDestructivePolicy(entry.allow_destructive_actions ?? config?.allow_destructive_actions ?? true);
+		return [{
+			configKey,
+			marketplaceName: entry.marketplaceName,
+			pluginName: entry.pluginName,
+			enabled: enabled && entry.enabled !== false,
+			allowDestructiveActions: entryDestructivePolicy.allowDestructiveActions,
+			destructiveApprovalMode: entryDestructivePolicy.destructiveApprovalMode
+		}];
+	}).toSorted((left, right) => left.configKey.localeCompare(right.configKey));
+	return {
+		configured,
+		enabled,
+		allowAllPlugins: enabled && config?.allow_all_plugins === true,
+		allowDestructiveActions: destructivePolicy.allowDestructiveActions,
+		destructiveApprovalMode: destructivePolicy.destructiveApprovalMode,
+		pluginPolicies
+	};
+}
+function isCodexPluginMarketplaceName(value) {
+	return typeof value === "string" && CODEX_PLUGIN_MARKETPLACE_NAME_PATTERN.test(value);
+}
+function resolveCodexPluginDestructivePolicy(policy) {
+	if (policy === "auto" || policy === "ask") return {
+		allowDestructiveActions: true,
+		destructiveApprovalMode: policy
+	};
+	return {
+		allowDestructiveActions: policy,
+		destructiveApprovalMode: policy ? "allow" : "deny"
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/auth-start-options.ts
+const CODEX_APP_SERVER_HOME_DIRNAME = "codex-home";
+const CODEX_EPHEMERAL_AUTH_STORE_OVERRIDE = "cli_auth_credentials_store=\"ephemeral\"";
+function resolveCodexAppServerHomeDir(agentDir) {
+	return path.join(path.resolve(agentDir), CODEX_APP_SERVER_HOME_DIRNAME);
+}
+/** Resolves the native user Codex home used by Desktop and the CLI. */
+function resolveCodexAppServerUserHomeDir(env = process.env, homedir$1 = homedir) {
+	const configured = normalizeOptionalString(env.CODEX_HOME);
+	return path.resolve(configured ?? path.join(homedir$1(), ".codex"));
+}
+/** Resolves the local CODEX_HOME used when starting one app-server connection. */
+function resolveCodexAppServerLocalHomeDir(startOptions, agentDir, env = process.env) {
+	const configured = startOptions.env?.CODEX_HOME;
+	if (configured?.trim()) return configured;
+	return startOptions.homeScope === "user" ? resolveCodexAppServerUserHomeDir(env) : resolveCodexAppServerHomeDir(agentDir);
+}
+/** Forces OpenClaw-owned Codex auth to remain process-local. */
+function withEphemeralCodexAuthStore(params) {
+	const { startOptions } = params;
+	if (!params.preparedAuth && params.authProfileId === null) return startOptions;
+	const args = normalizeCodexAppServerArgs(startOptions.args, CODEX_EPHEMERAL_AUTH_STORE_OVERRIDE);
+	return args === startOptions.args ? startOptions : {
+		...startOptions,
+		args
+	};
+}
+//#endregion
+//#region extensions/codex/src/app-server/protocol.ts
+/** Namespace Codex keeps directly model-visible without exposing it to Code Mode guests. */
+const CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE = "openclaw_direct";
+function flattenCodexDynamicToolFunctions(tools) {
+	return (tools ?? []).flatMap((tool) => tool.type === "namespace" ? tool.tools : [tool]);
+}
+/** Asserts the experimental beforeTurnId request field before it crosses the app-server boundary. */
+function assertCodexThreadForkParams(value) {
+	if (!isRecord(value) || typeof value.threadId !== "string" || !value.threadId.trim() || value.beforeTurnId !== void 0 && value.beforeTurnId !== null && typeof value.beforeTurnId !== "string") throw new Error("Invalid Codex app-server thread/fork params");
+	return value;
+}
+const CODEX_INTERACTIVE_THREAD_SOURCE_KINDS = ["cli", "vscode"];
+const CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES = ["atlas", "chatgpt"];
+function isJsonObject(value) {
+	return isRecord(value);
+}
+//#endregion
+export { resolveCodexPluginsPolicy as S, assertCodexAppServerCommandHasNoInlineArgs as _, flattenCodexDynamicToolFunctions as a, isCodexSandboxExecServerEnabled as b, resolveCodexAppServerLocalHomeDir as c, DEFAULT_CODEX_APP_SERVER_NETWORK_PROXY_PROFILE_PREFIX as d, DEFAULT_CODEX_COMPUTER_USE_LIVE_TEST_TIMEOUT_MS as f, DEFAULT_CODEX_COMPUTER_USE_TOOL_CALL_TIMEOUT_MS as g, DEFAULT_CODEX_COMPUTER_USE_PLUGIN_NAME as h, assertCodexThreadForkParams as i, resolveCodexAppServerUserHomeDir as l, DEFAULT_CODEX_COMPUTER_USE_MCP_SERVER_NAME as m, CODEX_INTERACTIVE_THREAD_SOURCE_KINDS as n, isJsonObject as o, DEFAULT_CODEX_COMPUTER_USE_MARKETPLACE_DISCOVERY_TIMEOUT_MS as p, CODEX_OPENCLAW_DIRECT_DYNAMIC_TOOL_NAMESPACE as r, resolveCodexAppServerHomeDir as s, CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES as t, withEphemeralCodexAuthStore as u, isCodexPairedNodeRemoteExecPlacementSandbox as v, readCodexPluginConfig as x, isCodexRemoteExecPlacementSandbox as y };

package/dist/provider-MQ8PVkuE.js

@@ -0,0 +1,50 @@
+//#region extensions/codex/src/migration/provider.ts
+function isMemoryOnlyMigration(ctx) {
+	return Boolean(ctx.itemKinds && ctx.itemKinds.length > 0 && ctx.itemKinds.every((kind) => kind === "memory"));
+}
+function isAuthOnlyMigration(ctx) {
+	return Boolean(ctx.itemKinds && ctx.itemKinds.length > 0 && ctx.itemKinds.every((kind) => kind === "auth"));
+}
+function buildCodexMigrationProvider(params = {}) {
+	return {
+		id: "codex",
+		label: "Codex",
+		description: "Import Codex memory and skills while keeping Codex native plugins and hooks explicit.",
+		supportedItemKinds: ["memory", "auth"],
+		async detect(ctx) {
+			const { discoverCodexSource, hasCodexSource } = await import("./source-CElXU0Oy.js").then((n) => n.i);
+			const source = await discoverCodexSource({
+				input: ctx.source,
+				memoryOnly: isMemoryOnlyMigration(ctx),
+				authOnly: isAuthOnlyMigration(ctx)
+			});
+			const found = isMemoryOnlyMigration(ctx) ? source.memoryFiles.length > 0 : isAuthOnlyMigration(ctx) ? Boolean(source.authPath) : hasCodexSource(source);
+			return {
+				found,
+				source: source.root,
+				label: "Codex",
+				confidence: found ? source.confidence : "low",
+				message: found ? "Codex state found." : "Codex state not found."
+			};
+		},
+		async plan(ctx) {
+			const { buildCodexMigrationPlan } = await import("./plan-7uG-Fp36.js");
+			return buildCodexMigrationPlan(ctx);
+		},
+		deferredApply: { retrySafe: true },
+		prepareApply(ctx) {
+			if (isMemoryOnlyMigration(ctx) || isAuthOnlyMigration(ctx)) return;
+			return import("./apply-CvT8tW5i.js").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
+		},
+		async apply(ctx, plan) {
+			const { applyCodexMigrationPlan } = await import("./apply-CvT8tW5i.js");
+			return await applyCodexMigrationPlan({
+				ctx,
+				plan,
+				runtime: params.runtime
+			});
+		}
+	};
+}
+//#endregion
+export { buildCodexMigrationProvider as t };

package/dist/{provider-capabilities-BpG9Ltc5.js → provider-capabilities-BvCUL69A.js}

@@ -1,5 +1,5 @@
-import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-CKhX2kFt.js";
-import { ut as normalizeCodexDynamicToolName } from "./thread-lifecycle-DPK30jad.js";
+import { h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-CscigXXL.js";
+import { ct as normalizeCodexDynamicToolName } from "./thread-lifecycle-DXl1-I6b.js";
 import { pinExecToolTarget } from "openclaw/plugin-sdk/codex-mcp-projection";
 import { loadNodeExecAvailability } from "openclaw/plugin-sdk/node-selection-runtime";
 //#region extensions/codex/src/app-server/shell-dynamic-tools.ts

package/dist/{rate-limits-Fx_l4eNa.js → rate-limits-CBMmWBr9.js}

@@ -1,4 +1,4 @@
-import { B as isJsonObject } from "./config-CyapYSji.js";
+import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
 import { asBoolean, asFiniteNumber, normalizeOptionalString, parseStrictFiniteNumber } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { MAX_DATE_TIMESTAMP_MS, resolveExpiresAtMsFromEpochSeconds } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";