@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

package/dist/node-exec-server.runtime-DXrqpw1c.js

@@ -0,0 +1,195 @@
+import { n as resolveManagedCodexAppServerStartOptions, r as resolveManagedCodexNativeCommand, t as isManagedCodexDesktopCommand } from "./managed-binary-ZkGodW19.js";
+import { i as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-C7-s9TLG.js";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { resolvePreferredOpenClawTmpDir, withTempWorkspace } from "openclaw/plugin-sdk/temp-path";
+import { killProcessTree } from "openclaw/plugin-sdk/process-runtime";
+import { once } from "node:events";
+import { sanitizeEnvVars } from "openclaw/plugin-sdk/sandbox";
+//#region extensions/codex/src/node-exec-server.runtime.ts
+const MAX_CODEX_EXEC_SERVER_MESSAGE_BYTES = 64 * 1024 * 1024;
+const CODEX_EXEC_SERVER_TERMINATION_GRACE_MS = 1e3;
+const CODEX_EXEC_SERVER_REAP_TIMEOUT_MS = 5e3;
+const NODE_EXEC_SERVER_PLATFORM_ENVIRONMENT = /^(?:SYSTEMROOT|WINDIR|COMSPEC|PATHEXT|TEMP|TMP|TMPDIR)$/iu;
+function validateNodeExecServerMessage(message) {
+	if (message.byteLength === 0 || message.byteLength > MAX_CODEX_EXEC_SERVER_MESSAGE_BYTES) throw new Error("Codex exec-server JSON-RPC message exceeds its 64 MiB limit.");
+	const encoded = Buffer.from(message.buffer, message.byteOffset, message.byteLength);
+	if (encoded.includes(10) || encoded.includes(13)) throw new Error("Codex exec-server JSON-RPC frames must contain exactly one message.");
+	let decoded;
+	try {
+		const text = new TextDecoder("utf-8", { fatal: true }).decode(encoded);
+		decoded = JSON.parse(text);
+	} catch {
+		throw new Error("Codex exec-server received malformed UTF-8 or JSON-RPC.");
+	}
+	if (!isRecord(decoded) || decoded.jsonrpc !== void 0 && decoded.jsonrpc !== "2.0" || typeof decoded.method !== "string" && !("id" in decoded && ("result" in decoded || "error" in decoded))) throw new Error("Codex exec-server received an invalid JSON-RPC message.");
+	return encoded;
+}
+function nodeExecServerAbortError(signal) {
+	return signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Codex node exec-server connection closed.");
+}
+function writeNodeExecServerMessage(child, message, signal) {
+	if (signal.aborted) throw nodeExecServerAbortError(signal);
+	const payload = Buffer.concat([message, Buffer.from("\n")]);
+	if (!child.stdin.write(payload)) return once(child.stdin, "drain", { signal }).then(() => void 0);
+}
+async function relayNodeExecServerOutput(child, send) {
+	let fragments = [];
+	let pendingBytes = 0;
+	for await (const rawChunk of child.stdout) {
+		const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk);
+		let offset = 0;
+		while (offset < chunk.byteLength) {
+			const newline = chunk.indexOf(10, offset);
+			const fragment = chunk.subarray(offset, newline === -1 ? chunk.byteLength : newline);
+			const nextLength = pendingBytes + fragment.byteLength;
+			if (nextLength > 67108865) throw new Error("Codex exec-server stdout message exceeds its 64 MiB limit.");
+			if (fragment.byteLength > 0) fragments.push(fragment);
+			pendingBytes = nextLength;
+			if (newline === -1) {
+				if (pendingBytes > MAX_CODEX_EXEC_SERVER_MESSAGE_BYTES && fragment[fragment.byteLength - 1] !== 13) throw new Error("Codex exec-server stdout message exceeds its 64 MiB limit.");
+				break;
+			}
+			const trailing = fragments.at(-1);
+			if (trailing?.[trailing.byteLength - 1] === 13) {
+				pendingBytes -= 1;
+				if (trailing.byteLength === 1) fragments.pop();
+				else fragments[fragments.length - 1] = trailing.subarray(0, trailing.byteLength - 1);
+			}
+			const message = validateNodeExecServerMessage(fragments.length === 1 ? fragments[0] : Buffer.concat(fragments, pendingBytes));
+			fragments = [];
+			pendingBytes = 0;
+			await send(message);
+			offset = newline + 1;
+		}
+	}
+	if (pendingBytes > 0) throw new Error("Codex exec-server stdout ended with an unterminated JSON-RPC message.");
+}
+function createNodeExecServerProcessOwner(child, closed) {
+	let termination;
+	return { terminate: () => termination ??= (async () => {
+		if (process.platform === "win32" && child.pid) killProcessTree(child.pid, { graceMs: CODEX_EXEC_SERVER_TERMINATION_GRACE_MS });
+		if (!await closeCodexAppServerTransportAndWait(child, {
+			forceKillDelayMs: CODEX_EXEC_SERVER_TERMINATION_GRACE_MS,
+			exitTimeoutMs: CODEX_EXEC_SERVER_REAP_TIMEOUT_MS
+		})) throw new Error("Codex node exec-server process tree did not terminate.");
+		await closed;
+	})() };
+}
+/** Runs the one-connection paired-node exec-server after lightweight command admission. */
+async function runCodexNodeExecServer(params) {
+	const { io } = params;
+	const frames = io.frames;
+	if (!frames) throw new Error("Codex node exec-server requires duplex frames.");
+	const cwd = params.workspaceDir;
+	let writes;
+	let rejectDisconnected;
+	const disconnected = new Promise((_resolve, reject) => {
+		rejectDisconnected = reject;
+	});
+	disconnected.catch(() => {});
+	const onAbort = () => {
+		const error = nodeExecServerAbortError(io.signal);
+		rejectDisconnected(error);
+	};
+	io.signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		if (io.signal.aborted) throw nodeExecServerAbortError(io.signal);
+		return await withTempWorkspace({
+			rootDir: resolvePreferredOpenClawTmpDir(),
+			prefix: "codex-node-exec-server-"
+		}, async ({ dir }) => {
+			const codexHome = path.join(dir, ".codex");
+			await mkdir(codexHome, {
+				recursive: true,
+				mode: 448
+			});
+			const resolved = await resolveManagedCodexAppServerStartOptions({
+				transport: "stdio",
+				command: "codex",
+				commandSource: "managed",
+				managedCommandOrder: "package-first",
+				args: [
+					"exec-server",
+					"--listen",
+					"stdio"
+				],
+				headers: {}
+			});
+			const native = resolveManagedCodexNativeCommand(resolved.command);
+			if (!native || isManagedCodexDesktopCommand(resolved.command)) throw new Error("Codex node exec-server requires the pinned managed package binary.");
+			const baseEnv = sanitizeEnvVars(process.env, {
+				strictMode: true,
+				customAllowedPatterns: [NODE_EXEC_SERVER_PLATFORM_ENVIRONMENT]
+			}).allowed;
+			if (io.signal.aborted) throw nodeExecServerAbortError(io.signal);
+			params.assertExecAuthorized();
+			const child = await createStdioTransport({
+				transport: "stdio",
+				command: native,
+				commandSource: "resolved-managed",
+				args: resolved.args,
+				headers: {},
+				cwd,
+				env: {
+					HOME: dir,
+					CODEX_HOME: codexHome,
+					...process.platform === "win32" ? { USERPROFILE: dir } : {}
+				},
+				clearEnv: ["NODE_OPTIONS"]
+			}, baseEnv, () => {
+				if (io.signal.aborted) throw nodeExecServerAbortError(io.signal);
+				params.assertExecAuthorized();
+			});
+			child.stdin.on("error", (error) => {
+				rejectDisconnected(error);
+			});
+			let stderr = Buffer.alloc(0);
+			child.stderr.on("data", (chunk) => {
+				const bounded = (Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)).subarray(-4096);
+				stderr = Buffer.concat([stderr, bounded]).subarray(-4096);
+			});
+			const closed = new Promise((resolve) => {
+				child.once("close", (code, signal) => resolve({
+					code,
+					signal
+				}));
+			});
+			child.once("error", (error) => {
+				rejectDisconnected(error);
+			});
+			const owner = createNodeExecServerProcessOwner(child, closed);
+			params.activeProcesses.add(owner.terminate);
+			const output = relayNodeExecServerOutput(child, frames.send.bind(frames));
+			output.catch((error) => {
+				rejectDisconnected(error instanceof Error ? error : new Error(String(error)));
+			});
+			try {
+				if (io.signal.aborted) throw nodeExecServerAbortError(io.signal);
+				params.onFrameReceiver((message) => {
+					const encoded = validateNodeExecServerMessage(message);
+					const operation = writes ? writes.then(() => writeNodeExecServerMessage(child, encoded, io.signal)) : writeNodeExecServerMessage(child, encoded, io.signal);
+					if (!operation) return;
+					const observed = operation.catch(() => {});
+					writes = observed;
+					observed.then(() => {
+						if (writes === observed) writes = void 0;
+					});
+					return operation;
+				});
+				const outcome = await Promise.race([closed, disconnected]);
+				const diagnostic = stderr.toString("utf8").trim();
+				throw new Error(`Codex node exec-server exited (code ${outcome.code ?? "none"}, signal ${outcome.signal ?? "none"})${diagnostic ? `: ${diagnostic}` : "."}`);
+			} finally {
+				await owner.terminate();
+				params.activeProcesses.delete(owner.terminate);
+				await Promise.allSettled([output, ...writes ? [writes] : []]);
+			}
+		});
+	} finally {
+		io.signal.removeEventListener("abort", onAbort);
+	}
+}
+//#endregion
+export { runCodexNodeExecServer };

package/dist/plugin-approval-roundtrip-D80UZiJ_.js

@@ -0,0 +1,95 @@
+import { F as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-kNkljY-R.js";
+import { isApprovalNotFoundError, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+//#region extensions/codex/src/app-server/plugin-approval-roundtrip.ts
+const DEFAULT_CODEX_APPROVAL_TIMEOUT_MS = 12e4;
+const MAX_PLUGIN_APPROVAL_TITLE_LENGTH = 80;
+const MAX_PLUGIN_APPROVAL_DESCRIPTION_LENGTH = 256;
+const ANSI_OSC_SEQUENCE_RE = new RegExp(String.raw`(?:\u001b]|\u009d)[^\u001b\u009c\u0007]*(?:\u0007|\u001b\\|\u009c)`, "g");
+const ANSI_CONTROL_SEQUENCE_RE = new RegExp(String.raw`(?:\u001b\[[0-?]*[ -/]*[@-~]|\u009b[0-?]*[ -/]*[@-~]|\u001b[@-Z\\-_])`, "g");
+const CONTROL_CHARACTER_RE = new RegExp(String.raw`[\u0000-\u001f\u007f-\u009f]+`, "g");
+const INVISIBLE_FORMATTING_CONTROL_RE = new RegExp(String.raw`[\u00ad\u034f\u061c\u200b-\u200f\u202a-\u202e\u2060-\u206f\ufeff\ufe00-\ufe0f\u{e0100}-\u{e01ef}]`, "gu");
+const DANGLING_TERMINAL_SEQUENCE_SUFFIX_RE = new RegExp(String.raw`(?:\u001b\][^\u001b\u009c\u0007]*|\u009d[^\u001b\u009c\u0007]*|\u001b\[[0-?]*[ -/]*|\u009b[0-?]*[ -/]*|\u001b)$`);
+const CODEX_APPROVAL_TIMEOUT_SUBJECTS = {
+	command: "Command approval",
+	"file-change": "File change approval",
+	permissions: "Permission approval",
+	other: "Approval"
+};
+function codexApprovalTimeoutText(kind) {
+	return `${CODEX_APPROVAL_TIMEOUT_SUBJECTS[kind]} timed out before an operator responded.`;
+}
+/** Starts a two-phase plugin approval request through the OpenClaw gateway. */
+async function requestPluginApproval(params) {
+	const timeoutMs = DEFAULT_CODEX_APPROVAL_TIMEOUT_MS;
+	return params.hostCapabilities.requestApproval({
+		title: truncateCodexApprovalDisplayText(params.title, MAX_PLUGIN_APPROVAL_TITLE_LENGTH),
+		description: truncateCodexApprovalDisplayText(params.description, MAX_PLUGIN_APPROVAL_DESCRIPTION_LENGTH),
+		severity: params.severity,
+		toolName: params.toolName,
+		toolCallId: params.toolCallId,
+		timeoutMs,
+		transportTimeoutMs: resolveCodexGatewayTimeoutWithGraceMs(timeoutMs),
+		...params.allowedDecisions ? { allowedDecisions: params.allowedDecisions } : {}
+	});
+}
+/** Detects the gateway's explicit null-decision marker for unavailable approvals. */
+function approvalRequestExplicitlyUnavailable(result) {
+	if (result === null || result === void 0 || typeof result !== "object") return false;
+	let descriptor;
+	try {
+		descriptor = Object.getOwnPropertyDescriptor(result, "decision");
+	} catch {
+		return false;
+	}
+	return descriptor !== void 0 && "value" in descriptor && descriptor.value === null;
+}
+/** Waits for the gateway's final approval decision, respecting turn aborts. */
+async function waitForPluginApprovalDecision(params) {
+	const timeoutMs = DEFAULT_CODEX_APPROVAL_TIMEOUT_MS;
+	const waitPromise = params.hostCapabilities.waitForApproval({
+		approvalId: params.approvalId,
+		timeoutMs,
+		transportTimeoutMs: resolveCodexGatewayTimeoutWithGraceMs(timeoutMs),
+		signal: params.signal
+	}).catch((error) => {
+		if (isApprovalNotFoundError(error)) return;
+		throw error;
+	});
+	if (!params.signal) return await waitPromise;
+	let onAbort;
+	const abortPromise = new Promise((_, reject) => {
+		if (params.signal.aborted) {
+			reject(toErrorObject(params.signal.reason, "Non-Error rejection"));
+			return;
+		}
+		onAbort = () => reject(toErrorObject(params.signal.reason, "Non-Error rejection"));
+		params.signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await Promise.race([waitPromise, abortPromise]);
+	} finally {
+		if (onAbort) params.signal.removeEventListener("abort", onAbort);
+	}
+}
+/** Converts a gateway exec approval decision into the app-server approval outcome enum. */
+function mapExecDecisionToOutcome(decision) {
+	switch (decision) {
+		case "allow-once": return "approved-once";
+		case "allow-always": return "approved-session";
+		case "deny": return "denied";
+		default: return "unavailable";
+	}
+}
+function truncateCodexApprovalDisplayText(value, maxLength) {
+	return value.length <= maxLength ? value : `${truncateUtf16Safe(value, maxLength - 3)}...`;
+}
+function stripDanglingCodexApprovalTerminalSequence(value) {
+	return value.replace(DANGLING_TERMINAL_SEQUENCE_SUFFIX_RE, "");
+}
+function sanitizeCodexApprovalVisibleText(value, options = {}) {
+	const terminalSafe = value.replace(ANSI_OSC_SEQUENCE_RE, "").replace(ANSI_CONTROL_SEQUENCE_RE, "");
+	return (options.stripDanglingTerminalSequence ? stripDanglingCodexApprovalTerminalSequence(terminalSafe) : terminalSafe).replace(INVISIBLE_FORMATTING_CONTROL_RE, " ").replace(CONTROL_CHARACTER_RE, " ").replace(/\s+/g, " ").trim();
+}
+//#endregion
+export { sanitizeCodexApprovalVisibleText as a, waitForPluginApprovalDecision as c, requestPluginApproval as i, codexApprovalTimeoutText as n, stripDanglingCodexApprovalTerminalSequence as o, mapExecDecisionToOutcome as r, truncateCodexApprovalDisplayText as s, approvalRequestExplicitlyUnavailable as t };

package/dist/{plugin-marketplace-discovery-CzrGJdCR.js → plugin-marketplace-discovery-mdmScYOj.js}

@@ -1,16 +1,22 @@
-import { P as isCodexFastServiceTier, o as isCodexAppServerNativeAuthProfile, r as bindingStoreKey, s as normalizeCodexAppServerBindingModelProvider } from "./session-binding-DPxIvMgE.js";
-import { a as getLeasedSharedCodexAppServerClient, l as releaseLeasedSharedCodexAppServerClient } from "./shared-client-kIBbGjk4.js";
-import { g as resolveCodexAppServerRequestModelSelection, v as resolveCodexBindingModelProviderFallback } from "./thread-lifecycle-Bu1BTDXr.js";
-import { r as formatCodexDisplayText } from "./command-formatters-B1AEz8ZA.js";
-import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-I5Bo-AsX.js";
+import { k as isCodexFastServiceTier } from "./config-Cxw3Cl3k.js";
+import { c as getLeasedSharedCodexAppServerClient, h as releaseLeasedSharedCodexAppServerClient } from "./shared-client-kNkljY-R.js";
+import { o as isCodexAppServerNativeAuthProfile, r as bindingStoreKey, s as normalizeCodexAppServerBindingModelProvider } from "./session-binding-q2WSTVmC.js";
+import { E as resolveCodexAppServerRequestModelSelection, O as resolveCodexBindingModelProviderFallback } from "./thread-lifecycle-Ss-uwnC4.js";
+import { r as formatCodexDisplayText } from "./command-formatters-C54Yg3eA.js";
+import { n as resolveCodexBindingAppServerConnection } from "./binding-connection-CCQFs8lf.js";
 import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveAgentDir } from "openclaw/plugin-sdk/agent-runtime";
-import { patchSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
+import { getSessionEntry, patchSessionEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { ModelSelectionLockedError, applyModelOverrideWithAuthProfileCompatibility } from "openclaw/plugin-sdk/model-session-runtime";
 //#region extensions/codex/src/command-authorization.ts
 const CODEX_NATIVE_EXECUTION_AUTH_ERROR = "Only an owner or operator.admin can control Codex native execution.";
+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 || ctx.gatewayClientScopes?.includes("operator.admin") === true;
+	return ctx.senderIsOwner === true || hasCodexAdminScope(ctx);
 }
 //#endregion
 //#region extensions/codex/src/conversation-control.ts
@@ -140,23 +146,23 @@ async function setCodexConversationModel(params) {
 	});
 	const nextModel = modelSelection.model;
 	const modelChanged = nextModel !== binding.model || nextModelProvider !== binding.modelProvider;
-	const session = params.session ?? (params.identity.kind === "session" && params.identity.sessionKey ? {
-		agentId: params.identity.agentId,
-		sessionId: params.identity.sessionId,
-		sessionKey: params.identity.sessionKey
-	} : void 0);
-	if (session) {
+	const projectionPatch = modelChanged && binding.contextEngine?.projection ? { contextEngine: {
+		...binding.contextEngine,
+		projection: void 0
+	} } : {};
+	const identity = params.identity;
+	if (identity.kind === "session" && identity.sessionKey) {
 		if (!await patchSessionEntry({
-			agentId: session.agentId,
-			storePath: resolveStorePath(params.config?.session?.store, { agentId: session.agentId }),
-			sessionKey: session.sessionKey,
+			agentId: identity.agentId,
+			storePath: resolveStorePath(params.config?.session?.store, { agentId: identity.agentId }),
+			sessionKey: identity.sessionKey,
 			requireWriteSuccess: true,
 			replaceEntry: true,
 			update: (entry) => {
-				if (entry.sessionId !== session.sessionId) throw new Error("Codex session changed while applying the model selection.");
+				if (entry.sessionId !== identity.sessionId) throw new Error("Codex session changed while applying the model selection.");
 				applyModelOverrideWithAuthProfileCompatibility({
 					cfg: params.config ?? {},
-					agentDir: params.agentDir ?? resolveAgentDir(params.config ?? {}, session.agentId),
+					agentDir: params.agentDir ?? resolveAgentDir(params.config ?? {}, identity.agentId),
 					entry,
 					currentProvider: binding.modelProvider ?? "openai",
 					selection: {
@@ -168,25 +174,11 @@ async function setCodexConversationModel(params) {
 				return entry;
 			}
 		})) throw new Error("Codex session changed while applying the model selection.");
-		if (params.identity.kind === "conversation") await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, {
-			model: nextModel,
-			modelProvider: nextModelProvider,
-			...modelChanged && binding.contextEngine?.projection ? { contextEngine: {
-				...binding.contextEngine,
-				projection: void 0
-			} } : {}
-		});
-		else if (modelChanged && binding.contextEngine?.projection) await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, { contextEngine: {
-			...binding.contextEngine,
-			projection: void 0
-		} });
+		if (modelChanged && binding.contextEngine?.projection) await patchThreadBinding(params.bindingStore, identity, binding.threadId, projectionPatch);
 	} else await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, {
 		model: nextModel,
 		modelProvider: nextModelProvider,
-		...modelChanged && binding.contextEngine?.projection ? { contextEngine: {
-			...binding.contextEngine,
-			projection: void 0
-		} } : {}
+		...projectionPatch
 	});
 	return `Codex model set to ${formatCodexDisplayText(nextModel)}.`;
 }
@@ -198,14 +190,31 @@ async function setCodexConversationFastMode(params) {
 	return `Codex fast mode ${params.enabled ? "enabled" : "disabled"}.`;
 }
 async function setCodexConversationPermissions(params) {
-	const binding = await requireThreadBinding(params.bindingStore, params.identity);
-	if (!params.mode) return `Codex permissions: ${formatPermissionsMode(binding)}.`;
-	const policy = permissionsForMode(params.mode);
-	await patchThreadBinding(params.bindingStore, params.identity, binding.threadId, {
-		approvalPolicy: policy.approvalPolicy,
-		sandbox: policy.sandbox
-	});
-	return `Codex permissions set to ${params.mode === "yolo" ? "full access" : "default"}.`;
+	const storePath = resolveStorePath(params.config?.session?.store, { agentId: params.session.agentId });
+	if (!params.mode) {
+		const entry = getSessionEntry({
+			agentId: params.session.agentId,
+			hydrateSkillPromptRefs: false,
+			readConsistency: "latest",
+			sessionKey: params.session.sessionKey,
+			storePath
+		});
+		if (entry?.sessionId !== params.session.sessionId) throw new Error("Codex session changed while reading the permission mode.");
+		return `Codex permissions: ${formatPermissionsMode(entry.permissionMode)}.`;
+	}
+	if (!await patchSessionEntry({
+		agentId: params.session.agentId,
+		storePath,
+		sessionKey: params.session.sessionKey,
+		requireWriteSuccess: true,
+		replaceEntry: true,
+		update: (entry) => {
+			if (entry.sessionId !== params.session.sessionId) throw new Error("Codex session changed while applying the permission mode.");
+			entry.permissionMode = params.mode === "yolo" ? "full" : "guarded";
+			return entry;
+		}
+	})) throw new Error("Codex session changed while applying the permission mode.");
+	return `Codex permissions set to ${params.mode === "yolo" ? "full access" : "guarded"}.`;
 }
 function parseCodexFastModeArg(arg) {
 	const normalized = arg?.trim().toLowerCase();
@@ -217,10 +226,15 @@ function parseCodexPermissionsModeArg(arg) {
 	const normalized = arg?.trim().toLowerCase();
 	if (!normalized || normalized === "status") return;
 	if (normalized === "yolo" || normalized === "full" || normalized === "full-access") return "yolo";
-	if (normalized === "default" || normalized === "guardian") return "default";
+	if ([
+		"default",
+		"guardian",
+		"guarded",
+		"approve"
+	].includes(normalized)) return "default";
 }
-function formatPermissionsMode(binding) {
-	return binding.approvalPolicy === "never" && binding.sandbox === "danger-full-access" ? "full access" : "default";
+function formatPermissionsMode(mode) {
+	return mode === "full" ? "full access" : mode ?? "default";
 }
 async function requireThreadBinding(bindingStore, identity) {
 	const binding = await bindingStore.read(identity);
@@ -251,15 +265,6 @@ function resolveConversationControlModelProvider(params) {
 	if (isCodexAppServerNativeAuthProfile(params) && modelProvider.toLowerCase() === "openai") return;
 	return modelProvider.toLowerCase() === "openai" ? "openai" : modelProvider;
 }
-function permissionsForMode(mode) {
-	return mode === "yolo" ? {
-		approvalPolicy: "never",
-		sandbox: "danger-full-access"
-	} : {
-		approvalPolicy: "on-request",
-		sandbox: "workspace-write"
-	};
-}
 //#endregion
 //#region extensions/codex/src/plugin-marketplace-discovery.ts
 /** Read-only discovery of Codex-owned local, curated, and remote plugin marketplaces. */
@@ -382,4 +387,4 @@ function boundedCatalogText(value) {
 	return sanitized.replace(/\s+/g, " ").trim().slice(0, MAX_PLUGIN_DESCRIPTION_LENGTH);
 }
 //#endregion
-export { parseCodexPermissionsModeArg as a, setCodexConversationModel as c, stopCodexConversationTurn as d, trackCodexConversationActiveTurn as f, parseCodexFastModeArg as i, setCodexConversationPermissions as l, canMutateCodexHost as m, parseCodexPluginMarketplaceId as n, readCodexConversationActiveTurn as o, CODEX_NATIVE_EXECUTION_AUTH_ERROR as p, formatPermissionsMode as r, setCodexConversationFastMode as s, discoverCodexMarketplacePlugins as t, steerCodexConversationTurn as u };
+export { hasCodexAdminScope as _, parseCodexPermissionsModeArg as a, setCodexConversationModel as c, stopCodexConversationTurn as d, trackCodexConversationActiveTurn as f, canMutateCodexHost as g, CODEX_NATIVE_EXECUTION_AUTH_ERROR as h, parseCodexFastModeArg as i, setCodexConversationPermissions as l, CODEX_HOST_INSPECTION_AUTH_ERROR as m, parseCodexPluginMarketplaceId as n, readCodexConversationActiveTurn as o, CODEX_FULL_PERMISSIONS_AUTH_ERROR as p, formatPermissionsMode as r, setCodexConversationFastMode as s, discoverCodexMarketplacePlugins as t, steerCodexConversationTurn as u };