@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/{node-cli-sessions-Cl8b2ZF3.mjs → node-cli-sessions-HC4W6FLI.mjs}

@@ -1,19 +1,22 @@
-import { o as formatCodexDisplayText } from "./command-formatters-CGEkdawF.mjs";
+import { A as unwrapNodeInvokePayload, x as readBoundedOptionalString } from "./session-catalog-parsing-CPGaPYr-.mjs";
+import { r as resolveCodexAppServerUserHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
+import { o as formatCodexDisplayText } from "./command-formatters-R3ckE3Co.mjs";
+import { t as codexCatalogHomeId } from "./session-catalog-home-id-vlih0B_g.mjs";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { runCommandBuffered, withCommandProcessScope } from "openclaw/plugin-sdk/process-runtime";
 import { timestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
-import { runCommandBuffered } from "openclaw/plugin-sdk/process-runtime";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 import path from "node:path";
-import os from "node:os";
 import fs from "node:fs/promises";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import process from "node:process";
+import { parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/codex/src/jsonl-lines.ts
 const JSONL_STREAM_THRESHOLD_BYTES = 4194304;
 const JSONL_READ_CHUNK_BYTES = 1048576;
-async function visitJsonlLines(file, visitor, chunkBytes = JSONL_READ_CHUNK_BYTES) {
+async function visitJsonlLines(file, visitor) {
 	let size;
 	try {
 		size = (await fs.stat(file)).size;
@@ -40,7 +43,7 @@ async function visitJsonlLines(file, visitor, chunkBytes = JSONL_READ_CHUNK_BYTE
 		let lineCount = 0;
 		for (const line of content.split(/\r?\n/u)) {
 			lineCount += 1;
-			if (visitor(line) === false) break;
+			visitor(line);
 		}
 		return {
 			ok: true,
@@ -56,7 +59,7 @@ async function visitJsonlLines(file, visitor, chunkBytes = JSONL_READ_CHUNK_BYTE
 			lineCount: 0
 		};
 	}
-	const buffer = Buffer.allocUnsafe(chunkBytes);
+	const buffer = Buffer.allocUnsafe(JSONL_READ_CHUNK_BYTES);
 	const decoder = new TextDecoder();
 	let pendingFragments = [];
 	let lineCount = 0;
@@ -77,10 +80,7 @@ async function visitJsonlLines(file, visitor, chunkBytes = JSONL_READ_CHUNK_BYTE
 				}
 				const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
 				lineCount += 1;
-				if (visitor(line) === false) return {
-					ok: true,
-					lineCount
-				};
+				visitor(line);
 				lineStart = newline + 1;
 			}
 			if (lineStart < content.length) pendingFragments.push(content.slice(lineStart));
@@ -110,21 +110,25 @@ async function visitJsonlLines(file, visitor, chunkBytes = JSONL_READ_CHUNK_BYTE
 //#region extensions/codex/src/node-cli-sessions.ts
 const CODEX_CLI_SESSIONS_LIST_COMMAND = "codex.cli.sessions.list";
 const CODEX_CLI_SESSION_RESUME_COMMAND = "codex.cli.session.resume";
+const CODEX_CLI_SESSION_SOURCE_CAPABILITY = "codex-cli-session-source";
+const CODEX_CLI_SESSION_SOURCE_UPGRADE_MESSAGE = "Update the node and approve its refreshed capabilities before continuing this Codex catalog session.";
 const DEFAULT_SESSION_LIMIT = 10;
 const MAX_SESSION_LIMIT = 50;
 const DEFAULT_RESUME_TIMEOUT_MS = 12e5;
 const SESSION_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
 const activeResumeSessions = /* @__PURE__ */ new Set();
-function createCodexCliSessionNodeHostCommands() {
+function createCodexCliSessionNodeHostCommands(resolveCatalogSource) {
 	return [{
 		command: CODEX_CLI_SESSIONS_LIST_COMMAND,
 		cap: "codex-cli-sessions",
+		hasActiveWork: () => false,
 		handle: listLocalCodexCliSessions
 	}, {
 		command: CODEX_CLI_SESSION_RESUME_COMMAND,
-		cap: "codex-cli-sessions",
+		cap: CODEX_CLI_SESSION_SOURCE_CAPABILITY,
 		dangerous: true,
-		handle: resumeLocalCodexCliSession
+		hasActiveWork: () => activeResumeSessions.size > 0,
+		handle: (paramsJSON, _io, context) => resumeLocalCodexCliSession(paramsJSON, resolveCatalogSource, context)
 	}];
 }
 function createCodexCliSessionNodeInvokePolicies() {
@@ -139,7 +143,11 @@ function createCodexCliSessionNodeInvokePolicies() {
 	}, {
 		commands: [CODEX_CLI_SESSION_RESUME_COMMAND],
 		dangerous: true,
-		handle: (ctx) => ctx.invokeNode()
+		handle: (ctx) => isRecord(ctx.params) && (ctx.params.agentId !== void 0 || ctx.params.sourceHomeId !== void 0) && !ctx.node?.caps?.includes("codex-cli-session-source") ? {
+			ok: false,
+			code: "CODEX_NODE_SOURCE_UNAVAILABLE",
+			message: CODEX_CLI_SESSION_SOURCE_UPGRADE_MESSAGE
+		} : ctx.invokeNode()
 	}];
 }
 async function listCodexCliSessionsOnNode(params) {
@@ -176,18 +184,38 @@ async function resolveCodexCliSessionForBindingOnNode(params) {
 	};
 }
 async function resumeCodexCliSessionOnNode(params) {
-	const payload = unwrapNodeInvokePayload(await params.runtime.nodes.invoke({
+	let catalogAgentId;
+	let catalogHomeId;
+	if (params.sessionKey) {
+		const { adoptionSessionKeyRest, CODEX_NODE_SESSION_KEY_PREFIX, readNodeSessionMarker } = await import("./session-catalog-node-adoption-DgXvSGu0.mjs");
+		const entry = params.runtime.agent.session.getSessionEntry({
+			sessionKey: params.sessionKey,
+			readConsistency: "latest"
+		});
+		const codex = entry?.pluginExtensions?.codex;
+		if (adoptionSessionKeyRest(params.sessionKey).startsWith(CODEX_NODE_SESSION_KEY_PREFIX) || isRecord(codex) && codex.sessionCatalog !== void 0) {
+			const marker = entry ? readNodeSessionMarker(entry) : void 0;
+			catalogAgentId = params.agentId?.trim();
+			if (!catalogAgentId || parseAgentSessionKey(params.sessionKey)?.agentId !== catalogAgentId || !marker || marker.initializing === true || marker.nodeId !== params.nodeId || marker.sourceHostId !== `node:${params.nodeId}` || marker.sourceThreadId !== params.sessionId || entry?.initializationPending === true || entry?.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true) throw new Error("Codex catalog session changed before its node turn could run.");
+			if (!marker.sourceHomeId) throw new Error("This Codex catalog session has no saved source home. Reopen it from the catalog to continue in a new chat.");
+			catalogHomeId = marker.sourceHomeId;
+		}
+	}
+	const raw = await params.runtime.nodes.invoke({
 		nodeId: params.nodeId,
 		command: CODEX_CLI_SESSION_RESUME_COMMAND,
 		params: {
 			sessionId: params.sessionId,
+			...catalogAgentId ? { agentId: catalogAgentId } : {},
+			...catalogHomeId ? { sourceHomeId: catalogHomeId } : {},
 			prompt: params.prompt,
 			cwd: params.cwd,
 			timeoutMs: params.timeoutMs
 		},
 		timeoutMs: (params.timeoutMs ?? DEFAULT_RESUME_TIMEOUT_MS) + 5e3,
 		scopes: ["operator.write"]
-	}));
+	});
+	const payload = unwrapNodeInvokePayload(raw, "Codex CLI node command returned malformed payloadJSON.");
 	if (!isRecord(payload) || payload.ok !== true || typeof payload.text !== "string") throw new Error("Codex CLI resume returned an invalid payload.");
 	return {
 		ok: true,
@@ -203,12 +231,11 @@ function formatCodexCliSessions(params) {
 	})].join("\n");
 }
 async function listLocalCodexCliSessions(paramsJSON) {
-	const params = readRecordParam(paramsJSON);
+	const params = parseJsonRecord(paramsJSON);
 	const limit = normalizeLimit(params.limit);
 	const filter = typeof params.filter === "string" ? params.filter.trim().toLowerCase() : "";
-	const codexHome = resolveCodexHome();
+	const codexHome = resolveCodexAppServerUserHomeDir();
 	const summaries = await readHistorySessions(codexHome);
-	await hydrateSessionFiles(codexHome, summaries);
 	await hydrateSessionsFromSessionFiles(codexHome, summaries);
 	const sessions = [...summaries.values()].filter((session) => {
 		if (!filter) return true;
@@ -217,26 +244,45 @@ async function listLocalCodexCliSessions(paramsJSON) {
 			session.cwd,
 			session.lastMessage
 		].some((value) => value?.toLowerCase().includes(filter));
-	}).toSorted((a, b) => compareOptionalStringsDesc(a.updatedAt, b.updatedAt)).slice(0, limit);
+	}).toSorted((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "")).slice(0, limit);
 	return JSON.stringify({
 		sessions,
 		codexHome
 	});
 }
-async function resumeLocalCodexCliSession(paramsJSON) {
-	const params = readRecordParam(paramsJSON);
+async function resumeLocalCodexCliSession(paramsJSON, resolveCatalogSource, context) {
+	context?.signal?.throwIfAborted();
+	const params = parseJsonRecord(paramsJSON);
 	const sessionId = typeof params.sessionId === "string" ? params.sessionId.trim() : "";
 	const prompt = typeof params.prompt === "string" ? params.prompt.trim() : "";
+	const expectedHomeId = readBoundedOptionalString(params, "sourceHomeId", 256);
 	if (!sessionId || !SESSION_ID_PATTERN.test(sessionId)) throw new Error("Missing or invalid Codex CLI session id.");
 	if (!prompt) throw new Error("Missing Codex CLI prompt.");
-	if (activeResumeSessions.has(sessionId)) throw new Error(`Codex CLI session ${sessionId} already has an active resume turn.`);
-	activeResumeSessions.add(sessionId);
+	let codexHome = resolveCodexAppServerUserHomeDir();
+	let sourceHomeId;
+	let assertCurrent;
+	if (params.agentId !== void 0) {
+		if (typeof params.agentId !== "string" || !params.agentId.trim()) throw new Error("Codex catalog agent id must be a nonempty string.");
+		const source = await resolveCatalogSource(params.agentId.trim());
+		if (source.transport !== "stdio") throw new Error("Codex CLI continuation requires a local Codex catalog source.");
+		codexHome = source.codexHome;
+		sourceHomeId = source.sourceHomeId;
+		assertCurrent = () => source.assertCurrent();
+	} else sourceHomeId = codexCatalogHomeId(codexHome);
+	if (expectedHomeId && expectedHomeId !== sourceHomeId) throw new Error("Codex catalog source home changed. Reopen the session from the catalog.");
+	context?.signal?.throwIfAborted();
+	const resumeKey = `${sourceHomeId}\0${sessionId}`;
+	if (activeResumeSessions.has(resumeKey)) throw new Error(`Codex CLI session ${sessionId} already has an active resume turn.`);
+	activeResumeSessions.add(resumeKey);
 	try {
 		const text = await runCodexExecResume({
 			sessionId,
 			prompt,
 			cwd: typeof params.cwd === "string" && params.cwd.trim() ? params.cwd.trim() : void 0,
-			timeoutMs: normalizeTimeoutMs(params.timeoutMs)
+			timeoutMs: normalizeTimeoutMs(params.timeoutMs),
+			codexHome,
+			assertCurrent,
+			signal: context?.signal
 		});
 		return JSON.stringify({
 			ok: true,
@@ -244,7 +290,7 @@ async function resumeLocalCodexCliSession(paramsJSON) {
 			text: text.trim() || "Codex completed without a text reply."
 		});
 	} finally {
-		activeResumeSessions.delete(sessionId);
+		activeResumeSessions.delete(resumeKey);
 	}
 }
 async function runCodexExecResume(params) {
@@ -266,22 +312,31 @@ async function runCodexExecResume(params) {
 			execPath: process.execPath,
 			packageName: "@openai/codex"
 		}), args);
-		const result = await runCommandBuffered([invocation.command, ...invocation.argv], {
-			cwd: params.cwd || process.cwd(),
-			input: params.prompt,
-			env: process.env,
-			killGraceMs: 2e3,
-			killProcessTree: false,
-			terminateOnOutputError: true,
-			timeoutMs: params.timeoutMs
-		});
+		const result = await withCommandProcessScope(() => {
+			params.assertCurrent?.();
+			return runCommandBuffered([invocation.command, ...invocation.argv], {
+				cwd: params.cwd || process.cwd(),
+				input: params.prompt,
+				env: {
+					...process.env,
+					CODEX_HOME: params.codexHome
+				},
+				killGraceMs: 2e3,
+				signal: params.signal,
+				terminateOnOutputError: true,
+				timeoutMs: params.timeoutMs
+			});
+		}, params.signal);
+		params.signal?.throwIfAborted();
 		if (result.termination === "timeout") throw new Error(`codex exec resume timed out after ${String(params.timeoutMs)}ms`);
 		if (result.termination === "error" && result.error) throw result.error;
 		if (result.code !== 0) {
 			const message = result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim() || `codex exec resume exited with code ${String(result.code)}`;
 			throw new Error(message);
 		}
-		return await fs.readFile(outputPath, "utf8");
+		const text = await fs.readFile(outputPath, "utf8");
+		params.signal?.throwIfAborted();
+		return text;
 	} finally {
 		await fs.rm(path.dirname(outputPath), {
 			recursive: true,
@@ -292,15 +347,8 @@ async function runCodexExecResume(params) {
 async function readHistorySessions(codexHome) {
 	const summaries = /* @__PURE__ */ new Map();
 	if (!(await visitJsonlLines(path.join(codexHome, "history.jsonl"), (line) => {
-		const trimmed = line.trim();
-		if (!trimmed) return;
-		let parsed;
-		try {
-			parsed = JSON.parse(trimmed);
-		} catch {
-			return;
-		}
-		if (!isRecord(parsed) || typeof parsed.session_id !== "string") return;
+		const parsed = parseJsonRecord(line.trim());
+		if (typeof parsed.session_id !== "string") return;
 		const sessionId = parsed.session_id.trim();
 		if (!sessionId) return;
 		const entry = summaries.get(sessionId) ?? {
@@ -314,23 +362,6 @@ async function readHistorySessions(codexHome) {
 	})).ok) return /* @__PURE__ */ new Map();
 	return summaries;
 }
-async function hydrateSessionFiles(codexHome, summaries) {
-	if (summaries.size === 0) return;
-	const files = await findSessionFiles(path.join(codexHome, "sessions"), 4);
-	const pending = new Set(summaries.keys());
-	for (const file of files) {
-		const basename = path.basename(file);
-		const sessionId = [...pending].find((id) => basename.includes(id));
-		if (!sessionId) continue;
-		const entry = summaries.get(sessionId);
-		if (!entry) continue;
-		entry.sessionFile = file;
-		const cwd = readSessionMetaCwd(await readFirstLine(file) ?? "");
-		if (cwd) entry.cwd = cwd;
-		pending.delete(sessionId);
-		if (pending.size === 0) return;
-	}
-}
 async function hydrateSessionsFromSessionFiles(codexHome, summaries) {
 	const files = await findSessionFiles(path.join(codexHome, "sessions"), 4);
 	for (const file of files) {
@@ -355,15 +386,7 @@ async function readSessionFileSummary(file) {
 	let lastMessage;
 	let messageCount = 0;
 	const result = await visitJsonlLines(file, (line) => {
-		const trimmed = line.trim();
-		if (!trimmed) return;
-		let parsed;
-		try {
-			parsed = JSON.parse(trimmed);
-		} catch {
-			return;
-		}
-		if (!isRecord(parsed)) return;
+		const parsed = parseJsonRecord(line.trim());
 		if (typeof parsed.timestamp === "string" && parsed.timestamp.trim()) updatedAt = parsed.timestamp.trim();
 		if (parsed.type === "session_meta" && isRecord(parsed.payload)) {
 			if (typeof parsed.payload.id === "string" && parsed.payload.id.trim()) sessionId = parsed.payload.id.trim();
@@ -376,8 +399,7 @@ async function readSessionFileSummary(file) {
 			lastMessage = truncateText(messageText, 140);
 		}
 	});
-	if (!result.ok) return null;
-	if (result.lineCount === 0) return null;
+	if (!result.ok || result.lineCount === 0) return null;
 	if (!sessionId) sessionId = readSessionIdFromFilename(file) ?? "";
 	if (!sessionId) return null;
 	return {
@@ -405,19 +427,8 @@ async function findSessionFiles(dir, maxDepth) {
 	}
 	return files;
 }
-function readSessionMetaCwd(line) {
-	try {
-		const parsed = JSON.parse(line);
-		if (!isRecord(parsed) || parsed.type !== "session_meta" || !isRecord(parsed.payload)) return;
-		return typeof parsed.payload.cwd === "string" && parsed.payload.cwd.trim() ? parsed.payload.cwd.trim() : void 0;
-	} catch {
-		return;
-	}
-}
 function readResponseItemMessageText(parsed) {
-	if (parsed.type !== "response_item" || !isRecord(parsed.payload)) return;
-	if (parsed.payload.type !== "message") return;
-	if ((typeof parsed.payload.role === "string" ? parsed.payload.role : "") !== "user") return;
+	if (parsed.type !== "response_item" || !isRecord(parsed.payload) || parsed.payload.type !== "message" || parsed.payload.role !== "user") return;
 	const parts = (Array.isArray(parsed.payload.content) ? parsed.payload.content : []).flatMap((entry) => {
 		if (!isRecord(entry)) return [];
 		const text = typeof entry.text === "string" ? entry.text : typeof entry.input_text === "string" ? entry.input_text : void 0;
@@ -446,7 +457,7 @@ async function resolveCodexCliNode(params) {
 	return expectDefined(usable[0], "single usable Codex CLI node");
 }
 function parseCodexCliSessionsListResult(raw) {
-	const payload = unwrapNodeInvokePayload(raw);
+	const payload = unwrapNodeInvokePayload(raw, "Codex CLI node command returned malformed payloadJSON.");
 	if (!isRecord(payload) || !Array.isArray(payload.sessions)) throw new Error("Codex CLI session list returned an invalid payload.");
 	return {
 		codexHome: typeof payload.codexHome === "string" ? payload.codexHome : "",
@@ -463,17 +474,7 @@ function parseCodexCliSessionsListResult(raw) {
 		})
 	};
 }
-function unwrapNodeInvokePayload(raw) {
-	const record = isRecord(raw) ? raw : {};
-	if (typeof record.payloadJSON === "string" && record.payloadJSON.trim()) try {
-		return JSON.parse(record.payloadJSON);
-	} catch (error) {
-		throw new Error("Codex CLI node command returned malformed payloadJSON.", { cause: error });
-	}
-	if ("payload" in record) return record.payload;
-	return raw;
-}
-function readRecordParam(paramsJSON) {
+function parseJsonRecord(paramsJSON) {
 	if (!paramsJSON?.trim()) return {};
 	try {
 		const parsed = JSON.parse(paramsJSON);
@@ -482,16 +483,6 @@ function readRecordParam(paramsJSON) {
 		return {};
 	}
 }
-function resolveCodexHome() {
-	return process.env.CODEX_HOME?.trim() || path.join(os.homedir(), ".codex");
-}
-async function readFirstLine(file) {
-	let firstLine;
-	return (await visitJsonlLines(file, (line) => {
-		firstLine = line;
-		return false;
-	}, 65536)).ok ? firstLine : void 0;
-}
 async function readFileMtimeIso(file) {
 	try {
 		return (await fs.stat(file)).mtime.toISOString();
@@ -509,9 +500,6 @@ function truncateText(value, max) {
 	if (value.length <= max) return value;
 	return `${truncateUtf16Safe(value, Math.max(0, max - 3))}...`;
 }
-function compareOptionalStringsDesc(a, b) {
-	return (b ?? "").localeCompare(a ?? "");
-}
 function readNodeId(node) {
 	if (!node.nodeId) throw new Error("Codex CLI node did not include a node id.");
 	return node.nodeId;
@@ -524,4 +512,4 @@ function formatNodeLabel(node) {
 	].filter(Boolean).join(" / ") || "node";
 }
 //#endregion
-export { listCodexCliSessionsOnNode as a, formatCodexCliSessions as i, createCodexCliSessionNodeHostCommands as n, resolveCodexCliSessionForBindingOnNode as o, createCodexCliSessionNodeInvokePolicies as r, resumeCodexCliSessionOnNode as s, CODEX_CLI_SESSION_RESUME_COMMAND as t };
+export { createCodexCliSessionNodeInvokePolicies as a, resolveCodexCliSessionForBindingOnNode as c, createCodexCliSessionNodeHostCommands as i, resumeCodexCliSessionOnNode as l, CODEX_CLI_SESSION_SOURCE_CAPABILITY as n, formatCodexCliSessions as o, CODEX_CLI_SESSION_SOURCE_UPGRADE_MESSAGE as r, listCodexCliSessionsOnNode as s, CODEX_CLI_SESSION_RESUME_COMMAND as t };

package/dist/.setup/node-exec-server.runtime-BgBfWQqo.mjs

@@ -0,0 +1,244 @@
+import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, t as isManagedCodexDesktopCommand } from "./managed-binary-kiWRhNRE.mjs";
+import { a as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-Bdegpn2V.mjs";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { stripVTControlCharacters } from "node:util";
+import { killProcessTree } from "openclaw/plugin-sdk/process-runtime";
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { once } from "node:events";
+import { resolvePreferredOpenClawTmpDir, tempWorkspace } from "openclaw/plugin-sdk/temp-path";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
+import { StringDecoder } from "node:string_decoder";
+import { sanitizeEnvVars } from "openclaw/plugin-sdk/sandbox";
+//#region extensions/codex/src/node-exec-server.runtime.ts
+const MAX_CODEX_EXEC_SERVER_MESSAGE_BYTES = 67108864;
+const MAX_CODEX_EXEC_SERVER_STDERR_BYTES = 4096;
+const CODEX_EXEC_SERVER_READY_LINE = "codex_exec_server::server::transport: codex-exec-server listening on stdio";
+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, releaseResources, activeProcesses) {
+	let termination;
+	let hasClosed = false;
+	const settled = closed.then(async () => {
+		hasClosed = true;
+		await termination?.catch(() => {});
+		await releaseResources();
+		activeProcesses.delete(terminate);
+	});
+	settled.catch(() => {});
+	const terminate = async () => {
+		if (!hasClosed) await (termination ??= (async () => {
+			if (process.platform === "win32" && child.pid) killProcessTree(child.pid, { graceMs: CODEX_EXEC_SERVER_TERMINATION_GRACE_MS });
+			const { exited } = await closeCodexAppServerTransportAndWait(child, {
+				forceKillDelayMs: CODEX_EXEC_SERVER_TERMINATION_GRACE_MS,
+				exitTimeoutMs: CODEX_EXEC_SERVER_REAP_TIMEOUT_MS
+			});
+			if (!exited) throw new Error("Codex node exec-server process tree did not terminate.");
+		})());
+		await settled;
+	};
+	activeProcesses.add(terminate);
+	return terminate;
+}
+/** Runs the one-connection paired-node exec-server after lightweight command admission. */
+async function runCodexNodeExecServer(params) {
+	const { io, workspace } = params;
+	const frames = io.frames;
+	const cwd = workspace.workspaceDir;
+	let writes;
+	let output;
+	let temporaryHome;
+	let unsubscribe;
+	const releaseResources = async () => {
+		try {
+			await Promise.allSettled([output, writes]);
+			await temporaryHome?.cleanup();
+		} finally {
+			workspace.release();
+		}
+	};
+	let close = releaseResources;
+	const { promise: disconnected, reject: rejectDisconnected } = createDeferred();
+	disconnected.catch(() => {});
+	const onAbort = () => {
+		const error = nodeExecServerAbortError(io.signal);
+		rejectDisconnected(error);
+	};
+	io.signal.addEventListener("abort", onAbort, { once: true });
+	try {
+		if (!frames) throw new Error("Codex node exec-server requires duplex frames.");
+		if (io.signal.aborted) throw nodeExecServerAbortError(io.signal);
+		temporaryHome = await tempWorkspace({
+			rootDir: resolvePreferredOpenClawTmpDir(),
+			prefix: "codex-node-exec-server-"
+		});
+		const { dir } = temporaryHome;
+		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 nativeReady = createDeferred();
+		const exit = createDeferred();
+		let stderr = Buffer.alloc(0);
+		let startupSettled = false;
+		let pendingLine = "";
+		const decoder = new StringDecoder("utf8");
+		const child = await createStdioTransport({
+			transport: "stdio",
+			command: native,
+			commandSource: "resolved-managed",
+			args: resolved.args,
+			headers: {},
+			cwd,
+			env: {
+				HOME: workspace.homeDir ?? dir,
+				CODEX_HOME: codexHome,
+				RUST_LOG: "error,opentelemetry_sdk=off,opentelemetry_otlp=off,codex_exec_server::server::transport=info",
+				...process.platform === "win32" ? { USERPROFILE: workspace.homeDir ?? dir } : {}
+			},
+			clearEnv: ["NODE_OPTIONS"]
+		}, baseEnv, () => {
+			if (io.signal.aborted) throw nodeExecServerAbortError(io.signal);
+			params.assertExecAuthorized();
+		}, (spawned) => {
+			spawned.once("close", (code, signal) => exit.resolve({
+				code,
+				signal
+			}));
+			close = createNodeExecServerProcessOwner(spawned, exit.promise, releaseResources, params.activeProcesses);
+			output = relayNodeExecServerOutput(spawned, frames.send.bind(frames));
+			output.catch((error) => {
+				rejectDisconnected(error instanceof Error ? error : new Error(String(error)));
+			});
+			spawned.once("error", rejectDisconnected);
+			spawned.stdin.on("error", rejectDisconnected);
+			spawned.stderr.on("data", (chunk) => {
+				const next = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+				stderr = Buffer.concat([stderr, next.subarray(-4096)]).subarray(-4096);
+				if (startupSettled) return;
+				const lines = (pendingLine + decoder.write(next)).split("\n");
+				pendingLine = lines.pop();
+				for (const line of [...lines, pendingLine]) if (Buffer.byteLength(line, "utf8") > MAX_CODEX_EXEC_SERVER_STDERR_BYTES) {
+					startupSettled = true;
+					pendingLine = "";
+					rejectDisconnected(/* @__PURE__ */ new Error("Codex node startup diagnostic line exceeded 4 KiB."));
+					return;
+				}
+				if (lines.some((line) => stripVTControlCharacters(line).trimEnd().endsWith(CODEX_EXEC_SERVER_READY_LINE))) {
+					startupSettled = true;
+					pendingLine = "";
+					nativeReady.resolve();
+				}
+			});
+		});
+		const stopped = exit.promise.then((outcome) => {
+			const diagnostic = stderr.toString("utf8").trim();
+			throw new Error(`Codex node exec-server exited (code ${outcome.code ?? "none"}, signal ${outcome.signal ?? "none"})${diagnostic ? `: ${diagnostic}` : "."}`);
+		});
+		await Promise.race([
+			nativeReady.promise,
+			stopped,
+			disconnected
+		]);
+		if (io.signal.aborted) throw nodeExecServerAbortError(io.signal);
+		if (child.exitCode !== null || child.signalCode !== null) await stopped;
+		params.assertExecAuthorized();
+		unsubscribe = frames.onMessage((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;
+		});
+		return await Promise.race([stopped, disconnected]);
+	} finally {
+		io.signal.removeEventListener("abort", onAbort);
+		try {
+			unsubscribe?.();
+		} finally {
+			await close();
+		}
+	}
+}
+//#endregion
+export { runCodexNodeExecServer };