@openclaw/codex 2026.7.2-beta.7 → 2026.8.1-beta.3

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

@@ -0,0 +1,192 @@
+import { z as closeCodexAppServerTransportAndWait } from "./shared-client-Dw-rzii0.js";
+import { t as createStdioTransport } from "./transport-stdio-DhoGy33Z.js";
+import { n as resolveManagedCodexAppServerStartOptions, r as resolveManagedCodexNativeCommand, t as isManagedCodexDesktopCommand } from "./managed-binary-By4FZC6i.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);
+			const child = 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);
+			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-app-cache-key-DztPafOA.js → plugin-app-cache-key-DMNQ8Zi8.js}

@@ -1,11 +1,11 @@
-import { K as resolveCodexAppServerHomeDir } from "./shared-client-DTbvH-XV.js";
-import { w as resolveCodexAppServerUserHomeDir } from "./session-binding-BXpo9ymA.js";
+import { x as resolveCodexAppServerUserHomeDir } from "./config-CpNeo5AE.js";
+import { ft as resolveCodexAppServerHomeDir, pt as resolveCodexAppServerLocalHomeDir } from "./shared-client-Dw-rzii0.js";
 import { createRequire } from "node:module";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { readPluginPackageVersion } from "openclaw/plugin-sdk/extension-shared";
 import { isFutureDateTimestampMs, resolveDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { OPENCLAW_VERSION, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
 import { createHash } from "node:crypto";
-import { readPluginPackageVersion } from "openclaw/plugin-sdk/extension-shared";
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/codex/src/app-server/app-inventory-cache.ts
 /**
@@ -331,6 +331,14 @@ function isSensitiveErrorDataKey(key) {
 * auth, account, and version inputs without storing secret material.
 */
 const CODEX_PLUGIN_VERSION = readPluginPackageVersion({ require: createRequire(import.meta.url) });
+let catalogConnectionHomes = /* @__PURE__ */ new Map();
+function catalogConnectionHomeKey(fingerprint, agentDir) {
+	return `${agentDir ?? ""}\0${fingerprint}`;
+}
+/** Replaces the lifecycle-owned catalog connection snapshot used by supervised bindings. */
+function replaceCodexCatalogConnectionHomes(homes) {
+	catalogConnectionHomes = new Map(homes.map((home) => [catalogConnectionHomeKey(home.fingerprint, home.agentDir), home.codexHome]));
+}
 /** Builds the full app inventory cache key for Codex plugin/app discovery. */
 function buildCodexPluginAppCacheKey(params) {
 	return buildCodexAppInventoryCacheKey({
@@ -364,13 +372,17 @@ function buildCodexAppServerConnectionFingerprint(appServer, agentDir) {
 		cwd: appServer.start.cwd ?? null
 	});
 }
+/** Looks up a snapshotted catalog store without repeating filesystem discovery on a run. */
+function resolveCodexCatalogConnectionHome(fingerprint, agentDir) {
+	return catalogConnectionHomes.get(catalogConnectionHomeKey(fingerprint, agentDir));
+}
 function resolveCodexAppServerConnectionHome(start, agentDir) {
 	const configured = start.env?.CODEX_HOME?.trim();
 	if (configured) return configured;
 	if (start.transport === "unix" && (!start.url || start.url === "unix://")) return resolveCodexAppServerUserHomeDir(start.env ?? process.env);
 	if (start.transport !== "stdio") return null;
 	if (start.homeScope === "user") return resolveCodexAppServerUserHomeDir(process.env);
-	return agentDir ? resolveCodexAppServerHomeDir(agentDir) : null;
+	return agentDir ? resolveCodexAppServerLocalHomeDir(start, agentDir) : null;
 }
 /** Serializes app-server endpoint identity, including credential fingerprints. */
 function resolveCodexPluginAppCacheEndpoint(appServer) {
@@ -405,4 +417,4 @@ function fingerprintCodexPluginAppCacheCredentials(startOptions) {
 	return `sha256:${hash.digest("hex")}`;
 }
 //#endregion
-export { serializeCodexAppInventoryError as a, defaultCodexAppInventoryCache as i, buildCodexAppServerRuntimeFingerprint as n, buildCodexPluginAppCacheKey as r, buildCodexAppServerConnectionFingerprint as t };
+export { resolveCodexCatalogConnectionHome as a, replaceCodexCatalogConnectionHomes as i, buildCodexAppServerRuntimeFingerprint as n, defaultCodexAppInventoryCache as o, buildCodexPluginAppCacheKey as r, serializeCodexAppInventoryError as s, buildCodexAppServerConnectionFingerprint as t };

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

@@ -0,0 +1,95 @@
+import { S as resolveCodexGatewayTimeoutWithGraceMs } from "./shared-client-Dw-rzii0.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 };