@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/shared-client-lifecycle-DJIgqgMw.mjs

@@ -0,0 +1,153 @@
+import { n as defineCodexBuildState } from "./build-state-Da1_z0kd.mjs";
+//#region extensions/codex/src/app-server/shared-client-lifecycle.ts
+/** Client ownership and synchronous retirement, independent of startup/auth execution. */
+const createCodexAppServerStartupLifetime = () => ({
+	controller: new AbortController(),
+	pending: /* @__PURE__ */ new Set()
+});
+function ownCodexStartup(lifetime, operation) {
+	lifetime.pending.add(operation);
+	const release = () => lifetime.pending.delete(operation);
+	operation.then(release, release);
+	return operation;
+}
+const getSharedCodexAppServerClientState = defineCodexBuildState("openclaw.codexAppServerClientState", () => ({
+	clients: /* @__PURE__ */ new Map(),
+	liveClients: /* @__PURE__ */ new Set(),
+	isolatedClients: /* @__PURE__ */ new Set(),
+	entriesByClient: /* @__PURE__ */ new WeakMap(),
+	desktopGenerationDrainChecks: /* @__PURE__ */ new Set(),
+	startup: createCodexAppServerStartupLifetime(),
+	startMetadata: /* @__PURE__ */ new WeakMap()
+}));
+function hasActiveSharedCodexAppServerWork() {
+	const state = getSharedCodexAppServerClientState();
+	if (state.startup.pending.size > 0 || state.startup.controller.signal.aborted) return true;
+	for (const entry of state.clients.values()) if (entry.activeLeases > 0 || entry.pendingAcquires > 0) return true;
+	for (const client of state.liveClients) {
+		const entry = state.entriesByClient.get(client);
+		if (entry && (entry.activeLeases > 0 || entry.pendingAcquires > 0)) return true;
+	}
+	return false;
+}
+function getCurrentSharedClientEntry(client) {
+	const state = getSharedCodexAppServerClientState();
+	const entry = client ? state.entriesByClient.get(client) : void 0;
+	return entry && entry.client === client && state.clients.get(entry.key) === entry ? entry : void 0;
+}
+/**
+* Retires a matching shared client. Default is graceful: detach from the map
+* (future acquisitions get a fresh client) and close once leases drain.
+* `failActiveLeases` is for suspect clients only (timed-out turns): it closes
+* the physical connection immediately so co-leased attempts hit the normal
+* client-closed retry path, and pending acquires reject instead of leasing
+* the poisoned process. Routine cleanup must NOT use it — it would abort
+* healthy sibling turns on a working client.
+*/
+function retireSharedCodexAppServerClientIfCurrent(client, opts) {
+	if (!client) return;
+	const state = getSharedCodexAppServerClientState();
+	const currentEntry = getCurrentSharedClientEntry(client);
+	const entry = currentEntry ?? state.entriesByClient.get(client);
+	if (!entry || entry.client !== client && !entry.closeError) return;
+	if (currentEntry) {
+		state.clients.delete(entry.key);
+		entry.closeWhenIdle = true;
+	}
+	if (opts?.failActiveLeases && (currentEntry || !entry.closeError)) {
+		entry.closeError = /* @__PURE__ */ new Error("codex app-server client is closed");
+		return {
+			activeLeases: entry.activeLeases,
+			closed: closeRetiredSharedClientEntry(entry)
+		};
+	}
+	return {
+		activeLeases: entry.activeLeases,
+		closed: currentEntry ? closeRetiredSharedClientEntryIfIdle(entry) : false
+	};
+}
+/** Gracefully retires exact clients attached to an older desktop generation. */
+function retireSharedCodexAppServerClientsBeforeDesktopGeneration(generation) {
+	const state = getSharedCodexAppServerClientState();
+	for (const entry of state.clients.values()) {
+		const client = entry.client;
+		const attached = client ? state.startMetadata.get(client) : void 0;
+		if (client && attached?.desktopGeneration && attached.desktopGeneration.epoch < generation.epoch) retireSharedCodexAppServerClientIfCurrent(client);
+	}
+}
+function closeRetiredSharedClientEntryIfIdle(entry) {
+	if (!entry.closeWhenIdle || entry.activeLeases > 0 || entry.pendingAcquires > 0 || !entry.client) return false;
+	entry.closeWhenIdle = false;
+	return closeRetiredSharedClientEntry(entry);
+}
+function closeRetiredSharedClientEntry(entry) {
+	const client = entry.client;
+	if (!client) return false;
+	entry.client = void 0;
+	client.close();
+	return true;
+}
+function retirePendingSharedClientEntryIfUnclaimed(entry) {
+	if (entry.activeLeases > 0 || entry.pendingAcquires > 0) return;
+	entry.startupAbort?.abort(/* @__PURE__ */ new Error("Codex app-server startup was abandoned"));
+	entry.closeWhenIdle = true;
+	const state = getSharedCodexAppServerClientState();
+	if (state.clients.get(entry.key) === entry) state.clients.delete(entry.key);
+	if (!entry.client) return;
+	closeRetiredSharedClientEntry(entry);
+}
+/** Failed final claimants join physical cleanup; healthy peers keep their startup. */
+async function waitForUnclaimedSharedClientStartup(entry) {
+	if (!entry.startupTransport || entry.activeLeases > 0 || entry.pendingAcquires > 0) return;
+	await entry.startupTransport.then((client) => client.closeAndWait(), () => {});
+}
+/** Exit registration also observes transports that have already terminated. */
+function waitForCodexAppServerClientExit(client) {
+	const metadata = getSharedCodexAppServerClientState().startMetadata.get(client);
+	const exited = metadata?.transportExit ?? new Promise((resolve) => {
+		client.addTransportExitHandler(() => resolve());
+	});
+	if (metadata) metadata.transportExit = exited;
+	return exited;
+}
+/** Acquire the recorded owner atomically, or join its exit before a replacement writes. */
+async function retainSharedCodexAppServerClientByInstanceId(clientId) {
+	const id = clientId?.trim();
+	if (!id) return;
+	const state = getSharedCodexAppServerClientState();
+	for (const client of state.liveClients) {
+		if (client.getInstanceId() !== id) continue;
+		const entry = state.entriesByClient.get(client);
+		if (entry?.client !== client || entry.closeError || client.getCloseError()) {
+			await waitForCodexAppServerClientExit(client);
+			return;
+		}
+		const release = retainSharedClientEntry(entry);
+		return {
+			client,
+			release: (waitForRetirement = false) => {
+				release();
+				return client.getCloseError() || waitForRetirement && entry.closeWhenIdle ? waitForCodexAppServerClientExit(client) : void 0;
+			}
+		};
+	}
+}
+function notifyDesktopGenerationDrainChecks(state) {
+	for (const check of state.desktopGenerationDrainChecks) check();
+}
+function retainSharedClientEntry(entry, counter = "activeLeases") {
+	let released = false;
+	entry[counter] += 1;
+	return () => {
+		if (released) return;
+		released = true;
+		releaseSharedClientEntry(entry, counter);
+	};
+}
+function releaseSharedClientEntry(entry, counter) {
+	entry[counter] -= 1;
+	closeRetiredSharedClientEntryIfIdle(entry);
+	notifyDesktopGenerationDrainChecks(getSharedCodexAppServerClientState());
+}
+//#endregion
+export { notifyDesktopGenerationDrainChecks as a, retainSharedClientEntry as c, retireSharedCodexAppServerClientIfCurrent as d, retireSharedCodexAppServerClientsBeforeDesktopGeneration as f, hasActiveSharedCodexAppServerWork as i, retainSharedCodexAppServerClientByInstanceId as l, waitForUnclaimedSharedClientStartup as m, getCurrentSharedClientEntry as n, ownCodexStartup as o, waitForCodexAppServerClientExit as p, getSharedCodexAppServerClientState as r, releaseSharedClientEntry as s, createCodexAppServerStartupLifetime as t, retirePendingSharedClientEntryIfUnclaimed as u };