@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/plugin-approval-roundtrip-CjfzafAZ.mjs

@@ -1,122 +0,0 @@
-import { it as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-BpTtuLQ5.mjs";
-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 = 512;
-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({
-		signal: params.signal,
-		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,
-		...params.mcpTool ? {
-			mcpTool: params.mcpTool,
-			isMcpToolApprovalActive: params.isMcpToolApprovalActive
-		} : {},
-		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";
-	}
-}
-/** Runs one complete host approval request and maps transport failures to a closed outcome. */
-async function requestPluginApprovalOutcome(params) {
-	try {
-		const requestResult = await requestPluginApproval({
-			...params,
-			severity: "warning"
-		});
-		const approvalId = requestResult?.id;
-		if (!approvalId) return "unavailable";
-		const approvalResult = approvalRequestExplicitlyUnavailable(requestResult) ? void 0 : await waitForPluginApprovalDecision({
-			hostCapabilities: params.hostCapabilities,
-			approvalId,
-			signal: params.signal
-		});
-		if (params.signal?.aborted) return "cancelled";
-		if (approvalResult?.terminalReason === "timeout") return "timed-out";
-		const decision = approvalResult?.decision;
-		return mapExecDecisionToOutcome(decision === "allow-always" && params.allowedDecisions?.includes("allow-always") === false ? "allow-once" : decision);
-	} catch {
-		return params.signal?.aborted ? "cancelled" : "denied";
-	}
-}
-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 { requestPluginApprovalOutcome as a, truncateCodexApprovalDisplayText as c, requestPluginApproval as i, waitForPluginApprovalDecision as l, codexApprovalTimeoutText as n, sanitizeCodexApprovalVisibleText as o, mapExecDecisionToOutcome as r, stripDanglingCodexApprovalTerminalSequence as s, approvalRequestExplicitlyUnavailable as t };

package/dist/.setup/provider-fFh_-VR3.mjs

@@ -1,50 +0,0 @@
-//#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-Bjp4UQij.mjs").then((n) => n.a);
-			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-xD7WKYTM.mjs");
-			return buildCodexMigrationPlan(ctx);
-		},
-		deferredApply: { retrySafe: true },
-		prepareApply(ctx) {
-			if (isMemoryOnlyMigration(ctx) || isAuthOnlyMigration(ctx)) return;
-			return import("./apply-CJ0ZfmBG.mjs").then(({ prepareTargetCodexAppServer }) => prepareTargetCodexAppServer(ctx));
-		},
-		async apply(ctx, plan) {
-			const { applyCodexMigrationPlan } = await import("./apply-CJ0ZfmBG.mjs");
-			return await applyCodexMigrationPlan({
-				ctx,
-				plan,
-				runtime: params.runtime
-			});
-		}
-	};
-}
-//#endregion
-export { buildCodexMigrationProvider as t };

package/dist/.setup/rolldown-runtime-8H4AJuhK.mjs

@@ -1,14 +0,0 @@
-import "node:module";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-export { __exportAll as t };

package/dist/.setup/sandbox-guard-BBP-RbTf.mjs

@@ -1,166 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { l as isCodexRemoteExecPlacementSandbox } from "./config-parsing-CcB9iPoq.mjs";
-import { n as resolveCodexNativeExecutionPolicy, t as formatCodexNativeNodeExecBlock } from "./native-execution-policy-YBMHSzC4.mjs";
-import { tryResolveDefaultAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
-import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
-import { resolveSandboxRuntimeStatus } from "openclaw/plugin-sdk/sandbox";
-//#region extensions/codex/src/app-server/sandbox-guard.ts
-/**
-* Blocks direct Codex app-server requests that would bypass OpenClaw sandbox or
-* node-exec routing guarantees.
-*/
-var sandbox_guard_exports = /* @__PURE__ */ __exportAll({
-	resolveCodexAppServerDirectSandboxBypassBlock: () => resolveCodexAppServerDirectSandboxBypassBlock,
-	resolveCodexNativeExecutionBlock: () => resolveCodexNativeExecutionBlock,
-	resolveCodexNativeSandboxBlock: () => resolveCodexNativeSandboxBlock
-});
-const DIRECT_METHOD_POLICIES = /* @__PURE__ */ new Map([
-	["account/rateLimits/read", "allowed-control-plane"],
-	["account/read", "allowed-control-plane"],
-	["app/installed", "allowed-control-plane"],
-	["app/list", "allowed-control-plane"],
-	["app/read", "allowed-control-plane"],
-	["config/batchWrite", "allowed-control-plane"],
-	["config/mcpServer/reload", "allowed-control-plane"],
-	["config/read", "allowed-control-plane"],
-	["config/value/write", "allowed-control-plane"],
-	["environment/add", "allowed-control-plane"],
-	["experimentalFeature/list", "allowed-control-plane"],
-	["experimentalFeature/enablement/set", "allowed-control-plane"],
-	["feedback/upload", "allowed-control-plane"],
-	["hooks/list", "allowed-control-plane"],
-	["initialize", "allowed-control-plane"],
-	["marketplace/add", "allowed-control-plane"],
-	["mcpServerStatus/list", "allowed-control-plane"],
-	["model/list", "allowed-control-plane"],
-	["plugin/install", "allowed-control-plane"],
-	["plugin/installed", "allowed-control-plane"],
-	["plugin/list", "allowed-control-plane"],
-	["plugin/read", "allowed-control-plane"],
-	["skills/list", "allowed-control-plane"],
-	["thread/archive", "allowed-control-plane"],
-	["thread/inject_items", "allowed-control-plane"],
-	["thread/list", "allowed-control-plane"],
-	["thread/metadata/update", "allowed-control-plane"],
-	["thread/name/set", "allowed-control-plane"],
-	["thread/read", "allowed-control-plane"],
-	["thread/rollback", "allowed-control-plane"],
-	["thread/start", "requires-openclaw-environment"],
-	["thread/unarchive", "allowed-control-plane"],
-	["thread/unsubscribe", "allowed-control-plane"],
-	["turn/interrupt", "allowed-control-plane"],
-	["turn/steer", "allowed-control-plane"],
-	["command/exec", "blocked-native-bypass"],
-	["command/resize", "blocked-native-bypass"],
-	["command/terminate", "blocked-native-bypass"],
-	["command/write", "blocked-native-bypass"],
-	["fuzzyFileSearch", "blocked-native-bypass"],
-	["mcpServer/resource/read", "blocked-native-bypass"],
-	["mcpServer/tool/call", "blocked-native-bypass"],
-	["process/kill", "blocked-native-bypass"],
-	["process/resizePty", "blocked-native-bypass"],
-	["process/spawn", "blocked-native-bypass"],
-	["process/writeStdin", "blocked-native-bypass"],
-	["review/start", "blocked-native-bypass"],
-	["thread/compact/start", "blocked-native-bypass"],
-	["thread/fork", "blocked-native-bypass"],
-	["thread/resume", "blocked-native-bypass"],
-	["thread/shellCommand", "blocked-native-bypass"],
-	["turn/start", "blocked-native-bypass"]
-]);
-const BLOCKED_DIRECT_METHOD_PREFIXES = [
-	"command/",
-	"fs/",
-	"windowsSandbox/"
-];
-const NODE_EXEC_BLOCKED_CONTROL_PLANE_METHODS = /* @__PURE__ */ new Set(["config/mcpServer/reload"]);
-/** Returns a block message when a direct app-server method would bypass OpenClaw execution policy. */
-function resolveCodexAppServerDirectSandboxBypassBlock(params) {
-	const policy = resolveDirectMethodPolicy(params.method);
-	if (NODE_EXEC_BLOCKED_CONTROL_PLANE_METHODS.has(params.method)) {
-		const nodeExecBlock = resolveCodexNativeNodeExecBlock({
-			config: params.config,
-			sessionKey: params.sessionKey,
-			sessionId: params.sessionId,
-			surface: `app-server method \`${params.method}\``
-		});
-		if (nodeExecBlock) return nodeExecBlock;
-	}
-	if (policy === "allowed-control-plane") return;
-	const nodeExecBlock = resolveCodexNativeNodeExecBlock({
-		config: params.config,
-		sessionKey: params.sessionKey,
-		sessionId: params.sessionId,
-		surface: `app-server method \`${params.method}\``
-	});
-	if (nodeExecBlock) return nodeExecBlock;
-	const sessionKey = params.sessionKey?.trim() || params.sessionId?.trim();
-	if (!sessionKey) return;
-	const sandboxBlock = resolveCodexNativeSandboxBlock({
-		config: params.config,
-		sessionKey,
-		sandbox: params.sandbox,
-		surface: `app-server method \`${params.method}\``
-	});
-	if (!sandboxBlock) return;
-	if (policy === "requires-openclaw-environment" && hasOpenClawSandboxEnvironmentSelection(params.requestParams)) return;
-	return sandboxBlock;
-}
-/** Resolves the generic native-execution block for sandboxed or node-hosted sessions. */
-function resolveCodexNativeExecutionBlock(params) {
-	return resolveCodexNativeSandboxBlock(params) ?? resolveCodexNativeNodeExecBlock(params);
-}
-/** Returns a block message when native Codex execution cannot honor active sandboxing. */
-function resolveCodexNativeSandboxBlock(params) {
-	if (params.sandboxEnvironmentSelected) return;
-	const sessionKey = params.sessionKey?.trim() || params.sessionId?.trim();
-	if (!sessionKey) return;
-	if (isCodexRemoteExecPlacementSandbox(params.sandbox) || params.sandbox?.enabled === true) return formatCodexNativeSandboxBlock({ surface: params.surface });
-	const sandboxAgentId = parseAgentSessionKey(sessionKey)?.agentId ?? params.agentId ?? tryResolveDefaultAgentId(params.config ?? {});
-	if (!sandboxAgentId) return;
-	if (!resolveSandboxRuntimeStatus({
-		cfg: params.config,
-		sessionKey,
-		agentId: sandboxAgentId,
-		classificationAgentId: sandboxAgentId
-	}).sandboxed) return;
-	return formatCodexNativeSandboxBlock({ surface: params.surface });
-}
-function resolveDirectMethodPolicy(method) {
-	const exact = DIRECT_METHOD_POLICIES.get(method);
-	if (exact) return exact;
-	if (BLOCKED_DIRECT_METHOD_PREFIXES.some((prefix) => method.startsWith(prefix))) return "blocked-native-bypass";
-	return "blocked-native-bypass";
-}
-function hasOpenClawSandboxEnvironmentSelection(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	const environments = value.environments;
-	return Array.isArray(environments) && environments.length > 0 && environments.every((entry) => {
-		if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
-		const environment = entry;
-		return typeof environment.environmentId === "string" && environment.environmentId.startsWith("openclaw-sandbox-") && typeof environment.cwd === "string" && environment.cwd.trim().length > 0;
-	});
-}
-function formatCodexNativeSandboxBlock(params) {
-	return [
-		`Codex-native ${params.surface} is unavailable because OpenClaw sandboxing is active for this session.`,
-		"This mode cannot route execution through the OpenClaw sandbox backend.",
-		"Use a normal Codex harness turn, or run an intentionally unsandboxed session."
-	].join(" ");
-}
-function resolveCodexNativeNodeExecBlock(params) {
-	const sessionKey = params.sessionKey?.trim() || params.sessionId?.trim();
-	const policy = resolveCodexNativeExecutionPolicy({
-		config: params.config,
-		sessionKey,
-		agentId: params.agentId,
-		readRuntimeSessionEntry: Boolean(sessionKey)
-	});
-	if (policy.nativeToolSurfaceAllowed) return;
-	return formatCodexNativeNodeExecBlock({
-		surface: params.surface,
-		reason: policy.blockReason
-	});
-}
-//#endregion
-export { resolveCodexNativeSandboxBlock as n, sandbox_guard_exports as r, resolveCodexNativeExecutionBlock as t };