@openclaw/codex 2026.9.2 → 2026.9.4

package/dist/inference-context-Dr_mzvk4.js

@@ -0,0 +1,94 @@
+import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
+import { randomUUID } from "node:crypto";
+//#region extensions/codex/src/app-server/inference-context.ts
+const MAX_CONTEXT_BYTES = 262144;
+const MAX_ACTIVE_ROOTS = 64;
+const CODEX_INFERENCE_GENERATION_KEY = "openclaw_inference_generation";
+/** One physical inference transport owns these confidential, nonpersistent snapshots. */
+function createCodexInferenceContext(assertClientCurrent) {
+	const roots = /* @__PURE__ */ new Map();
+	let closed = false;
+	const assertOpen = () => {
+		if (closed) throw new Error("Codex parent-local inference transport is closed");
+		assertClientCurrent();
+	};
+	return {
+		register(params) {
+			assertOpen();
+			params.signal.throwIfAborted();
+			params.assertCurrent();
+			if (Buffer.byteLength(params.text) > MAX_CONTEXT_BYTES) throw new Error("Codex parent-local context exceeds the 256 KiB inference limit");
+			if (!roots.has(params.threadId) && roots.size >= MAX_ACTIVE_ROOTS) throw new Error("Codex parent-local inference root limit reached");
+			roots.get(params.threadId)?.release();
+			const controller = new AbortController();
+			const registration = {
+				generation: randomUUID(),
+				text: params.text,
+				controller,
+				assertCurrent: () => {
+					assertOpen();
+					controller.signal.throwIfAborted();
+					params.signal.throwIfAborted();
+					params.assertCurrent();
+					if (roots.get(params.threadId) !== registration) throw new Error("Codex parent-local inference generation was replaced");
+				},
+				release: () => {
+					if (roots.get(params.threadId) === registration) roots.delete(params.threadId);
+					registration.text = "";
+					controller.abort();
+					params.signal.removeEventListener("abort", registration.release);
+				}
+			};
+			roots.set(params.threadId, registration);
+			params.signal.addEventListener("abort", registration.release, { once: true });
+			return {
+				generation: registration.generation,
+				release: registration.release
+			};
+		},
+		/** Caller must authenticate its private transport before parsing any model request. */
+		prepare(body) {
+			assertOpen();
+			const metadata = isJsonObject(body.client_metadata) ? body.client_metadata : void 0;
+			const raw = metadata?.["x-codex-turn-metadata"];
+			if (typeof raw !== "string" || Buffer.byteLength(raw) > 1048576) throw new Error("Codex inference request is missing bounded native metadata");
+			const value = JSON.parse(raw);
+			if (!isJsonObject(value)) throw new Error("Codex inference request has invalid native metadata");
+			const threadId = value.thread_id;
+			if (metadata?.thread_id != null && threadId != null && metadata.thread_id !== threadId) throw new Error("Codex inference thread metadata disagrees");
+			const child = Boolean(value.parent_thread_id || value.subagent_kind || metadata?.["x-openai-subagent"] || metadata?.["x-codex-parent-thread-id"]);
+			const kind = value.request_kind;
+			if (child || kind === "compaction" || kind === "memory") return {
+				body,
+				assertCurrent: assertOpen,
+				signal: void 0
+			};
+			if (kind !== "turn" && kind !== "prewarm") throw new Error("Codex inference request has an unsupported native purpose");
+			const registration = typeof threadId === "string" ? roots.get(threadId) : void 0;
+			const generation = value[CODEX_INFERENCE_GENERATION_KEY];
+			if (kind === "prewarm" && body.generate === false && generation == null) return {
+				body,
+				assertCurrent: assertOpen,
+				signal: void 0
+			};
+			if (!registration || generation !== registration.generation) throw new Error("Codex inference has no current admitted parent generation");
+			registration.assertCurrent();
+			const instructions = body.instructions;
+			if (instructions !== void 0 && typeof instructions !== "string") throw new Error("Codex inference request has invalid top-level instructions");
+			return {
+				body: registration.text ? {
+					...body,
+					instructions: instructions === void 0 ? registration.text : instructions + "\n\n" + registration.text
+				} : body,
+				assertCurrent: registration.assertCurrent,
+				signal: registration.controller.signal
+			};
+		},
+		close() {
+			closed = true;
+			for (const registration of roots.values()) registration.release();
+		}
+	};
+}
+//#endregion
+export { createCodexInferenceContext as n, CODEX_INFERENCE_GENERATION_KEY as t };

package/dist/inference-proxy-HGXKUIre.js

@@ -0,0 +1,311 @@
+import { o as isJsonObject } from "./protocol-5bh1G-H7.js";
+import { n as createCodexInferenceContext } from "./inference-context-Dr_mzvk4.js";
+import { zstdCompress, zstdDecompress } from "node:zlib";
+import { promisify } from "node:util";
+import { Writable } from "node:stream";
+import WebSocket, { WebSocketServer } from "ws";
+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/{isolated-completion-CRh-51AK.js → isolated-completion-DWVb5U2J.js}

@@ -1,7 +1,10 @@
-import { O as readCodexPluginConfig, r as resolveCodexAppServerHomeScope } from "./config-CyapYSji.js";
-import { Kt as resolveCodexAppServerPreparedAuthHandoff, Z as assertCodexPassiveTurnItems } from "./shared-client-CKhX2kFt.js";
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-DxGJRYbY.js";
-import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-B9kp6iGC.js";
+import { i as resolveCodexAppServerHomeScope } from "./config-options-CXMq1T-C.js";
+import { x as readCodexPluginConfig } from "./protocol-5bh1G-H7.js";
+import { g as assertCodexPassiveTurnItems } from "./client-B57KWPQx.js";
+import "./config-oIORaQ5T.js";
+import { tt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-CscigXXL.js";
+import { runBoundedCodexAppServerTurn } from "./bounded-turn-C_Hneydj.js";
+import { a as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-BmBM4qBV.js";
 //#region extensions/codex/src/app-server/isolated-completion.ts
 /** Runs prompt-only Codex inference on an ephemeral, ring-zero native thread. */
 async function runCodexIsolatedCompletion(params, options) {

package/dist/launch-args-RXQwn8zV.js

@@ -0,0 +1,90 @@
+//#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;
+}
+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 { normalizeCodexAppServerArgs as n, readCodexAppServerConfigOptions as r, isCodexAppServerProxyLaunch as t };

package/dist/{managed-binary-DcpnJF9x.js → managed-binary-D22rNEcR.js}

@@ -1,98 +1,11 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { n as MANAGED_CODEX_APP_SERVER_PACKAGE } from "./version-omm6IPI3.js";
 import { createRequire } from "node:module";
-import { access } from "node:fs/promises";
-import path from "node:path";
 import { constants, existsSync, realpathSync } from "node:fs";
+import path from "node:path";
+import { access } from "node:fs/promises";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
-//#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;
-}
-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
 //#region extensions/codex/src/app-server/desktop-app-paths.ts
 /** Shared path candidates for Codex's macOS desktop app bundle. */
 const MACOS_DESKTOP_CODEX_APP_PATH_CANDIDATES = [{
@@ -130,22 +43,19 @@ function resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath(params = {}
 	return candidates.find((candidate) => pathExists(candidate));
 }
 //#endregion
-//#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.153.4";
-/** 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
 //#region extensions/codex/src/app-server/managed-binary.ts
 /**
 * Resolves the managed Codex app-server binary shipped with or installed beside
 * the Codex plugin before stdio startup.
 */
+var managed_binary_exports = /* @__PURE__ */ __exportAll({
+	isManagedCodexDesktopCommand: () => isManagedCodexDesktopCommand,
+	resolveManagedCodexAppServerStartOptions: () => resolveManagedCodexAppServerStartOptions,
+	resolveManagedCodexNativeCommand: () => resolveManagedCodexNativeCommand,
+	resolveManagedCodexPackageEntrypoint: () => resolveManagedCodexPackageEntrypoint,
+	resolvePackagedCodexNativeCommand: () => resolvePackagedCodexNativeCommand,
+	setManagedCodexPluginRoot: () => setManagedCodexPluginRoot
+});
 const registeredCodexPlugin = resolveGlobalSingleton(Symbol.for("openclaw.codexManagedPluginRoot"), () => ({}));
 /** Records the process-stable plugin root prepared by OpenClaw's plugin loader. */
 function setManagedCodexPluginRoot(pluginRoot) {
@@ -282,4 +192,4 @@ async function commandPathExists(filePath, platform) {
 	}
 }
 //#endregion
-export { setManagedCodexPluginRoot as a, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as c, resolveMacOSDesktopCodexComputerUseServiceAppCandidates as d, isCodexAppServerProxyLaunch as f, resolvePackagedCodexNativeCommand as i, resolveMacOSDesktopCodexAppPathCandidates as l, readCodexAppServerConfigOptions as m, resolveManagedCodexAppServerStartOptions as n, CODEX_APP_SERVER_VERSION as o, normalizeCodexAppServerArgs as p, resolveManagedCodexNativeCommand as r, MIN_SUPPORTED_CODEX_APP_SERVER_VERSION as s, isManagedCodexDesktopCommand as t, resolveMacOSDesktopCodexBundledMarketplaceCandidates as u };
+export { resolvePackagedCodexNativeCommand as a, resolveMacOSDesktopCodexAppPathCandidates as c, resolveManagedCodexNativeCommand as i, resolveMacOSDesktopCodexBundledMarketplaceCandidates as l, managed_binary_exports as n, setManagedCodexPluginRoot as o, resolveManagedCodexAppServerStartOptions as r, resolveFirstExistingMacOSDesktopCodexBundledMarketplacePath as s, isManagedCodexDesktopCommand as t, resolveMacOSDesktopCodexComputerUseServiceAppCandidates as u };