@openclaw/codex 2026.7.2-beta.7 → 2026.7.34

package/dist/plugin-app-cache-key-DztPafOA.js

@@ -1,408 +0,0 @@
-import { K as resolveCodexAppServerHomeDir } from "./shared-client-DTbvH-XV.js";
-import { w as resolveCodexAppServerUserHomeDir } from "./session-binding-BXpo9ymA.js";
-import { createRequire } from "node:module";
-import { isFutureDateTimestampMs, resolveDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
-import { OPENCLAW_VERSION, embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { createHash } from "node:crypto";
-import { readPluginPackageVersion } from "openclaw/plugin-sdk/extension-shared";
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-//#region extensions/codex/src/app-server/app-inventory-cache.ts
-/**
-* Process-local cache for Codex app-server app inventories, keyed by runtime
-* identity and safe to refresh in the background.
-*/
-/** Default app inventory cache freshness window. */
-const CODEX_APP_INVENTORY_CACHE_TTL_MS = 3600 * 1e3;
-const CODEX_APP_READ_BATCH_LIMIT = 100;
-const MAX_SERIALIZED_ERROR_MESSAGE_LENGTH = 500;
-/** In-memory app inventory cache with coalesced refreshes per key. */
-var CodexAppInventoryCache = class {
-	constructor(options = {}) {
-		this.entries = /* @__PURE__ */ new Map();
-		this.inFlight = /* @__PURE__ */ new Map();
-		this.refreshTokens = /* @__PURE__ */ new Map();
-		this.diagnostics = /* @__PURE__ */ new Map();
-		this.revision = 0;
-		this.ttlMs = options.ttlMs ?? CODEX_APP_INVENTORY_CACHE_TTL_MS;
-	}
-	/** Reads a snapshot and schedules refresh when missing, stale, or forced. */
-	read(params) {
-		const nowMs = resolveDateTimestampMs(params.nowMs);
-		const entry = this.entries.get(params.key);
-		if (!entry) {
-			const refreshScheduled = params.suppressRefresh ? false : this.scheduleRefresh(params);
-			return {
-				state: "missing",
-				key: params.key,
-				revision: this.revision,
-				refreshScheduled,
-				...this.diagnostics.get(params.key) ? { diagnostic: this.diagnostics.get(params.key) } : {}
-			};
-		}
-		const state = entry.invalidated || !isFutureDateTimestampMs(entry.expiresAtMs, { nowMs }) ? "stale" : "fresh";
-		const refreshScheduled = state === "fresh" && !params.forceRefetch ? false : this.scheduleRefresh(params);
-		return {
-			state,
-			key: params.key,
-			revision: entry.revision,
-			snapshot: stripEntryState(entry),
-			refreshScheduled,
-			...entry.lastError ? { diagnostic: entry.lastError } : {}
-		};
-	}
-	/** Forces or joins an immediate refresh for a cache key. */
-	refreshNow(params) {
-		return this.refresh(params);
-	}
-	/**
-	* Marks a key stale and records the reason as a diagnostic. A scope names
-	* the app ids the invalidation concerns so a covering targeted refresh can
-	* clear it; without one, only a complete refresh revalidates the entry.
-	*/
-	invalidate(key, reason, nowMs = Date.now(), invalidatedAppIds) {
-		this.revision += 1;
-		this.refreshTokens.set(key, (this.refreshTokens.get(key) ?? 0) + 1);
-		this.inFlight.delete(key);
-		const diagnostic = {
-			message: reason,
-			atMs: nowMs
-		};
-		const entry = this.entries.get(key);
-		if (entry) {
-			const scope = invalidatedAppIds?.filter(Boolean) ?? [];
-			if (!entry.invalidated) entry.invalidatedAppIds = scope.length ? [...scope].toSorted() : void 0;
-			else if (entry.invalidatedAppIds && scope.length) entry.invalidatedAppIds = Array.from(/* @__PURE__ */ new Set([...entry.invalidatedAppIds, ...scope])).toSorted();
-			else entry.invalidatedAppIds = void 0;
-			entry.invalidated = true;
-			entry.lastError = diagnostic;
-			entry.revision = this.revision;
-		} else this.diagnostics.set(key, diagnostic);
-		return this.revision;
-	}
-	/** Clears all cached snapshots, diagnostics, in-flight requests, and revision state. */
-	clear() {
-		this.entries.clear();
-		this.inFlight.clear();
-		this.refreshTokens.clear();
-		this.diagnostics.clear();
-		this.revision = 0;
-	}
-	/** Returns the monotonically increasing cache revision. */
-	getRevision() {
-		return this.revision;
-	}
-	scheduleRefresh(params) {
-		const existing = this.inFlight.get(params.key);
-		if (existing && !params.forceRefetch && doesInFlightRefreshCover(existing, params)) return true;
-		this.refresh(params).catch(() => void 0);
-		return true;
-	}
-	async refresh(params) {
-		const existing = this.inFlight.get(params.key);
-		if (existing && !params.forceRefetch && doesInFlightRefreshCover(existing, params)) return existing.promise;
-		const refreshToken = (this.refreshTokens.get(params.key) ?? 0) + 1;
-		this.refreshTokens.set(params.key, refreshToken);
-		const previousRefresh = params.forceRefetch ? void 0 : existing?.promise;
-		const promise = this.refreshUncoalesced(params, refreshToken, previousRefresh);
-		const currentRefresh = {
-			promise,
-			targetAppIds: new Set(params.targetAppIds?.filter(Boolean) ?? [])
-		};
-		this.inFlight.set(params.key, currentRefresh);
-		try {
-			return await promise;
-		} finally {
-			if (this.inFlight.get(params.key) === currentRefresh) this.inFlight.delete(params.key);
-		}
-	}
-	async refreshUncoalesced(params, refreshToken, previousRefresh) {
-		const nowMs = resolveDateTimestampMs(params.nowMs);
-		try {
-			let previousRefreshSucceeded = false;
-			if (previousRefresh) try {
-				await previousRefresh;
-				previousRefreshSucceeded = true;
-			} catch {}
-			const inventory = await readInstalledApps(params.request, {
-				forceRefresh: params.forceRefetch === true || !this.entries.has(params.key) && !previousRefreshSucceeded,
-				targetAppIds: params.targetAppIds
-			});
-			this.revision += 1;
-			const expiresAtMs = resolveExpiresAtMsFromDurationMs(this.ttlMs, { nowMs }) ?? 0;
-			const snapshot = {
-				key: params.key,
-				apps: inventory.apps,
-				installedApps: inventory.installedApps,
-				...params.targetAppIds?.some(Boolean) ? { targetAppIds: Array.from(new Set(params.targetAppIds.filter(Boolean))).toSorted() } : {},
-				fetchedAtMs: nowMs,
-				expiresAtMs,
-				revision: this.revision
-			};
-			if (this.refreshTokens.get(params.key) === refreshToken) {
-				const existingEntry = this.entries.get(params.key);
-				const published = resolvePublishedInventorySnapshot(existingEntry, snapshot, nowMs);
-				const remaining = resolveRemainingInvalidationScope(existingEntry, snapshot);
-				this.entries.set(params.key, {
-					...published,
-					...remaining,
-					...remaining.invalidated && existingEntry?.lastError ? { lastError: existingEntry.lastError } : {}
-				});
-				this.diagnostics.delete(params.key);
-			}
-			return snapshot;
-		} catch (error) {
-			const diagnostic = {
-				message: sanitizeErrorMessage(error instanceof Error ? error.message : String(error)),
-				atMs: nowMs
-			};
-			this.diagnostics.set(params.key, diagnostic);
-			const entry = this.entries.get(params.key);
-			if (entry) entry.lastError = diagnostic;
-			embeddedAgentLog.warn("codex app inventory refresh failed", {
-				forceRefetch: params.forceRefetch === true,
-				keyFingerprint: fingerprintInventoryCacheKey(params.key),
-				error: serializeCodexAppInventoryError(error)
-			});
-			throw error;
-		}
-	}
-};
-/**
-* Publish policy for refreshed snapshots. A complete refresh replaces the
-* entry, but a targeted refresh only rewrites its own target rows in place —
-* replacing the whole entry with a narrow snapshot makes agents that share
-* the runtime identity see each other's plugin apps vanish and force a hosted
-* connector refresh per turn. The refreshed snapshot stays authoritative for
-* its target set, so target rows it no longer returns are deleted.
-*/
-function resolvePublishedInventorySnapshot(existing, snapshot, nowMs) {
-	if (!snapshot.targetAppIds?.length || !existing) return snapshot;
-	if (!isFutureDateTimestampMs(existing.expiresAtMs, { nowMs })) return snapshot;
-	const refreshedTargetIds = new Set(snapshot.targetAppIds);
-	const { targetAppIds: snapshotTargetAppIds, ...snapshotBase } = snapshot;
-	return {
-		...snapshotBase,
-		fetchedAtMs: existing.fetchedAtMs,
-		expiresAtMs: existing.expiresAtMs,
-		apps: mergeRefreshedRows(existing.apps, snapshot.apps, refreshedTargetIds),
-		installedApps: mergeRefreshedRows(existing.installedApps, snapshot.installedApps, refreshedTargetIds),
-		...existing.targetAppIds?.length ? { targetAppIds: Array.from(/* @__PURE__ */ new Set([...existing.targetAppIds, ...snapshotTargetAppIds])).toSorted() } : {}
-	};
-}
-/** Replaces refreshed target rows in place, deletes vanished ones, appends new ones. */
-function mergeRefreshedRows(existingRows, refreshedRows, refreshedTargetIds) {
-	const refreshedById = new Map(refreshedRows.map((row) => [row.id, row]));
-	const existingIds = new Set(existingRows.map((row) => row.id));
-	return [...existingRows.flatMap((row) => {
-		if (!refreshedTargetIds.has(row.id)) return [row];
-		const refreshed = refreshedById.get(row.id);
-		return refreshed ? [refreshed] : [];
-	}), ...refreshedRows.filter((row) => !existingIds.has(row.id))];
-}
-/**
-* A refresh retires exactly the invalidation scope it re-read: a complete
-* refresh clears everything; a targeted one subtracts its target ids so
-* separate covering refreshes accumulate until no scope remains. Unscoped
-* invalidations require a complete refresh.
-*/
-function resolveRemainingInvalidationScope(existing, snapshot) {
-	if (!existing?.invalidated || !snapshot.targetAppIds?.length) return { invalidated: false };
-	if (!existing.invalidatedAppIds) return { invalidated: true };
-	const refreshedTargetIds = new Set(snapshot.targetAppIds);
-	const remaining = existing.invalidatedAppIds.filter((appId) => !refreshedTargetIds.has(appId));
-	return remaining.length > 0 ? {
-		invalidated: true,
-		invalidatedAppIds: remaining
-	} : { invalidated: false };
-}
-function doesInFlightRefreshCover(existing, params) {
-	if (existing.targetAppIds.size === 0) return true;
-	const requestedAppIds = new Set(params.targetAppIds?.filter(Boolean) ?? []);
-	return requestedAppIds.size > 0 && Array.from(requestedAppIds).every((appId) => existing.targetAppIds.has(appId));
-}
-/** Serializes a refresh failure without leaking large or sensitive error data. */
-function serializeCodexAppInventoryError(error) {
-	const record = isRecord(error) ? error : void 0;
-	const data = record && "data" in record ? redactErrorData(record.data) : void 0;
-	return {
-		name: error instanceof Error ? error.name : typeof record?.name === "string" ? record.name : void 0,
-		message: sanitizeErrorMessage(error instanceof Error ? error.message : String(error)),
-		...typeof record?.code === "number" ? { code: record.code } : {},
-		...data !== void 0 ? { data } : {}
-	};
-}
-/** Shared app inventory cache used by Codex app-server runtime paths. */
-const defaultCodexAppInventoryCache = new CodexAppInventoryCache();
-/** Builds a stable cache key from build versions and runtime identity fields. */
-function buildCodexAppInventoryCacheKey(input, openClawVersion, codexPluginVersion) {
-	return JSON.stringify({
-		openClawVersion,
-		codexPluginVersion,
-		codexHome: input.codexHome ?? null,
-		endpoint: input.endpoint ?? null,
-		runtimeIdentity: normalizeRuntimeIdentityForCacheKey(input.runtimeIdentity),
-		authProfileId: input.authProfileId ?? null,
-		accountId: input.accountId ?? null,
-		envApiKeyFingerprint: input.envApiKeyFingerprint ?? null,
-		appServerVersion: input.appServerVersion ?? null
-	});
-}
-function normalizeRuntimeIdentityForCacheKey(value) {
-	if (!value) return null;
-	const entries = Object.entries(value).flatMap(([key, rawValue]) => {
-		const normalized = rawValue?.trim();
-		return normalized ? [[key, normalized]] : [];
-	}).toSorted(([left], [right]) => left.localeCompare(right));
-	return entries.length > 0 ? Object.fromEntries(entries) : null;
-}
-async function readInstalledApps(request, options) {
-	const installed = await request("app/installed", { forceRefresh: options.forceRefresh });
-	const targetIds = new Set((options.targetAppIds ?? []).filter(Boolean));
-	const apps = targetIds.size === 0 ? installed.apps : installed.apps.filter((app) => targetIds.has(app.id));
-	if (apps.length === 0) return {
-		apps: [],
-		installedApps: []
-	};
-	const metadataResponses = await Promise.all(Array.from({ length: Math.ceil(apps.length / CODEX_APP_READ_BATCH_LIMIT) }, (_, index) => request("app/read", { appIds: apps.slice(index * CODEX_APP_READ_BATCH_LIMIT, (index + 1) * CODEX_APP_READ_BATCH_LIMIT).map((app) => app.id) })));
-	const metadataById = new Map(metadataResponses.flatMap((response) => response.apps).map((metadata) => [metadata.id, metadata]));
-	return {
-		apps: apps.flatMap((installedApp) => {
-			const metadata = metadataById.get(installedApp.id);
-			if (!metadata) return [];
-			return [{
-				id: installedApp.id,
-				name: metadata.name,
-				description: metadata.description ?? null,
-				logoUrl: metadata.iconUrl ?? null,
-				logoUrlDark: metadata.iconUrlDark ?? null,
-				distributionChannel: metadata.distributionChannel ?? null,
-				branding: null,
-				appMetadata: null,
-				labels: null,
-				installUrl: metadata.installUrl ?? null,
-				isAccessible: true,
-				isEnabled: installedApp.enabled,
-				pluginDisplayNames: metadata.pluginDisplayNames
-			}];
-		}),
-		installedApps: apps
-	};
-}
-function stripEntryState(entry) {
-	const { invalidated: _invalidated, invalidatedAppIds: _invalidatedAppIds, ...snapshot } = entry;
-	return snapshot;
-}
-function fingerprintInventoryCacheKey(key) {
-	let hash = 0;
-	for (let index = 0; index < key.length; index += 1) hash = hash * 31 + key.charCodeAt(index) >>> 0;
-	return hash.toString(16).padStart(8, "0");
-}
-function truncateSerializedErrorText(value) {
-	return value.length > MAX_SERIALIZED_ERROR_MESSAGE_LENGTH ? `${truncateUtf16Safe(value, MAX_SERIALIZED_ERROR_MESSAGE_LENGTH)}...` : value;
-}
-function redactErrorData(value, depth = 0) {
-	if (value === void 0) return;
-	if (value === null || typeof value === "boolean" || typeof value === "number") return value;
-	if (depth > 6) return "[truncated]";
-	if (Array.isArray(value)) return value.map((entry) => redactErrorData(entry, depth + 1) ?? null);
-	if (isRecord(value)) {
-		const redacted = {};
-		for (const [key, entry] of Object.entries(value)) redacted[key] = isSensitiveErrorDataKey(key) ? "<redacted>" : redactErrorData(entry, depth + 1) ?? null;
-		return redacted;
-	}
-	if (typeof value === "string") return truncateSerializedErrorText(value);
-	if (typeof value === "bigint") return value.toString();
-	if (typeof value === "symbol") return value.description ? `Symbol(${value.description})` : "Symbol()";
-	if (typeof value === "function") return value.name ? `[function ${value.name}]` : "[function]";
-	return "[unserializable]";
-}
-function sanitizeErrorMessage(message) {
-	const htmlStart = message.search(/<html[\s>]/i);
-	return truncateSerializedErrorText((htmlStart >= 0 ? `${message.slice(0, htmlStart).trimEnd()} [HTML response body omitted]` : message).replace(/([?&][^=\s"'<>]*(?:api[_-]?key|authorization|cookie|credential|password|secret|token|tk)[^=\s"'<>]*=)[^&\s"'<>]+/gi, "$1<redacted>"));
-}
-function isSensitiveErrorDataKey(key) {
-	return /api[_-]?key|authorization|cookie|credential|password|secret|token/i.test(key);
-}
-//#endregion
-//#region extensions/codex/src/app-server/plugin-app-cache-key.ts
-/**
-* Builds stable Codex plugin/app inventory cache keys from app-server startup,
-* auth, account, and version inputs without storing secret material.
-*/
-const CODEX_PLUGIN_VERSION = readPluginPackageVersion({ require: createRequire(import.meta.url) });
-/** Builds the full app inventory cache key for Codex plugin/app discovery. */
-function buildCodexPluginAppCacheKey(params) {
-	return buildCodexAppInventoryCacheKey({
-		codexHome: params.runtimeIdentity?.codexHome ?? resolveCodexPluginAppCacheCodexHome(params.appServer, params.agentDir),
-		endpoint: resolveCodexPluginAppCacheEndpoint(params.appServer),
-		authProfileId: params.authProfileId,
-		accountId: params.accountId,
-		envApiKeyFingerprint: params.envApiKeyFingerprint,
-		appServerVersion: params.appServerVersion ?? params.runtimeIdentity?.serverVersion,
-		runtimeIdentity: params.runtimeIdentity
-	}, OPENCLAW_VERSION, CODEX_PLUGIN_VERSION);
-}
-/** Builds a durable thread-binding fingerprint for one initialized app-server runtime. */
-function buildCodexAppServerRuntimeFingerprint(params) {
-	return JSON.stringify({
-		endpoint: resolveCodexPluginAppCacheEndpoint(params.appServer),
-		connectionClass: params.appServer.connectionClass,
-		remoteWorkspaceRoot: params.appServer.remoteWorkspaceRoot ?? null,
-		appServerVersion: params.appServerVersion ?? params.runtimeIdentity?.serverVersion ?? null,
-		runtimeIdentity: params.runtimeIdentity ?? null
-	});
-}
-/** Fingerprints the configured connection that owns a supervised source thread. */
-function buildCodexAppServerConnectionFingerprint(appServer, agentDir) {
-	return JSON.stringify({
-		endpoint: resolveCodexPluginAppCacheEndpoint(appServer),
-		connectionClass: appServer.connectionClass,
-		remoteWorkspaceRoot: appServer.remoteWorkspaceRoot ?? null,
-		homeScope: appServer.start.homeScope ?? null,
-		codexHome: resolveCodexAppServerConnectionHome(appServer.start, agentDir),
-		cwd: appServer.start.cwd ?? null
-	});
-}
-function resolveCodexAppServerConnectionHome(start, agentDir) {
-	const configured = start.env?.CODEX_HOME?.trim();
-	if (configured) return configured;
-	if (start.transport === "unix" && (!start.url || start.url === "unix://")) return resolveCodexAppServerUserHomeDir(start.env ?? process.env);
-	if (start.transport !== "stdio") return null;
-	if (start.homeScope === "user") return resolveCodexAppServerUserHomeDir(process.env);
-	return agentDir ? resolveCodexAppServerHomeDir(agentDir) : null;
-}
-/** Serializes app-server endpoint identity, including credential fingerprints. */
-function resolveCodexPluginAppCacheEndpoint(appServer) {
-	return JSON.stringify({
-		transport: appServer.start.transport,
-		command: appServer.start.command,
-		args: appServer.start.args,
-		url: appServer.start.url ?? null,
-		credentialFingerprint: fingerprintCodexPluginAppCacheCredentials(appServer.start)
-	});
-}
-/** Resolves the CODEX_HOME value that scopes local app-server inventory. */
-function resolveCodexPluginAppCacheCodexHome(appServer, agentDir) {
-	const configuredCodexHome = appServer.start.env?.CODEX_HOME?.trim();
-	if (configuredCodexHome) return configuredCodexHome;
-	return appServer.start.transport === "stdio" && agentDir ? resolveCodexAppServerHomeDir(agentDir) : void 0;
-}
-function fingerprintCodexPluginAppCacheCredentials(startOptions) {
-	const authToken = startOptions.authToken ?? "";
-	const headers = Object.entries(startOptions.headers).map(([key, value]) => [key.toLowerCase(), value]).toSorted(([left], [right]) => left.localeCompare(right));
-	if (!authToken && headers.length === 0) return null;
-	const hash = createHash("sha256");
-	hash.update("openclaw:codex:plugin-app-cache-credentials:v1");
-	hash.update("\0");
-	hash.update(authToken);
-	for (const [key, value] of headers) {
-		hash.update("\0");
-		hash.update(key);
-		hash.update("\0");
-		hash.update(value);
-	}
-	return `sha256:${hash.digest("hex")}`;
-}
-//#endregion
-export { serializeCodexAppInventoryError as a, defaultCodexAppInventoryCache as i, buildCodexAppServerRuntimeFingerprint as n, buildCodexPluginAppCacheKey as r, buildCodexAppServerConnectionFingerprint as t };

package/dist/request-qKh331yu.js

@@ -1,157 +0,0 @@
-import { a as getLeasedSharedCodexAppServerClient, g as withTimeout, i as createIsolatedCodexAppServerClient, l as releaseLeasedSharedCodexAppServerClient, p as retireSharedCodexAppServerClientIfCurrent, s as isCodexAppServerStartSelectionChangedError } from "./shared-client-DTbvH-XV.js";
-import { t as resolveCodexAppServerDirectSandboxBypassBlock } from "./sandbox-guard-NuhpXmPB.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);
-				} 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 };