@openclaw/codex 2026.8.1-beta.2 → 2026.8.1

package/dist/request-BRl5_UfX.js

@@ -1,157 +0,0 @@
-import { _ as withTimeout, a as getLeasedSharedCodexAppServerClient, i as createIsolatedCodexAppServerClient, l as releaseLeasedSharedCodexAppServerClient, p as retireSharedCodexAppServerClientIfCurrent, s as isCodexAppServerStartSelectionChangedError } from "./shared-client-kIBbGjk4.js";
-import { t as resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard-Cmwc9eIk.js";
-//#region extensions/codex/src/app-server/request.ts
-/** Sends one guarded request over a client lease owned by the caller. */
-async function requestCodexAppServerClientJson(params) {
-	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
-		method: params.method,
-		requestParams: params.requestParams,
-		config: params.config,
-		sessionKey: params.sessionKey,
-		sessionId: params.sessionId
-	});
-	if (sandboxBlock) throw new Error(sandboxBlock);
-	const timeoutMs = params.timeoutMs ?? 6e4;
-	return await withTimeout(params.client.request(params.method, params.requestParams, { timeoutMs }), timeoutMs, `codex app-server ${params.method} timed out`);
-}
-async function requestCodexAppServerJson(params) {
-	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
-		method: params.method,
-		requestParams: params.requestParams,
-		config: params.config,
-		sessionKey: params.sessionKey,
-		sessionId: params.sessionId
-	});
-	if (sandboxBlock) throw new Error(sandboxBlock);
-	return await withCodexAppServerJsonClient({
-		...params,
-		timeoutMessage: `codex app-server ${params.method} timed out`
-	}, async (request) => await request({
-		method: params.method,
-		requestParams: params.requestParams
-	}));
-}
-const CODEX_USAGE_ISOLATED_SHUTDOWN = {
-	forceKillDelayMs: 200,
-	exitTimeoutMs: 300
-};
-const CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS = 4e3;
-const CODEX_USAGE_DEADLINE_RESERVE_MS = CODEX_USAGE_ISOLATED_SHUTDOWN.forceKillDelayMs + CODEX_USAGE_ISOLATED_SHUTDOWN.exitTimeoutMs + 250;
-/** Reads rate limits and best-effort account identity from one isolated app-server session. */
-async function readCodexAppServerUsage(options) {
-	const deadline = Date.now() + options.timeoutMs;
-	return await withCodexAppServerJsonClient({
-		timeoutMs: options.timeoutMs,
-		timeoutMessage: "codex app-server usage read timed out",
-		agentDir: options.agentDir,
-		...options.authProfileId ? { authProfileId: options.authProfileId } : {},
-		config: options.config,
-		startOptions: options.startOptions,
-		isolated: true,
-		isolatedShutdown: CODEX_USAGE_ISOLATED_SHUTDOWN
-	}, async (request) => {
-		const rateLimits = await request({ method: "account/rateLimits/read" });
-		const accountEmail = await readCodexAccountEmailBestEffort(request, deadline);
-		return {
-			rateLimits,
-			...accountEmail ? { accountEmail } : {}
-		};
-	});
-}
-function extractCodexAccountEmail(value) {
-	if (!value || typeof value !== "object") return;
-	const record = value;
-	const account = record.account && typeof record.account === "object" ? record.account : record;
-	const email = account.email ?? account.accountEmail;
-	return typeof email === "string" && email.trim() ? email.trim() : void 0;
-}
-async function readCodexAccountEmailBestEffort(request, deadline) {
-	const boundMs = Math.min(CODEX_ACCOUNT_READ_MAX_TIMEOUT_MS, deadline - Date.now() - CODEX_USAGE_DEADLINE_RESERVE_MS);
-	if (boundMs <= 0) return;
-	const read = request({
-		method: "account/read",
-		requestParams: {}
-	}).then((account) => extractCodexAccountEmail(account), () => void 0);
-	let timer;
-	const timeout = new Promise((resolve) => {
-		timer = setTimeout(() => resolve(void 0), boundMs);
-		timer.unref?.();
-	});
-	try {
-		return await Promise.race([read, timeout]);
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
-}
-/**
-* Runs several guarded requests over one acquired client (shared lease or
-* isolated child) so related reads see the same app-server session. The whole
-* callback re-runs once when the client's start selection changed underneath it.
-*/
-async function withCodexAppServerJsonClient(params, run) {
-	const timeoutMs = params.timeoutMs ?? 6e4;
-	const timeoutMessage = params.timeoutMessage ?? "codex app-server request timed out";
-	const timeoutController = new AbortController();
-	const deadline = Number.isFinite(timeoutMs) && timeoutMs > 0 ? Date.now() + timeoutMs : void 0;
-	const isPastDeadline = () => deadline !== void 0 && Date.now() >= deadline;
-	const throwIfAbandoned = () => {
-		if (timeoutController.signal.aborted || isPastDeadline()) throw new Error(timeoutMessage);
-	};
-	const remainingTimeoutMs = () => {
-		throwIfAbandoned();
-		return deadline === void 0 ? timeoutMs : Math.max(1, deadline - Date.now());
-	};
-	try {
-		return await withTimeout((async () => {
-			for (let attempt = 0; attempt < 2; attempt += 1) {
-				throwIfAbandoned();
-				const client = await (params.isolated ? createIsolatedCodexAppServerClient : getLeasedSharedCodexAppServerClient)({
-					startOptions: params.startOptions,
-					pluginConfig: params.pluginConfig,
-					timeoutMs: remainingTimeoutMs(),
-					authProfileId: params.authProfileId,
-					agentDir: params.agentDir,
-					config: params.config,
-					abandonSignal: timeoutController.signal
-				});
-				try {
-					throwIfAbandoned();
-					const scopedRequest = async (request) => {
-						const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
-							method: request.method,
-							requestParams: request.requestParams,
-							config: params.config,
-							sessionKey: params.sessionKey,
-							sessionId: params.sessionId
-						});
-						if (sandboxBlock) throw new Error(sandboxBlock);
-						throwIfAbandoned();
-						return await client.request(request.method, request.requestParams, {
-							timeoutMs: remainingTimeoutMs(),
-							signal: timeoutController.signal
-						});
-					};
-					return await run(scopedRequest, client);
-				} catch (error) {
-					if (!isCodexAppServerStartSelectionChangedError(error) || attempt > 0) throw error;
-					if (!params.isolated) retireSharedCodexAppServerClientIfCurrent(client);
-					throwIfAbandoned();
-				} finally {
-					if (params.isolated) await client.closeAndWait({
-						exitTimeoutMs: params.isolatedShutdown?.exitTimeoutMs ?? 2e3,
-						forceKillDelayMs: params.isolatedShutdown?.forceKillDelayMs ?? 250
-					});
-					else releaseLeasedSharedCodexAppServerClient(client);
-				}
-			}
-			throw new Error("Codex app-server selection retry loop exited unexpectedly");
-		})(), timeoutMs, timeoutMessage);
-	} catch (error) {
-		if (isPastDeadline()) throw new Error(timeoutMessage, { cause: error });
-		throw error;
-	} finally {
-		timeoutController.abort();
-	}
-}
-//#endregion
-export { withCodexAppServerJsonClient as i, requestCodexAppServerClientJson as n, requestCodexAppServerJson as r, readCodexAppServerUsage as t };

package/dist/session-retirement-DoMMJFKm.js

@@ -1,36 +0,0 @@
-import { K as releaseCodexAppServerLiveThread, d as retainSharedCodexAppServerClientByInstanceId } from "./shared-client-kIBbGjk4.js";
-import { a as closeCodexStartupClientBestEffort, d as unsubscribeCodexThreadBestEffort, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-DMLXUfa8.js";
-import { t as isIncognitoSessionKey } from "./incognito-session-ET_ufDH-.js";
-import { t as codexNativeSubagentMonitorRuntime } from "./native-subagent-monitor-DyTGmTUx.js";
-//#region extensions/codex/src/app-server/session-retirement.ts
-/** Retire binding and native subscription under the same generation/physical-client ownership fence. */
-async function retireCodexAppServerSessionGeneration(params) {
-	const retireGeneration = () => params.mode === "reset" ? params.bindingStore.resetSessionGeneration(params.identity) : params.bindingStore.retireSessionGeneration(params.identity);
-	const expectedBinding = await params.bindingStore.read(params.identity);
-	if (!expectedBinding) return await retireGeneration();
-	return await params.bindingStore.withLease(params.identity, async () => {
-		const binding = await params.bindingStore.read(params.identity);
-		if (binding?.threadId !== expectedBinding.threadId) return "conflict";
-		const result = await retireGeneration();
-		if (result !== "applied" || !binding?.clientId) return result;
-		const clientLease = retainSharedCodexAppServerClientByInstanceId(binding.clientId);
-		if (!clientLease) return result;
-		try {
-			codexNativeSubagentMonitorRuntime.retireParent(clientLease.client, binding.threadId);
-			if (!await releaseCodexAppServerLiveThread(clientLease.client, binding.threadId) && isIncognitoSessionKey(params.identity.sessionKey)) {
-				if (!await unsubscribeCodexThreadBestEffort(clientLease.client, {
-					threadId: binding.threadId,
-					timeoutMs: 5e3
-				})) {
-					await closeCodexStartupClientBestEffort(clientLease.client);
-					throw new CodexAppServerUnsafeSubscriptionError(`Codex retired session subscription could not be released: ${binding.threadId}`);
-				}
-			}
-		} finally {
-			clientLease.release();
-		}
-		return result;
-	});
-}
-//#endregion
-export { retireCodexAppServerSessionGeneration };

package/dist/thread-resume-CPrJNQVM.js

@@ -1,30 +0,0 @@
-import { F as isCodexAppServerPrewriteRequestCancellationError, s as isCodexAppServerStartSelectionChangedError, z as CodexAppServerRpcError } from "./shared-client-kIBbGjk4.js";
-import { i as assertCodexThreadResumeSubscription, r as CodexAppServerUnsafeSubscriptionError } from "./attempt-client-cleanup-DMLXUfa8.js";
-import { i as assertCodexThreadResumeResponse } from "./protocol-validators-B4F7L8Rf.js";
-//#region extensions/codex/src/app-server/thread-resume.ts
-/** Owns Codex thread/resume subscription safety. */
-/** Resumes one thread and retires the physical client when acceptance is indeterminate. */
-async function resumeCodexAppServerThread(params) {
-	const threadId = params.request.threadId;
-	let response;
-	try {
-		response = assertCodexThreadResumeResponse(await params.client.request("thread/resume", params.request, {
-			...params.timeoutMs !== void 0 ? { timeoutMs: params.timeoutMs } : {},
-			...params.signal ? { signal: params.signal } : {}
-		}));
-		assertCodexThreadResumeSubscription(threadId, response.thread.id);
-	} catch (error) {
-		if (isCodexAppServerStartSelectionChangedError(error) || isCodexAppServerPrewriteRequestCancellationError(error)) throw error;
-		if (error instanceof CodexAppServerRpcError) throw error;
-		try {
-			await params.abandonClient();
-		} catch (abandonError) {
-			throw new CodexAppServerUnsafeSubscriptionError(`Codex thread/resume client could not be retired for ${threadId}`, { cause: abandonError });
-		}
-		if (error instanceof CodexAppServerUnsafeSubscriptionError) throw error;
-		throw new CodexAppServerUnsafeSubscriptionError(error instanceof Error ? error.message : `Codex thread/resume outcome is indeterminate for ${threadId}`, { cause: error });
-	}
-	return response;
-}
-//#endregion
-export { resumeCodexAppServerThread as t };

package/dist/transport-stdio-DIImwDVS.js

@@ -1,99 +0,0 @@
-import { materializeWindowsSpawnProgram, resolveWindowsSpawnProgram } from "openclaw/plugin-sdk/windows-spawn";
-import { spawn } from "node:child_process";
-//#region extensions/codex/src/app-server/transport-stdio.ts
-/**
-* Creates and configures stdio-backed Codex app-server transports, including
-* Windows spawn normalization and environment filtering.
-*/
-const UNSAFE_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([
-	"__proto__",
-	"constructor",
-	"prototype"
-]);
-const RUNTIME_INJECTION_ENVIRONMENT_KEYS = /* @__PURE__ */ new Set([
-	"NODE_PATH",
-	"LD_AUDIT",
-	"LD_LIBRARY_PATH",
-	"LD_PRELOAD"
-]);
-const QA_PARENT_PID_ENV = "OPENCLAW_QA_PARENT_PID";
-const DEFAULT_SPAWN_RUNTIME = {
-	platform: process.platform,
-	env: process.env,
-	execPath: process.execPath
-};
-/** Resolves the concrete command/argv/shell settings used to spawn Codex app-server. */
-function resolveCodexAppServerSpawnInvocation(options, runtime = DEFAULT_SPAWN_RUNTIME) {
-	if (options.commandSource === "managed") throw new Error("Managed Codex app-server start options must be resolved before spawn.");
-	const resolved = materializeWindowsSpawnProgram(resolveWindowsSpawnProgram({
-		command: options.command,
-		platform: runtime.platform,
-		env: runtime.env,
-		execPath: runtime.execPath,
-		packageName: "@openai/codex"
-	}), options.args);
-	return {
-		command: resolved.command,
-		args: resolved.argv,
-		shell: resolved.shell,
-		windowsHide: resolved.windowsHide
-	};
-}
-/** 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 ?? []);
-	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];
-	} else for (const key of keysToClear) delete env[key];
-	for (const key of Object.keys(env)) if (isCodexRuntimeInjectionEnvironmentKey(key)) delete env[key];
-	return env;
-}
-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;
-		target[key] = value;
-	}
-}
-/** Spawns the Codex app-server process and returns the shared transport interface. */
-function createStdioTransport(options) {
-	const env = resolveCodexAppServerSpawnEnv(options);
-	const invocation = resolveCodexAppServerSpawnInvocation(options, {
-		platform: process.platform,
-		env,
-		execPath: process.execPath
-	});
-	return 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
-	});
-}
-//#endregion
-export { resolveCodexAppServerSpawnEnv as n, createStdioTransport as t };