@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/{request-BioXJLYa.mjs → request-BHZ1nz8d.mjs}

@@ -1,5 +1,6 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { i as CodexAppServerRpcError, n as withTimeout, t as withAbortableTimeout } from "./timeout-DZF05XrR.mjs";
+import { n as CodexAppServerRpcError } from "./rpc-error-BlD2vuzn.mjs";
+import { i as withTimeout, r as withAbortableTimeout } from "./timeout-CXOfNoaX.mjs";
+import { t as __exportAll } from "./session-binding-sidecars-jo6H8dFr.mjs";
 //#region extensions/codex/src/app-server/request.ts
 var request_exports = /* @__PURE__ */ __exportAll({
 	CodexAppServerScopedRequestRejectedError: () => CodexAppServerScopedRequestRejectedError,
@@ -28,7 +29,7 @@ async function requestCodexAppServerClientJson(params) {
 	let phase = "prepare";
 	observeControlPhase(params.controlObservation, phase);
 	try {
-		const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
+		const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
 		const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 			method: params.method,
 			requestParams: params.requestParams,
@@ -57,7 +58,7 @@ async function requestCodexAppServerClientJson(params) {
 }
 async function requestCodexAppServerJson(params) {
 	observeControlPhase(params.controlObservation, "prepare");
-	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
+	const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
 	const sandboxBlock = resolveCodexAppServerDirectSandboxBypassBlock({
 		method: params.method,
 		requestParams: params.requestParams,
@@ -81,6 +82,15 @@ var CodexAppServerScopedRequestRejectedError = class extends Error {
 		this.name = "CodexAppServerScopedRequestRejectedError";
 	}
 };
+function createScopeCleanupError(message) {
+	const stackTraceLimit = Error.stackTraceLimit;
+	try {
+		Error.stackTraceLimit = 0;
+		return new CodexAppServerScopedRequestRejectedError(message);
+	} finally {
+		Error.stackTraceLimit = stackTraceLimit;
+	}
+}
 function assertRequestOwnerCurrent(assertCurrent) {
 	try {
 		assertCurrent?.();
@@ -99,6 +109,7 @@ async function readCodexAppServerUsage(options) {
 	const deadline = performance.now() + options.timeoutMs;
 	return await withCodexAppServerJsonClient({
 		timeoutMs: options.timeoutMs,
+		signal: options.signal,
 		timeoutMessage: "codex app-server usage read timed out",
 		agentDir: options.agentDir,
 		...options.authProfileId ? { authProfileId: options.authProfileId } : {},
@@ -118,20 +129,13 @@ async function readCodexAppServerUsage(options) {
 		};
 	});
 }
-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 - performance.now() - CODEX_USAGE_DEADLINE_RESERVE_MS);
 	if (boundMs <= 0) return;
 	const read = request({
 		method: "account/read",
 		requestParams: {}
-	}).then((account) => extractCodexAccountEmail(account), () => void 0);
+	}).then(({ account }) => account?.type === "chatgpt" ? account.email?.trim() || void 0 : void 0, () => void 0);
 	let timer;
 	const timeout = new Promise((resolve) => {
 		timer = setTimeout(() => resolve(void 0), boundMs);
@@ -155,6 +159,9 @@ async function withCodexAppServerJsonClient(params, run) {
 	let errorPhase;
 	observeControlPhase(params.controlObservation, activePhase);
 	const timeoutController = new AbortController();
+	const abort = () => timeoutController.abort(params.signal?.reason);
+	params.signal?.addEventListener("abort", abort, { once: true });
+	if (params.signal?.aborted) abort();
 	const deadline = Number.isFinite(timeoutMs) && timeoutMs > 0 ? performance.now() + timeoutMs : void 0;
 	const isPastDeadline = () => deadline !== void 0 && performance.now() >= deadline;
 	const throwIfAbandoned = () => {
@@ -166,13 +173,14 @@ async function withCodexAppServerJsonClient(params, run) {
 		return deadline === void 0 ? timeoutMs : Math.max(1, deadline - performance.now());
 	};
 	try {
+		throwIfAbandoned();
 		return await withAbortableTimeout({
 			signal: timeoutController.signal,
 			timeoutMs,
 			timeoutMessage,
 			promise: (async () => {
-				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-BBP-RbTf.mjs").then((n) => n.r);
-				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-BpTtuLQ5.mjs").then((n) => n.y);
+				const { resolveCodexAppServerDirectSandboxBypassBlock } = await import("./sandbox-guard-DjCz2eOw.mjs").then((n) => n.r);
+				const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, isCodexAppServerStartSelectionChangedError, releaseLeasedSharedCodexAppServerClient, retireSharedCodexAppServerClientIfCurrent } = await import("./shared-client-DqyTMYug.mjs").then((n) => n.v);
 				for (let attempt = 0; attempt < 2; attempt += 1) {
 					errorPhase = void 0;
 					activePhase = "prepare";
@@ -225,7 +233,7 @@ async function withCodexAppServerJsonClient(params, run) {
 								timeoutMs: remainingTimeoutMs(),
 								signal: timeoutController.signal,
 								...attemptWaiterFinished ? { attemptWaiterFinished } : {},
-								...params.catalogPreview && method === "thread/list" ? {
+								...params.catalogPreview ? {
 									catalogPreview: true,
 									catalogPreviewCache: params.catalogPreviewCache,
 									catalogRows: params.catalogRows
@@ -285,7 +293,8 @@ async function withCodexAppServerJsonClient(params, run) {
 		if (deadlineObserved) throw new Error(timeoutMessage, { cause: error });
 		throw error;
 	} finally {
-		timeoutController.abort(new CodexAppServerScopedRequestRejectedError(timeoutMessage));
+		params.signal?.removeEventListener("abort", abort);
+		timeoutController.abort(createScopeCleanupError(timeoutMessage));
 	}
 }
 //#endregion

package/dist/.setup/responses-oauth-twnuTaAa.mjs

@@ -0,0 +1,93 @@
+import { createHash } from "node:crypto";
+import { findPersistedAuthProfileCredential, isPendingOAuthRefreshFence, isSameOAuthRefreshGeneration, resolveApiKeyForProfile } from "openclaw/plugin-sdk/agent-runtime";
+import { decodeOpenAICodexJwtPayload } from "openclaw/plugin-sdk/provider-auth";
+//#region extensions/codex/src/app-server/responses-oauth.ts
+const CODEX_RESPONSES_OAUTH_PROVIDER = "openclaw_token_sharing";
+function isCodexResponsesOAuthRun(params) {
+	return params.runtimePlan?.auth.selectedAuthMode === "oauth" && params.runtimePlan.auth.selectedAuthFlow === "chatgpt-token-sharing";
+}
+function isCodexResponsesOAuthCredential(credential) {
+	return credential?.type === "oauth" && credential.provider === "openai" && credential.authFlow === "chatgpt-token-sharing";
+}
+function isCodexResponsesOAuth(prepared) {
+	return prepared?.kind === "profile" && prepared.snapshot?.inferenceAuth === "host-oauth";
+}
+/** The OAuth owner verified this ID token. Decoding here compares identity, never proves it. */
+function fingerprintCodexResponsesOAuth(credential) {
+	if (!isCodexResponsesOAuthCredential(credential) || credential?.type !== "oauth") throw new Error("ChatGPT subscription sharing is unavailable; sign in with OpenClaw again.");
+	const subject = credential.idToken && decodeOpenAICodexJwtPayload(credential.idToken)?.sub;
+	if (!credential.issuer || !credential.clientId || typeof subject !== "string" || !subject) throw new Error("ChatGPT subscription sharing identity is missing; sign in again.");
+	return createHash("sha256").update(JSON.stringify([
+		credential.issuer,
+		credential.clientId,
+		subject,
+		credential.authFlow
+	])).digest("hex");
+}
+async function resolveCodexResponsesOAuthProfileFingerprint(params) {
+	const credential = params.store.profiles[params.profileId];
+	if (credential?.type === "oauth" && isPendingOAuthRefreshFence(credential)) {
+		const resolved = await resolveApiKeyForProfile({
+			cfg: params.config,
+			store: params.store,
+			profileId: params.profileId,
+			agentDir: params.agentDir,
+			allowProfileFallback: false
+		});
+		if (!resolved?.credential || resolved.profileId !== params.profileId) throw new Error("ChatGPT subscription sharing could not settle its refresh; sign in again.");
+		const fingerprint = fingerprintCodexResponsesOAuth(resolved.credential);
+		params.store.profiles[params.profileId] = resolved.credential;
+		return fingerprint;
+	}
+	if (!credential) throw new Error("ChatGPT subscription sharing profile is unavailable; sign in again.");
+	return fingerprintCodexResponsesOAuth(credential);
+}
+/** Keep OAuth refresh and persisted grant ownership in OpenClaw, outside native Codex auth. */
+function createCodexResponsesOAuth(params) {
+	const persisted = Boolean(findPersistedAuthProfileCredential(params)) || params.store.runtimePersistedProfileIds?.includes(params.profileId) === true;
+	const readCredential = () => persisted ? findPersistedAuthProfileCredential(params) : params.store.profiles[params.profileId];
+	const validate = (credential) => {
+		if (fingerprintCodexResponsesOAuth(credential) !== params.fingerprint) throw new Error("ChatGPT subscription sharing identity changed; reconnect before retrying.");
+	};
+	let lastCredential = params.store.profiles[params.profileId];
+	validate(lastCredential);
+	const validateCurrent = (credential, reference) => {
+		if (credential?.type === "oauth" && reference?.type === "oauth" && isPendingOAuthRefreshFence(credential) && credential.authFlow === reference.authFlow && credential.issuer === reference.issuer && credential.clientId === reference.clientId && isSameOAuthRefreshGeneration({
+			profileId: params.profileId,
+			left: credential,
+			right: reference
+		})) return;
+		validate(credential);
+	};
+	return { async resolve(forceRefresh) {
+		const credential = readCredential();
+		validateCurrent(credential, lastCredential);
+		const resolved = await resolveApiKeyForProfile({
+			cfg: params.config,
+			agentDir: params.agentDir,
+			profileId: params.profileId,
+			store: persisted ? {
+				...params.store,
+				profiles: {
+					...params.store.profiles,
+					[params.profileId]: credential
+				}
+			} : params.store,
+			forceRefresh,
+			allowProfileFallback: false,
+			validateOAuthCredential: validate
+		});
+		if (!resolved?.apiKey || resolved.profileId !== params.profileId) throw new Error("ChatGPT subscription sharing could not refresh; sign in again.");
+		const resolvedCredential = resolved.credential;
+		validate(resolvedCredential);
+		lastCredential = resolvedCredential;
+		const assertCurrent = () => validateCurrent(readCredential(), resolvedCredential);
+		assertCurrent();
+		return {
+			token: resolved.apiKey,
+			assertCurrent
+		};
+	} };
+}
+//#endregion
+export { isCodexResponsesOAuthRun as a, isCodexResponsesOAuthCredential as i, createCodexResponsesOAuth as n, resolveCodexResponsesOAuthProfileFingerprint as o, isCodexResponsesOAuth as r, CODEX_RESPONSES_OAUTH_PROVIDER as t };

package/dist/.setup/rpc-error-BlD2vuzn.mjs

@@ -0,0 +1,31 @@
+import { i as isJsonObject } from "./protocol-CANUwXJ3.mjs";
+//#region extensions/codex/src/app-server/rpc-error.ts
+const CODEX_APP_SERVER_OVERLOADED_ERROR_CODE = -32001;
+/** RPC error wrapper that preserves app-server error code and data. */
+var CodexAppServerRpcError = class extends Error {
+	constructor(error, method) {
+		super(formatCodexAppServerRpcErrorMessage(error, method));
+		this.name = "CodexAppServerRpcError";
+		this.code = error.code;
+		this.data = error.data;
+		this.method = method;
+	}
+};
+function isCodexThreadReadMissingError(error, threadId) {
+	return error instanceof CodexAppServerRpcError && error.method === "thread/read" && error.code === -32600 && error.message === `thread not loaded: ${threadId}`;
+}
+function formatCodexAppServerRpcErrorMessage(error, method) {
+	const message = error.message || `${method} failed`;
+	const detail = readCodexAppServerRpcReloginDetail(error.data);
+	return detail && !message.includes(detail) ? `${message}: ${detail}` : message;
+}
+function readCodexAppServerRpcReloginDetail(data) {
+	const record = isJsonObject(data) ? data : void 0;
+	const nested = isJsonObject(record?.error) ? record.error : record;
+	if (!nested) return;
+	const isRelogin = nested.action === "relogin" || nested.reason === "cloudRequirements" && nested.errorCode === "Auth";
+	const detail = typeof nested.detail === "string" ? nested.detail.trim() : "";
+	return isRelogin && detail ? detail : void 0;
+}
+//#endregion
+export { CodexAppServerRpcError as n, isCodexThreadReadMissingError as r, CODEX_APP_SERVER_OVERLOADED_ERROR_CODE as t };