@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/{transport-stdio-Cmx94Oiy.mjs → transport-stdio-Bdegpn2V.mjs}

@@ -1,11 +1,18 @@
-import { r as normalizeCodexAppServerArgs } from "./launch-args-DnMak49W.mjs";
+import { r as normalizeCodexAppServerArgs } from "./launch-args-DbFCehO7.mjs";
+import { i as resolveManagedCodexNativeCommand } from "./managed-binary-kiWRhNRE.mjs";
+import { i as recordCodexAppServerSpawnFailure, r as getCodexAppServerSpawnFailure } from "./spawn-error-CL3n6MAa.mjs";
 import { createHash, randomUUID } from "node:crypto";
+import { stripVTControlCharacters } from "node:util";
+import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-registration";
 import { z } from "zod";
 import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
 import { closeSync, constants, openSync, readSync } from "node:fs";
 import path from "node:path";
 import { readFile, readdir } from "node:fs/promises";
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
 import { once } from "node:events";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 import { execFile, spawn } from "node:child_process";
 import { setImmediate } from "node:timers/promises";
 import { finished } from "node:stream/promises";
@@ -302,6 +309,8 @@ const MAX_PROCESS_QUIESCE_PASSES = 16;
 /** Discharges the registered root obligation, including an already-obsolete PID. */
 async function terminateCodexAppServerOrphan(expected) {
 	const deadline = Date.now() + MAX_PROCESS_CONTAINMENT_MS;
+	const initial = (await readCodexAppServerProcessSnapshot(deadline, [expected.pid])).find((row) => row.pid === expected.pid);
+	if (!initial || !hasSameIdentity(initial, expected) || isDeadProcessState(initial.state)) return true;
 	const result = await terminateCodexAppServerDescendants({
 		pid: expected.pid,
 		kill: (signal) => signalProcess(expected.pid, signal ?? "SIGTERM")
@@ -314,7 +323,7 @@ async function terminateCodexAppServerOrphan(expected) {
 			if (current && isSameLiveRoot(current, contained.root, true)) signalProcess(current.pgid === current.pid ? -current.pid : current.pid, "SIGKILL");
 		}
 		while (Date.now() < deadline) {
-			const snapshot = await readCodexAppServerProcessSnapshot(deadline).catch(() => void 0);
+			const snapshot = await readCodexAppServerProcessSnapshot(deadline, [expected.pid]).catch(() => void 0);
 			if (!snapshot?.some((row) => row.pid === process.pid)) return false;
 			const current = snapshot.find((row) => row.pid === expected.pid);
 			if (!current || !hasSameIdentity(current, expected) || isDeadProcessState(current.state)) {
@@ -531,21 +540,37 @@ const registrationSchema = z.object({
 	parent: processIdentity,
 	child: childIdentity
 }).strict();
+const registrationCleanup = /* @__PURE__ */ new WeakMap();
+const processReaper = resolveGlobalSingleton(Symbol.for("openclaw.codexAppServerProcessReaper"), () => new KeyedAsyncQueue());
+/** Join bookkeeping after the transport owner has observed physical exit. */
+async function waitForCodexAppServerProcessRegistrationCleanup(child) {
+	await registrationCleanup.get(child);
+}
 function fingerprintProcessCommand(command) {
 	return createHash("sha256").update(command).digest("hex");
 }
 async function openProcessRegistrationStore() {
-	const { createPluginStateSyncKeyedStore } = await import("openclaw/plugin-sdk/plugin-state-store-runtime");
-	return createPluginStateSyncKeyedStore("codex", {
+	const env = {
+		...process.env,
+		OPENCLAW_STATE_DIR: resolveStateDir()
+	};
+	const { createPluginStateKeyedStore } = await import("openclaw/plugin-sdk/plugin-state-store-runtime");
+	return createPluginStateKeyedStore("codex", {
 		namespace: "app-server-processes",
 		maxEntries: 512,
-		overflowPolicy: "reject-new"
+		overflowPolicy: "reject-new",
+		env
 	});
 }
 async function reapRegisteredCodexAppServerOrphans() {
 	const store = await openProcessRegistrationStore();
+	await processReaper.enqueue("orphans", () => sweepRegisteredCodexAppServerOrphans(store));
+	return store;
+}
+async function sweepRegisteredCodexAppServerOrphans(store) {
+	const entries = await store.entries();
 	const deadline = Date.now() + PROCESS_REGISTRATION_INSPECTION_MS;
-	for (const entry of store.entries()) {
+	for (const entry of entries) {
 		if (Date.now() >= deadline) throw new Error("Codex orphan cleanup exceeded its startup budget. Retry to finish cleanup.");
 		const registration = registrationSchema.parse(entry.value);
 		const snapshot = await readCodexAppServerProcessSnapshot(deadline, [registration.parent.pid, registration.child.pid]);
@@ -557,29 +582,34 @@ async function reapRegisteredCodexAppServerOrphans() {
 			try {
 				command = await readCodexAppServerProcessCommand(child, deadline);
 			} catch (error) {
-				if ((await readCodexAppServerProcessSnapshot(deadline, [registration.child.pid])).find((row) => row.pid === registration.child.pid)?.startedAt === registration.child.startedAt) throw error;
+				const current = (await readCodexAppServerProcessSnapshot(deadline, [registration.child.pid])).find((row) => row.pid === registration.child.pid);
+				if (current?.startedAt === registration.child.startedAt && !isDeadProcessState(current.state)) throw error;
 			}
 			if (command !== void 0 && fingerprintProcessCommand(command) !== registration.child.commandFingerprint) {
-				store.delete(entry.key);
+				await store.delete(entry.key);
 				continue;
 			}
 		}
 		if (!await terminateCodexAppServerOrphan(registration.child)) throw new Error(`Cannot reap registered Codex process ${registration.child.pid}. Stop it before retrying.`);
-		store.delete(entry.key);
+		await store.delete(entry.key);
 	}
 }
 function createCodexAppServerProcessReaperService() {
+	let pendingSweep;
 	return {
 		id: "codex-app-server-process-reaper",
 		start(ctx) {
 			if (process.platform === "win32") return;
-			(async () => {
+			pendingSweep = (async () => {
 				try {
 					await reapRegisteredCodexAppServerOrphans();
 				} catch (error) {
 					ctx.logger.warn(`Codex app-server orphan cleanup failed: ${String(error)}`);
 				}
 			})();
+		},
+		async stop() {
+			await pendingSweep;
 		}
 	};
 }
@@ -588,8 +618,7 @@ async function prepareCodexAppServerProcessRegistration() {
 	if (process.platform === "win32") return async (child) => {
 		await once(child, "spawn");
 	};
-	await reapRegisteredCodexAppServerOrphans();
-	const store = await openProcessRegistrationStore();
+	const store = await reapRegisteredCodexAppServerOrphans();
 	return async (child) => {
 		await once(child, "spawn");
 		if (!child.pid) throw new ProcessInspectionError("unavailable");
@@ -601,21 +630,63 @@ async function prepareCodexAppServerProcessRegistration() {
 		const command = await readCodexAppServerProcessCommand(spawned, deadline);
 		if (child.exitCode !== null || child.signalCode !== null) throw new Error("Cannot register the Codex child process command: the child exited during inspection. Retry.");
 		const key = randomUUID();
-		store.register(key, {
+		const value = {
 			parent: processIdentity.parse(parent),
 			child: childIdentity.parse({
 				...spawned,
 				commandFingerprint: fingerprintProcessCommand(command)
 			})
+		};
+		const exited = new Promise((resolve) => {
+			child.once("exit", () => resolve());
 		});
-		child.once("exit", () => {
+		const registered = store.register(key, value);
+		const cleanup = (async () => {
+			await exited;
+			await registered.catch(() => void 0);
 			try {
-				store.delete(key);
+				await store.delete(key);
 			} catch {}
-		});
+		})();
+		registrationCleanup.set(child, cleanup);
+		await registered;
+		if (child.exitCode !== null || child.signalCode !== null) {
+			await cleanup;
+			throw new Error("Cannot register the Codex child process: the child exited during registration. Retry.");
+		}
 	};
 }
 //#endregion
+//#region extensions/codex/src/app-server/managed-launcher-failure.ts
+/** The official npm launcher prints Node's native spawn error and exits before initialization. */
+function observeManagedCodexLauncherFailure(child, nativeCommand) {
+	let prefix = "";
+	let launchCode;
+	const startupFailure = { complete() {
+		child.stderr.off("data", onData);
+		child.off("exit", onExit);
+		prefix = "";
+	} };
+	const onData = (chunk) => {
+		if (launchCode || prefix.length >= 16384) return;
+		prefix = (prefix + stripVTControlCharacters(chunk.toString())).slice(0, 16384);
+		if (/\bError: spawn\b/u.test(prefix) && /syscall: ['"]spawn(?: [^'"\r\n]*)?['"]/u.test(prefix)) launchCode = /\bcode: ['"](ENOENT|EACCES|EBADARCH|Unknown system error -86)['"]/u.exec(prefix)?.[1];
+		else if (/Error: Missing optional dependency @openai\/codex-[\w-]+\. Reinstall Codex:/u.test(prefix)) launchCode = "ENOENT";
+	};
+	const onExit = (code) => {
+		startupFailure.complete();
+		if (code !== 1 || !launchCode) return;
+		const described = recordCodexAppServerSpawnFailure(Object.assign(/* @__PURE__ */ new Error(`spawn ${launchCode}`), {
+			code: launchCode,
+			syscall: "spawn"
+		}), nativeCommand, nativeCommand);
+		if (described instanceof Error) startupFailure.error = described;
+	};
+	child.stderr.on("data", onData);
+	child.once("exit", onExit);
+	Object.assign(child, { startupFailure });
+}
+//#endregion
 //#region extensions/codex/src/app-server/transport.ts
 /**
 * Shared transport lifecycle helpers for stdio and WebSocket Codex app-server
@@ -645,12 +716,7 @@ function beginCodexAppServerTransportClose(child, options) {
 				finishCodexAppServerTransportClose(child, options, forceKill);
 				return "uncertain";
 			}
-			let contained;
-			try {
-				contained = await terminateCodexAppServerDescendants(child);
-			} catch {
-				contained = void 0;
-			}
+			const contained = await terminateCodexAppServerDescendants(child).catch(() => void 0);
 			if (contained === "exited") return "natural";
 			try {
 				finishCodexAppServerTransportClose(child, options, forceKill, contained?.resume);
@@ -696,6 +762,7 @@ async function closeCodexAppServerTransportAndWait(child, options = {}) {
 	const closure = beginCodexAppServerTransportClose(child, options);
 	const containment = await closure.closing;
 	const settled = await waitForCodexAppServerTransportExit(child, options.exitTimeoutMs ?? 2e3, drained);
+	if (settled) await waitForCodexAppServerProcessRegistrationCleanup(child);
 	closure.naturalExit = containment === "natural" && settled;
 	if (options.drainStdio) {
 		child.stdout.destroy?.();
@@ -710,7 +777,7 @@ async function closeCodexAppServerTransportAndWait(child, options = {}) {
 	};
 }
 function hasCodexAppServerTransportExited(child) {
-	return child.exitCode !== null && child.exitCode !== void 0 ? true : child.signalCode !== null && child.signalCode !== void 0;
+	return child.exitCode != null || child.signalCode != null;
 }
 async function waitForCodexAppServerTransportExit(child, timeoutMs, drained) {
 	return await new Promise((resolve) => {
@@ -756,46 +823,36 @@ const RUNTIME_INJECTION_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([
 	"LD_PRELOAD"
 ]);
 const QA_PARENT_PID_ENV = "OPENCLAW_QA_PARENT_PID";
-const DEFAULT_SPAWN_RUNTIME = {
-	platform: process.platform,
-	env: process.env,
-	execPath: process.execPath,
-	isBun: typeof process.versions.bun === "string"
-};
 /** Resolves the concrete command/argv/shell settings used to spawn Codex app-server. */
-function resolveCodexAppServerSpawnInvocation(options, runtime = DEFAULT_SPAWN_RUNTIME) {
+function resolveCodexAppServerSpawnInvocation(options, env) {
 	if (options.commandSource === "managed") throw new Error("Managed Codex app-server start options must be resolved before spawn.");
 	const program = resolveWindowsSpawnProgram({
 		command: options.command,
-		platform: runtime.platform,
-		env: runtime.env,
-		execPath: runtime.execPath,
+		platform: process.platform,
+		env,
+		execPath: process.execPath,
 		packageName: "@openai/codex"
 	});
 	const args = normalizeCodexAppServerArgs(options.args);
 	const resolved = materializeWindowsSpawnProgram(program, args);
-	if (runtime.isBun && options.commandSource === "resolved-managed" && resolved.resolution === "direct" && [
+	if (options.commandSource === "resolved-managed" && resolved.resolution === "direct" && [
 		".cjs",
 		".js",
 		".mjs"
 	].includes(path.extname(resolved.command).toLowerCase())) return {
-		command: runtime.execPath,
-		args: [resolved.command, ...resolved.argv],
-		windowsHide: resolved.windowsHide
-	};
-	return {
-		command: resolved.command,
-		args: resolved.argv,
-		shell: resolved.shell,
-		windowsHide: resolved.windowsHide
+		...resolved,
+		command: process.execPath,
+		argv: [resolved.command, ...resolved.argv],
+		resolution: "node-entrypoint"
 	};
+	return resolved;
 }
 /** Merges app-server environment overrides while honoring clearEnv and unsafe key filtering. */
 function resolveCodexAppServerSpawnEnv(options, baseEnv = process.env, platform = process.platform) {
 	const env = Object.create(null);
 	copySafeEnvironmentEntries(env, baseEnv);
 	copySafeEnvironmentEntries(env, options.env ?? {});
-	const keysToClear = normalizedEnvironmentKeys(options.clearEnv ?? []);
+	const keysToClear = (options.clearEnv ?? []).map((key) => key.trim()).filter(Boolean);
 	if (platform === "win32") {
 		const lowerCaseKeysToClear = new Set(keysToClear.map((key) => key.toLowerCase()));
 		for (const candidate of Object.keys(env)) if (lowerCaseKeysToClear.has(candidate.toLowerCase())) delete env[candidate];
@@ -807,18 +864,6 @@ function isCodexRuntimeInjectionEnvironmentKey(rawKey) {
 	const key = rawKey.toUpperCase();
 	return RUNTIME_INJECTION_ENVIRONMENT_KEYS.has(key) || key.startsWith("DYLD_");
 }
-/** Keeps QA-owned app-server processes inside the gateway process-group cleanup boundary. */
-function resolveCodexAppServerDetachedMode(env, platform = process.platform) {
-	return platform !== "win32" && !env[QA_PARENT_PID_ENV]?.trim();
-}
-function normalizedEnvironmentKeys(rawKeys) {
-	const keys = [];
-	for (const rawKey of rawKeys) {
-		const key = rawKey.trim();
-		if (key.length > 0) keys.push(key);
-	}
-	return keys;
-}
 function copySafeEnvironmentEntries(target, source) {
 	for (const [key, value] of Object.entries(source)) {
 		if (UNSAFE_ENVIRONMENT_KEYS.has(key)) continue;
@@ -828,27 +873,45 @@ function copySafeEnvironmentEntries(target, source) {
 /** Spawns the Codex app-server process and returns the shared transport interface. */
 async function createStdioTransport(options, baseEnv = process.env, assertCurrent, onSpawn) {
 	const env = resolveCodexAppServerSpawnEnv(options, baseEnv);
-	const invocation = resolveCodexAppServerSpawnInvocation(options, {
-		platform: process.platform,
-		env,
-		execPath: process.execPath,
-		isBun: typeof process.versions.bun === "string"
-	});
+	const invocation = resolveCodexAppServerSpawnInvocation(options, env);
+	const nativeCommand = options.commandSource === "resolved-managed" ? resolveManagedCodexNativeCommand(options.command, { pathExists: () => true }) : void 0;
+	const launchKey = JSON.stringify([
+		invocation.command,
+		options.cwd ?? process.cwd(),
+		nativeCommand ?? null,
+		path.isAbsolute(invocation.command) ? null : env.PATH ?? env.Path
+	]);
+	const previousFailure = getCodexAppServerSpawnFailure(launchKey) ?? (nativeCommand ? getCodexAppServerSpawnFailure(nativeCommand) : void 0);
+	if (previousFailure) throw previousFailure;
 	const register = await prepareCodexAppServerProcessRegistration();
 	assertCurrent?.();
-	const child = spawn(invocation.command, invocation.args, {
-		...options.cwd !== void 0 ? { cwd: options.cwd } : {},
-		env,
-		detached: resolveCodexAppServerDetachedMode(env),
-		shell: invocation.shell,
-		stdio: [
-			"pipe",
-			"pipe",
-			"pipe"
-		],
-		windowsHide: invocation.windowsHide
+	embeddedAgentLog.debug("Codex app-server spawn", {
+		command: invocation.command,
+		launcher: options.command,
+		...options.cwd ? { cwd: options.cwd } : {},
+		...nativeCommand ? { nativeCommand } : {},
+		platform: process.platform,
+		arch: process.arch
 	});
+	let child;
+	try {
+		child = spawn(invocation.command, invocation.argv, {
+			...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+			env,
+			detached: process.platform !== "win32" && !env[QA_PARENT_PID_ENV]?.trim(),
+			shell: invocation.shell,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			windowsHide: invocation.windowsHide
+		});
+	} catch (error) {
+		throw recordCodexAppServerSpawnFailure(error, invocation.command, launchKey);
+	}
 	try {
+		if (nativeCommand && invocation.resolution === "node-entrypoint") observeManagedCodexLauncherFailure(child, nativeCommand);
 		onSpawn?.(child);
 		await register(child);
 		assertCurrent?.();
@@ -856,8 +919,8 @@ async function createStdioTransport(options, baseEnv = process.env, assertCurren
 	} catch (error) {
 		await closeCodexAppServerTransportAndWait(child, { drainStdio: true });
 		assertCurrent?.();
-		throw error;
+		throw child.startupFailure?.error ?? recordCodexAppServerSpawnFailure(error, invocation.command, launchKey);
 	}
 }
 //#endregion
-export { hasCodexAppServerNaturalExit as a, closeCodexAppServerTransportAndWait as i, resolveCodexAppServerSpawnEnv as n, createCodexAppServerProcessReaperService as o, closeCodexAppServerTransport as r, createStdioTransport as t };
+export { closeCodexAppServerTransportAndWait as a, closeCodexAppServerTransport as i, resolveCodexAppServerSpawnEnv as n, hasCodexAppServerNaturalExit as o, resolveCodexAppServerSpawnInvocation as r, createCodexAppServerProcessReaperService as s, createStdioTransport as t };

package/dist/.setup/transport-websocket-BTBE-LD9.mjs

@@ -0,0 +1,211 @@
+import { r as resolveCodexAppServerUserHomeDir } from "./auth-start-options-BPIPeEX8.mjs";
+import "./config-DKhXquav.mjs";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+import net from "node:net";
+import { PassThrough, Writable } from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+import { WebSocket } from "openclaw/plugin-sdk/websocket-runtime";
+//#region extensions/codex/src/app-server/transport-websocket.ts
+/**
+* Adapts a remote Codex app-server WebSocket endpoint to the shared stdio-like
+* transport interface.
+*/
+const WEBSOCKET_HANDSHAKE_TIMEOUT_MS = 1e4;
+const WEBSOCKET_PING_INTERVAL_MS = 2e4;
+const WEBSOCKET_PONG_TIMEOUT_MS = 2e4;
+const MAX_CONSECUTIVE_MISSED_WEBSOCKET_PONGS = 5;
+/** Only the transport can prove that its buffered initialize never reached a peer. */
+function isCodexWebSocketOpenFailure(error) {
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	while (current instanceof Error && !seen.has(current)) {
+		seen.add(current);
+		if ("code" in current && current.code === "CODEX_APP_SERVER_WEBSOCKET_OPEN_FAILED") return true;
+		current = current.cause;
+	}
+	return false;
+}
+/** Opens a WebSocket app-server transport and maps newline-delimited frames to stdout/stdin. */
+function createWebSocketTransport(options) {
+	if (!options.url) throw new Error("codex app-server websocket transport requires plugins.entries.codex.config.appServer.url");
+	const events = new EventEmitter();
+	const stdout = new PassThrough();
+	const stderr = new PassThrough();
+	const websocketOptions = {
+		headers: {
+			...options.headers,
+			...options.authToken ? { Authorization: `Bearer ${options.authToken}` } : {}
+		},
+		perMessageDeflate: false,
+		...options.transport === "websocket" ? { handshakeTimeout: WEBSOCKET_HANDSHAKE_TIMEOUT_MS } : {}
+	};
+	const unixSocketPath = resolveCodexAppServerUnixSocketPath(options);
+	const socket = unixSocketPath ? new WebSocket("ws://localhost/", {
+		...websocketOptions,
+		createConnection: () => connectCodexAppServerUnixSocket(unixSocketPath)
+	}) : new WebSocket(options.url, websocketOptions);
+	const pendingFrames = [];
+	const stdinDecoder = new StringDecoder("utf8");
+	let pendingLine = "";
+	let opened = false;
+	let killed = false;
+	let exitCode = null;
+	let pingTimeout;
+	let pongTimeout;
+	let expectedPong;
+	let consecutiveMissedPongs = 0;
+	let heartbeatSequence = 0;
+	const clearConnectionHealthTimers = () => {
+		if (pingTimeout) {
+			clearTimeout(pingTimeout);
+			pingTimeout = void 0;
+		}
+		if (pongTimeout) {
+			clearTimeout(pongTimeout);
+			pongTimeout = void 0;
+		}
+		expectedPong = void 0;
+	};
+	const sendHeartbeatPing = () => {
+		if (socket.readyState !== WebSocket.OPEN || pongTimeout) return;
+		const payload = Buffer.from(`openclaw-codex-${++heartbeatSequence}`);
+		expectedPong = payload;
+		pongTimeout = setTimeout(() => {
+			pongTimeout = void 0;
+			expectedPong = void 0;
+			consecutiveMissedPongs += 1;
+			if (consecutiveMissedPongs >= MAX_CONSECUTIVE_MISSED_WEBSOCKET_PONGS) {
+				socket.terminate();
+				return;
+			}
+			sendHeartbeatPing();
+		}, WEBSOCKET_PONG_TIMEOUT_MS);
+		pongTimeout.unref();
+		socket.ping(payload, void 0, (error) => {
+			if (error) socket.terminate();
+		});
+	};
+	const scheduleHeartbeatPing = () => {
+		if (options.transport !== "websocket" || socket.readyState !== WebSocket.OPEN || pingTimeout || pongTimeout) return;
+		pingTimeout = setTimeout(() => {
+			pingTimeout = void 0;
+			sendHeartbeatPing();
+		}, WEBSOCKET_PING_INTERVAL_MS);
+		pingTimeout.unref();
+	};
+	const recordConnectionActivity = () => {
+		consecutiveMissedPongs = 0;
+		if (pongTimeout) {
+			clearTimeout(pongTimeout);
+			pongTimeout = void 0;
+		}
+		expectedPong = void 0;
+		scheduleHeartbeatPing();
+	};
+	const sendFrame = (frame) => {
+		const trimmed = frame.trim();
+		if (!trimmed) return;
+		if (socket.readyState === WebSocket.OPEN) {
+			socket.send(trimmed);
+			return;
+		}
+		pendingFrames.push(trimmed);
+	};
+	socket.once("open", () => {
+		opened = true;
+		for (const frame of pendingFrames.splice(0)) socket.send(frame);
+		scheduleHeartbeatPing();
+	});
+	socket.on("pong", (payload) => {
+		if (expectedPong?.equals(payload)) recordConnectionActivity();
+	});
+	socket.once("error", (error) => {
+		clearConnectionHealthTimers();
+		const code = "code" in error ? error.code : void 0;
+		if (options.transport === "websocket" && !opened && (code === "ECONNREFUSED" || code === "ECONNRESET" || code === "ETIMEDOUT" || error.message === "Opening handshake has timed out")) {
+			events.emit("error", Object.assign(new Error(error.message, { cause: error }), { code: "CODEX_APP_SERVER_WEBSOCKET_OPEN_FAILED" }));
+			return;
+		}
+		events.emit("error", error);
+	});
+	socket.once("close", (code, reason) => {
+		clearConnectionHealthTimers();
+		killed = true;
+		exitCode = code;
+		events.emit("exit", code, reason.toString("utf8"));
+	});
+	socket.on("message", (data) => {
+		if (options.transport === "websocket") recordConnectionActivity();
+		const frame = websocketFrameToBuffer(data);
+		const writable = stdout.write(frame);
+		const delimited = frame.at(-1) === 10 || stdout.write(Buffer.from("\n"));
+		if (!writable || !delimited) socket.pause();
+	});
+	stdout.on("drain", () => {
+		if (socket.readyState === WebSocket.OPEN) socket.resume();
+	});
+	const stdin = new Writable({
+		write(chunk, _encoding, callback) {
+			pendingLine += stdinDecoder.write(chunk);
+			const lines = pendingLine.split("\n");
+			pendingLine = lines.pop() ?? "";
+			for (const frame of lines) sendFrame(frame);
+			callback();
+		},
+		final(callback) {
+			pendingLine += stdinDecoder.end();
+			if (pendingLine) sendFrame(pendingLine);
+			pendingLine = "";
+			callback();
+		}
+	});
+	const closeSocket = () => {
+		if (socket.readyState === WebSocket.CLOSED || socket.readyState === WebSocket.CLOSING) return;
+		socket.close();
+	};
+	stdin.once("finish", closeSocket);
+	stdin.once("close", closeSocket);
+	return {
+		maxFrameBytes: 16777216,
+		stdin,
+		stdout,
+		stderr,
+		get killed() {
+			return killed;
+		},
+		get exitCode() {
+			return exitCode;
+		},
+		kill: (signal) => {
+			killed = true;
+			clearConnectionHealthTimers();
+			if (signal === "SIGKILL") socket.terminate();
+			else socket.close();
+		},
+		once: (event, listener) => events.once(event, listener),
+		off: (event, listener) => events.off(event, listener)
+	};
+}
+/** Named local-only socket boundary for the egress classifier. */
+function connectCodexAppServerUnixSocket(socketPath) {
+	return net.createConnection(socketPath);
+}
+/** Resolves the canonical or explicitly configured Codex control socket. */
+function resolveCodexAppServerUnixSocketPath(options) {
+	if (options.transport !== "unix") {
+		if (options.url?.startsWith("unix://")) throw new Error("codex app-server unix URL requires unix transport");
+		return;
+	}
+	const url = options.url ?? "unix://";
+	if (!url.startsWith("unix://")) throw new Error("codex app-server unix transport requires a unix:// URL");
+	return url.slice(7) || path.join(resolveCodexAppServerUserHomeDir(options.env ?? process.env), "app-server-control", "app-server-control.sock");
+}
+function websocketFrameToBuffer(data) {
+	if (typeof data === "string") return Buffer.from(data);
+	if (Buffer.isBuffer(data)) return data;
+	if (Array.isArray(data)) return Buffer.concat(data);
+	return Buffer.from(data);
+}
+//#endregion
+export { isCodexWebSocketOpenFailure as n, resolveCodexAppServerUnixSocketPath as r, createWebSocketTransport as t };

package/dist/.setup/{upstream-prompt-provenance-LphB8slG.mjs → upstream-prompt-provenance-fXkKbPVC.mjs}

@@ -1,4 +1,4 @@
-import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asOptionalRecord, readNonEmptyStringPreservingWhitespace } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/upstream-prompt-provenance.ts
 const UPSTREAM_USER_TEXT_META_KEY = "upstreamUserText";
 const MIRROR_IDENTITY_META_KEY = "mirrorIdentity";
@@ -16,10 +16,7 @@ function attachCodexMirrorIdentity(message, identity) {
 }
 function readMirrorIdentity(message) {
 	const meta = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
-	const record = asOptionalRecord(meta);
-	if (!record) return;
-	const id = record[MIRROR_IDENTITY_META_KEY];
-	return typeof id === "string" && id ? id : void 0;
+	return readNonEmptyStringPreservingWhitespace(asOptionalRecord(meta)?.[MIRROR_IDENTITY_META_KEY]);
 }
 function attachUpstreamUserText(message, text) {
 	const existing = CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
@@ -34,10 +31,7 @@ function attachUpstreamUserText(message, text) {
 }
 function readUpstreamUserText(message) {
 	const meta = message && CODEX_META_KEY in message ? message[CODEX_META_KEY] : void 0;
-	const record = asOptionalRecord(meta);
-	if (!record) return;
-	const text = record[UPSTREAM_USER_TEXT_META_KEY];
-	return typeof text === "string" && text ? text : void 0;
+	return readNonEmptyStringPreservingWhitespace(asOptionalRecord(meta)?.[UPSTREAM_USER_TEXT_META_KEY]);
 }
 //#endregion
 export { readUpstreamUserText as i, attachUpstreamUserText as n, readMirrorIdentity as r, attachCodexMirrorIdentity as t };