@openclaw/codex 2026.9.5 → 2026.9.6

package/dist/.setup/inference-proxy-CC15HuSi.mjs

@@ -1,311 +0,0 @@
-import { m as isJsonObject } from "./config-security-BRQ2mgW9.mjs";
-import { n as createCodexInferenceContext } from "./inference-context-fulhZuz8.mjs";
-import { promisify } from "node:util";
-import { zstdCompress, zstdDecompress } from "node:zlib";
-import { Writable } from "node:stream";
-import { WebSocket, WebSocketServer } from "openclaw/plugin-sdk/websocket-runtime";
-import { createServer } from "node:http";
-import { createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
-import { generateSecureToken } from "openclaw/plugin-sdk/secure-random-runtime";
-import { fetchWithSsrFGuard, isBlockedHostnameOrIp, resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-runtime";
-//#region extensions/codex/src/app-server/inference-proxy.ts
-const MAX_BODY_BYTES = 33554432;
-const MAX_ERROR_BODY_BYTES = 1048576;
-const MAX_CONNECTIONS = 16;
-const compress = promisify(zstdCompress);
-const decompress = promisify(zstdDecompress);
-const HOP_HEADERS = /* @__PURE__ */ new Set([
-	"connection",
-	"keep-alive",
-	"proxy-authenticate",
-	"proxy-authorization",
-	"te",
-	"trailer",
-	"transfer-encoding",
-	"upgrade",
-	"host",
-	"content-length"
-]);
-const FAILURE = "Codex parent-local inference transport failed; retry on a fresh connection.";
-/** Private, fixed-destination relay. No upstream credentials or model content are retained. */
-async function createCodexInferenceProxy(params) {
-	const upstream = new URL(params.upstream);
-	if (upstream.protocol !== "https:" || upstream.username || upstream.password || upstream.hash) throw new Error("Codex inference requires a credential-free HTTPS upstream URL");
-	const lifetime = new AbortController();
-	const assertCurrent = () => {
-		lifetime.signal.throwIfAborted();
-		params.assertCurrent();
-	};
-	const context = createCodexInferenceContext(assertCurrent);
-	const pathPrefix = "/" + generateSecureToken({
-		bytes: 32,
-		redact: true
-	}) + upstream.pathname.replace(/\/$/, "");
-	const active = /* @__PURE__ */ new Set();
-	const sockets = /* @__PURE__ */ new Set();
-	const wss = new WebSocketServer({
-		noServer: true,
-		maxPayload: MAX_BODY_BYTES,
-		perMessageDeflate: false
-	});
-	const handshakeHeaders = /* @__PURE__ */ new WeakMap();
-	wss.on("headers", (headers, request) => {
-		for (const [key, value] of Object.entries(handshakeHeaders.get(request) ?? {})) if (!key.startsWith("sec-websocket-")) headers.push(key + ": " + value);
-		handshakeHeaders.delete(request);
-	});
-	const resolveTarget = (request) => {
-		assertCurrent();
-		if (request.headers.origin || !request.url?.startsWith(pathPrefix + "/") || isBlockedHostnameOrIp(upstream.hostname)) throw new Error(FAILURE);
-		const suffix = request.url.slice(pathPrefix.length);
-		if (suffix.startsWith("//") || suffix.includes("\\") || /%2e|%2f|%5c|(?:^|\/)\.\.?(?:\/|\?|$)/i.test(suffix)) throw new Error(FAILURE);
-		const target = new URL(upstream);
-		const incoming = new URL(suffix, "http://localhost");
-		target.pathname = upstream.pathname.replace(/\/$/, "") + incoming.pathname;
-		for (const [key, value] of incoming.searchParams) target.searchParams.append(key, value);
-		return {
-			target,
-			sampling: incoming.pathname === "/responses"
-		};
-	};
-	const prepare = (bytes, sampling) => {
-		assertCurrent();
-		if (!sampling) return {
-			bytes,
-			assertCurrent,
-			signal: void 0
-		};
-		const value = JSON.parse(bytes.toString("utf8"));
-		if (!isJsonObject(value)) throw new Error(FAILURE);
-		const prepared = context.prepare(value);
-		const rewritten = Buffer.from(JSON.stringify(prepared.body));
-		if (rewritten.length > MAX_BODY_BYTES) throw new Error(FAILURE);
-		return {
-			...prepared,
-			bytes: rewritten
-		};
-	};
-	const server = createServer((req, res) => {
-		const controller = new AbortController();
-		let guarded;
-		const abort = () => controller.abort();
-		req.once("aborted", abort);
-		res.once("close", abort);
-		(async () => {
-			try {
-				const { target, sampling } = resolveTarget(req);
-				if (req.method !== "POST" || active.size >= MAX_CONNECTIONS) throw new Error(FAILURE);
-				active.add(controller);
-				const wire = await readProxyBody(req, MAX_BODY_BYTES);
-				const encoding = req.headers["content-encoding"];
-				if (encoding && encoding !== "identity" && encoding !== "zstd") throw new Error(FAILURE);
-				const decoded = encoding === "zstd" ? await decompress(wire, { maxOutputLength: MAX_BODY_BYTES }) : wire;
-				assertCurrent();
-				const prepared = prepare(decoded, sampling);
-				const body = Buffer.from(encoding === "zstd" ? await compress(prepared.bytes) : prepared.bytes);
-				prepared.assertCurrent();
-				const signal = AbortSignal.any([
-					lifetime.signal,
-					controller.signal,
-					...prepared.signal ? [prepared.signal] : []
-				]);
-				guarded = await fetchWithSsrFGuard({
-					url: target.toString(),
-					init: {
-						method: "POST",
-						headers: relayHeaders(req.headers),
-						body,
-						signal
-					},
-					signal,
-					beforeRequest: prepared.assertCurrent,
-					requireHttps: true,
-					maxRedirects: 0,
-					capture: false,
-					mode: "trusted_env_proxy",
-					auditContext: "codex-parent-local-inference"
-				});
-				prepared.assertCurrent();
-				const headers = Object.fromEntries(guarded.response.headers);
-				delete headers["content-encoding"];
-				res.writeHead(guarded.response.status, relayHeaders(headers));
-				if (!guarded.response.body) res.end();
-				else await guarded.response.body.pipeTo(Writable.toWeb(res), { signal });
-			} catch {
-				if (!res.headersSent && !res.destroyed) res.writeHead(502, { "content-type": "text/plain" }).end(FAILURE);
-				else res.destroy();
-			} finally {
-				active.delete(controller);
-				req.off("aborted", abort);
-				res.off("close", abort);
-				await guarded?.release().catch(() => void 0);
-			}
-		})();
-	});
-	server.maxConnections = MAX_CONNECTIONS;
-	server.requestTimeout = 3e4;
-	server.headersTimeout = 1e4;
-	server.on("upgrade", (req, socket, head) => {
-		(async () => {
-			let remote;
-			let local;
-			let proxyAgent;
-			const controller = new AbortController();
-			const close = () => {
-				controller.abort();
-				active.delete(controller);
-				remote?.terminate();
-				local?.terminate();
-				proxyAgent?.destroy();
-				if (remote) sockets.delete(remote);
-				if (local) sockets.delete(local);
-				socket.destroy();
-			};
-			try {
-				const { target, sampling } = resolveTarget(req);
-				if (!sampling || active.size >= MAX_CONNECTIONS) throw new Error(FAILURE);
-				active.add(controller);
-				socket.once("close", close);
-				socket.once("error", close);
-				const signal = AbortSignal.any([lifetime.signal, controller.signal]);
-				proxyAgent = createNodeProxyAgent({
-					mode: "env",
-					targetUrl: target.href
-				});
-				const lookup = proxyAgent ? void 0 : (await resolvePinnedHostnameWithPolicy(target.hostname, { signal })).lookup;
-				assertCurrent();
-				signal.throwIfAborted();
-				target.protocol = "wss:";
-				const headers = relayHeaders(req.headers);
-				for (const key of Object.keys(headers)) if (key.startsWith("sec-websocket-")) delete headers[key];
-				remote = new WebSocket(target, {
-					headers,
-					...proxyAgent ? { agent: proxyAgent } : { lookup },
-					followRedirects: false,
-					perMessageDeflate: false,
-					maxPayload: MAX_BODY_BYTES,
-					handshakeTimeout: 1e4
-				});
-				sockets.add(remote);
-				remote.once("upgrade", (response) => {
-					handshakeHeaders.set(req, relayHeaders(response.headers));
-				});
-				remote.once("error", close);
-				remote.once("close", close);
-				remote.once("unexpected-response", (_request, response) => {
-					(async () => {
-						try {
-							const body = await readProxyBody(response, MAX_ERROR_BODY_BYTES);
-							assertCurrent();
-							signal.throwIfAborted();
-							const failureHeaders = Object.entries(relayHeaders(response.headers)).map(([key, value]) => key + ": " + value);
-							failureHeaders.push("Connection: close", "Content-Length: " + body.length);
-							const status = "HTTP/1.1 " + response.statusCode + " " + (response.statusMessage ?? "Upstream refused");
-							socket.end(Buffer.concat([Buffer.from(status + "\r\n" + failureHeaders.join("\r\n") + "\r\n\r\n"), body]), close);
-						} catch {
-							close();
-						}
-					})();
-				});
-				remote.once("open", () => {
-					try {
-						assertCurrent();
-						signal.throwIfAborted();
-						wss.handleUpgrade(req, socket, head, (accepted) => {
-							local = accepted;
-							sockets.add(accepted);
-							accepted.once("error", close);
-							accepted.once("close", close);
-							let releaseFrame = () => {};
-							accepted.on("message", (data, binary) => {
-								try {
-									if (binary) throw new Error(FAILURE);
-									const prepared = prepare(rawBytes(data), true);
-									prepared.assertCurrent();
-									releaseFrame();
-									const onAbort = () => close();
-									prepared.signal?.addEventListener("abort", onAbort, { once: true });
-									releaseFrame = () => prepared.signal?.removeEventListener("abort", onAbort);
-									if (!remote || remote.readyState !== WebSocket.OPEN || remote.bufferedAmount + prepared.bytes.length > MAX_BODY_BYTES) throw new Error(FAILURE);
-									remote.send(prepared.bytes, { binary: false }, (error) => {
-										if (error) close();
-									});
-								} catch {
-									close();
-								}
-							});
-							accepted.once("close", () => releaseFrame());
-							remote.on("message", (data, binary) => {
-								if (accepted.readyState !== WebSocket.OPEN || accepted.bufferedAmount + rawBytes(data).length > MAX_BODY_BYTES) {
-									close();
-									return;
-								}
-								accepted.send(data, { binary }, (error) => {
-									if (error) close();
-								});
-							});
-						});
-					} catch {
-						close();
-					}
-				});
-			} catch {
-				close();
-			}
-		})();
-	});
-	const close = () => {
-		lifetime.abort();
-		context.close();
-		for (const controller of active) controller.abort();
-		for (const socket of sockets) socket.terminate();
-		server.close();
-		server.closeAllConnections();
-		wss.close();
-	};
-	try {
-		await new Promise((resolve, reject) => {
-			server.once("error", reject);
-			server.listen(0, "127.0.0.1", () => {
-				server.off("error", reject);
-				resolve();
-			});
-		});
-		assertCurrent();
-		server.on("error", close);
-		const address = server.address();
-		if (!address || typeof address === "string") throw new Error(FAILURE);
-		return {
-			context,
-			upstream: upstream.toString(),
-			baseUrl: "http://127.0.0.1:" + address.port + pathPrefix,
-			assertCurrent,
-			close
-		};
-	} catch (error) {
-		close();
-		throw error;
-	}
-}
-async function readProxyBody(stream, maxBytes) {
-	const chunks = [];
-	let size = 0;
-	for await (const chunk of stream) {
-		const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-		size += bytes.length;
-		if (size > maxBytes) throw new Error(FAILURE);
-		chunks.push(bytes);
-	}
-	return Buffer.concat(chunks);
-}
-function rawBytes(data) {
-	return Array.isArray(data) ? Buffer.concat(data) : Buffer.isBuffer(data) ? data : Buffer.from(data);
-}
-function relayHeaders(input) {
-	const excluded = new Set(HOP_HEADERS);
-	for (const token of (input.connection ?? "").split(",")) excluded.add(token.trim().toLowerCase());
-	const output = {};
-	for (const [key, value] of Object.entries(input)) if (value !== void 0 && !excluded.has(key.toLowerCase())) output[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
-	return output;
-}
-//#endregion
-export { createCodexInferenceProxy };

package/dist/.setup/launch-args-DnMak49W.mjs

@@ -1,111 +0,0 @@
-//#region extensions/codex/src/app-server/launch-args.ts
-const CODEX_VALUE_OPTIONS = /* @__PURE__ */ new Set([
-	"-m",
-	"--model",
-	"--local-provider",
-	"-p",
-	"--profile",
-	"-s",
-	"--sandbox",
-	"-a",
-	"--ask-for-approval",
-	"-C",
-	"--cd",
-	"--add-dir",
-	"--remote",
-	"--remote-auth-token-env",
-	"-c",
-	"--config",
-	"--enable",
-	"--disable",
-	"--listen",
-	"--code-mode-host",
-	"--ws-auth",
-	"--ws-token-file",
-	"--ws-token-sha256",
-	"--ws-shared-secret-file",
-	"--ws-issuer",
-	"--ws-audience",
-	"--ws-max-clock-skew-seconds"
-]);
-/** One tokenization owner for launch, turn policy, reviewer trust, and private turns. */
-function readCodexArgs(args) {
-	const tokens = [];
-	let nativeSubcommand = false;
-	let end = 0;
-	for (const [index, arg] of args.entries()) {
-		if (index < end) continue;
-		end = index + 1;
-		const attached = /^(--[^=]+)=([\s\S]*)$/u.exec(arg) ?? /^(-[cmpisaC])=?([\s\S]+)$/u.exec(arg);
-		const name = attached?.[1] ?? arg;
-		let value = attached?.[2];
-		if (name === "-i" || name === "--image") while (args[end]?.startsWith("-") === false) end += 1;
-		else if (!attached && CODEX_VALUE_OPTIONS.has(name)) {
-			value = args[end];
-			if (value !== void 0) end += 1;
-		}
-		tokens.push({
-			index,
-			end,
-			name,
-			value
-		});
-		if (name === "app-server") nativeSubcommand = true;
-		if (name === "--" && nativeSubcommand) break;
-	}
-	return tokens;
-}
-/** Uses the native CLI configuration for status without starting its transport. */
-function buildCodexLoginStatusArgs(args) {
-	const options = /* @__PURE__ */ new Set([
-		"-c",
-		"--config",
-		"-p",
-		"--profile",
-		"--enable",
-		"--disable"
-	]);
-	const tokens = readCodexArgs(args);
-	const subcommandIndex = tokens.findLast(({ name }) => name === "app-server")?.index ?? -1;
-	const prefix = subcommandIndex < 0 ? [] : args.slice(0, subcommandIndex);
-	const configArgs = tokens.filter(({ index, name }) => index > subcommandIndex && options.has(name)).flatMap(({ index, end }) => args.slice(index, end));
-	return [
-		...prefix,
-		...configArgs,
-		"login",
-		"status"
-	];
-}
-function readCodexAppServerConfigOptions(args) {
-	return readCodexArgs(args).filter(({ name }) => name === "-c" || name === "--config" || name === "-p" || name === "--profile");
-}
-/** The stdio proxy forwards to an external server; it does not own that runtime. */
-function isCodexAppServerProxyLaunch(args) {
-	const tokens = readCodexArgs(args);
-	const server = tokens.findLastIndex(({ name }) => name === "app-server");
-	return server >= 0 && tokens.slice(server + 1).find(({ name }) => !name.startsWith("-"))?.name === "proxy";
-}
-/** Keeps Codex overrides in one CLI scope without rewriting raw TOML or wrapper prefixes. */
-function normalizeCodexAppServerArgs(rawArgs, enforcedOverride) {
-	const tokens = readCodexArgs(rawArgs);
-	const subcommandIndex = tokens.findLast(({ name }) => name === "app-server")?.index ?? -1;
-	const prefix = subcommandIndex < 0 ? [...rawArgs] : rawArgs.slice(0, subcommandIndex);
-	const suffix = [];
-	if (subcommandIndex >= 0) for (const token of tokens) {
-		if (token.index <= subcommandIndex) continue;
-		if (token.name === "--") {
-			suffix.push(...rawArgs.slice(token.index));
-			break;
-		}
-		(token.name === "-c" || token.name === "--config" ? prefix : suffix).push(...rawArgs.slice(token.index, token.end));
-	}
-	if (enforcedOverride && !(prefix.at(-2) === "-c" && prefix.at(-1) === enforcedOverride)) prefix.push("-c", enforcedOverride);
-	const normalized = subcommandIndex < 0 ? prefix : [
-		...prefix,
-		"app-server",
-		...suffix
-	];
-	return normalized.length === rawArgs.length && normalized.every((arg, index) => arg === rawArgs[index]) ? rawArgs : normalized;
-}
-//#endregion
-export { readCodexAppServerConfigOptions as i, isCodexAppServerProxyLaunch as n, normalizeCodexAppServerArgs as r, buildCodexLoginStatusArgs as t };

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

@@ -1,226 +0,0 @@
-import { i as resolveManagedCodexNativeCommand, r as resolveManagedCodexAppServerStartOptions, t as isManagedCodexDesktopCommand } from "./managed-binary-DP6Rib3P.mjs";
-import { i as closeCodexAppServerTransportAndWait, t as createStdioTransport } from "./transport-stdio-Cmx94Oiy.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, withTempWorkspace } 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) {
-	let termination;
-	return { terminate: () => 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 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 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: params.homeDir ?? dir,
-					CODEX_HOME: codexHome,
-					RUST_LOG: "error,opentelemetry_sdk=off,opentelemetry_otlp=off,codex_exec_server::server::transport=info",
-					...process.platform === "win32" ? { USERPROFILE: params.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
-				}));
-				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 closed = exit.promise;
-			const stopped = closed.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}` : "."}`);
-			});
-			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 {
-				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();
-				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;
-				});
-				return await Promise.race([stopped, disconnected]);
-			} 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/.setup/version-CoqzXPgK.mjs

@@ -1,12 +0,0 @@
-//#region extensions/codex/src/app-server/version.ts
-/**
-* Version and package pins for the managed Codex app-server runtime.
-*/
-/** Exact Codex app-server version shipped by the OpenClaw Codex bridge. */
-const CODEX_APP_SERVER_VERSION = "0.154.0";
-/** Inclusive runtime compatibility floor for external app-server binaries. */
-const MIN_SUPPORTED_CODEX_APP_SERVER_VERSION = "0.149.0";
-/** npm package name for the managed Codex app-server binary. */
-const MANAGED_CODEX_APP_SERVER_PACKAGE = "@openai/codex";
-//#endregion
-export { MANAGED_CODEX_APP_SERVER_PACKAGE as n, MIN_SUPPORTED_CODEX_APP_SERVER_VERSION as r, CODEX_APP_SERVER_VERSION as t };

package/dist/.setup/{native-execution-policy-YBMHSzC4.mjs → native-execution-policy-umd0tgh4.mjs}

@@ -1,6 +1,6 @@
 import { resolveAgentConfig, tryResolveDefaultAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
-import { getSessionEntry } from "openclaw/plugin-sdk/session-store-runtime";
 import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { getSessionEntry } from "openclaw/plugin-sdk/session-store-runtime";
 import { resolveSandboxRuntimeStatus } from "openclaw/plugin-sdk/sandbox";
 //#region extensions/codex/src/app-server/native-execution-policy.ts
 /** Projects node execution ownership into the runtime tool factory options. */