@openclaw/codex 2026.9.2 → 2026.9.4

package/dist/session-catalog-adoption-tcZi1IfX.js

@@ -0,0 +1,251 @@
+import { l as sessionBindingIdentity } from "./session-binding-record-Bcvslnhf.js";
+import { c as CatalogParamsError, f as boundedCatalogString, w as requireBoundThread } from "./thread-history-page-D0JIp48V.js";
+import { n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.js";
+import { i as reclaimCurrentCodexSessionGeneration } from "./session-binding-CI8UuilT.js";
+import { adoptionSessionKeyRest, continueOperations, runSessionActionExclusive } from "./session-catalog-node-adoption-B1tgDW-m.js";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { listSessionCatalogEntries, sessionCatalogAdoptedSessionKey, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
+//#region extensions/codex/src/session-catalog-adoption.ts
+const CODEX_SUPERVISION_SESSION_KEY_PREFIX = "harness:codex:supervision:";
+const boundCatalogSessionId = (value) => boundedCatalogString(value, 256);
+function requireIdleThread(thread, action) {
+	if (thread.status?.type === "idle" || action === "archive" && thread.status?.type === "notLoaded") return;
+	if (thread.status?.type === "active") throw new CatalogParamsError(`Codex session is active in this App Server; wait for it to finish before ${action === "continue" ? "starting a branch" : "archiving"}`);
+	throw new CatalogParamsError(action === "archive" ? "Codex session cannot be archived in its current state" : "Codex session cannot start a branch in its current state");
+}
+function adoptionSessionKey(threadId, sourceHomeId) {
+	const source = sourceHomeId ? JSON.stringify([sourceHomeId, threadId]) : threadId;
+	return sessionCatalogAdoptedSessionKey(CODEX_SUPERVISION_SESSION_KEY_PREFIX, source);
+}
+function isAdoptionSessionKeyForThread(sessionKey, threadId, sourceHomeId) {
+	return adoptionSessionKeyRest(sessionKey) === adoptionSessionKey(threadId, sourceHomeId);
+}
+function readCodexSupervisionMarker(entry) {
+	const codex = isRecord(entry.pluginExtensions?.codex) ? entry.pluginExtensions.codex : void 0;
+	const marker = codex && isRecord(codex.supervision) ? codex.supervision : void 0;
+	const sourceThreadId = marker?.sourceThreadId;
+	const sourceHomeId = marker?.sourceHomeId;
+	if (typeof sourceThreadId !== "string" || !sourceThreadId.trim() || sourceHomeId !== void 0 && (typeof sourceHomeId !== "string" || !sourceHomeId.trim())) return;
+	return {
+		sourceThreadId: sourceThreadId.trim(),
+		...typeof sourceHomeId === "string" ? { sourceHomeId: sourceHomeId.trim() } : {}
+	};
+}
+async function listAdoptedSessionEntries(params) {
+	const adopted = /* @__PURE__ */ new Map();
+	for (const { agentId, entry, sessionKey } of listSessionCatalogEntries({
+		...params.agentId ? { agentId: params.agentId } : {},
+		config: params.config ?? {},
+		runtime: params.runtime,
+		sessionEntries: params.sessionEntries
+	})) {
+		const sessionKeyRest = adoptionSessionKeyRest(sessionKey);
+		const marker = readCodexSupervisionMarker(entry);
+		if (!sessionKeyRest.startsWith(CODEX_SUPERVISION_SESSION_KEY_PREFIX) || !marker || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true) continue;
+		const sessionId = entry.sessionId?.trim();
+		if (!sessionId) continue;
+		const binding = params.bindingStore.read(sessionBindingIdentity({
+			sessionId,
+			sessionKey,
+			config: params.config
+		}));
+		const sourceThreadId = binding?.supervisionSourceThreadId?.trim();
+		const boundThreadId = binding?.threadId.trim();
+		if (binding?.connectionScope !== "supervision" || !sourceThreadId || !boundThreadId || sessionKeyRest !== adoptionSessionKey(sourceThreadId, marker.sourceHomeId)) continue;
+		const sourceKey = sessionCatalogAdoptedSourceKey(marker.sourceHomeId ?? "gateway:local", sourceThreadId);
+		if (adopted.has(sourceKey)) throw new Error(`multiple OpenClaw sessions adopt Codex thread ${sourceThreadId} from the same home`);
+		adopted.set(sourceKey, {
+			key: sessionKey,
+			sessionId,
+			agentId,
+			boundThreadId
+		});
+	}
+	return adopted;
+}
+async function findAdoptedSessionEntry(params) {
+	const adopted = await listAdoptedSessionEntries(params);
+	return adopted.get(sessionCatalogAdoptedSourceKey(params.sourceHomeId ?? "gateway:local", params.threadId)) ?? (params.sourceHomeId && params.allowLegacy === true ? adopted.get(sessionCatalogAdoptedSourceKey("gateway:local", params.threadId)) : void 0);
+}
+function matchesPendingAdoptionBinding(binding, expected) {
+	const historyCoveredThrough = binding?.historyCoveredThrough;
+	return binding?.threadId === expected.sourceThreadId && binding.connectionScope === "supervision" && binding.supervisionSourceThreadId === expected.sourceThreadId && binding.cwd === expected.cwd && binding.conversationSourceTransferComplete === true && binding.preserveNativeModel === true && binding.pendingSupervisionBranch?.sourceThreadId === expected.sourceThreadId && binding.pendingSupervisionBranch.connectionFingerprint === expected.connectionFingerprint && binding.pendingSupervisionBranch.lastTurnId === expected.lastTurnId && (binding.pendingSupervisionBranch.cleanupThreadIds?.length ?? 0) === 0 && typeof historyCoveredThrough === "string" && Number.isFinite(Date.parse(historyCoveredThrough));
+}
+async function ensurePendingAdoptionBinding(params) {
+	const pending = {
+		sourceThreadId: params.sourceThreadId,
+		connectionFingerprint: params.connectionFingerprint,
+		...params.lastTurnId ? { lastTurnId: params.lastTurnId } : {}
+	};
+	const ownsGeneration = await reclaimCurrentCodexSessionGeneration({
+		assertCurrent: params.initialization.assertCurrent,
+		bindingStore: params.bindingStore,
+		identity: params.identity,
+		config: params.config
+	});
+	params.initialization.assertCurrent();
+	if (!ownsGeneration) throw new Error(`failed to claim the OpenClaw session generation for ${params.sourceThreadId}`);
+	const existing = params.bindingStore.read(params.identity);
+	params.initialization.assertCurrent();
+	if (existing) {
+		if (matchesPendingAdoptionBinding(existing, params)) return;
+		throw new Error(`OpenClaw session is already bound to Codex thread ${existing.threadId}`);
+	}
+	const binding = {
+		threadId: params.sourceThreadId,
+		connectionScope: "supervision",
+		supervisionSourceThreadId: params.sourceThreadId,
+		cwd: params.cwd,
+		historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString(),
+		conversationSourceTransferComplete: true,
+		preserveNativeModel: true,
+		pendingSupervisionBranch: pending
+	};
+	await params.initialization.bind(binding);
+}
+async function createOrReuseAdoptedSession(params) {
+	const runtime = params.api.runtime;
+	const lookup = {
+		...params,
+		runtime,
+		threadId: params.sourceThread.id
+	};
+	const existing = await findAdoptedSessionEntry(lookup);
+	if (existing) return existing;
+	try {
+		const spawnedCwd = params.sourceThread.cwd?.trim() || void 0;
+		const pendingLastTurnId = codexLastTerminalTurnId(params.sourceThread, boundCatalogSessionId);
+		const marker = {
+			sourceThreadId: params.sourceThread.id,
+			...params.sourceHomeId ? { sourceHomeId: params.sourceHomeId } : {}
+		};
+		const { createImportedCodexSession } = await import("./session-history-import-DwyijFI6.js");
+		const created = await createImportedCodexSession({
+			runtime: params.api.runtime,
+			bindingStore: params.bindingStore,
+			config: params.config,
+			key: adoptionSessionKey(params.sourceThread.id, params.sourceHomeId),
+			agentId: params.agentId,
+			displayName: params.sourceThread.name ?? void 0,
+			thread: params.sourceThread,
+			throughTurnId: pendingLastTurnId ?? null,
+			recoverMatchingInitialEntry: true,
+			initialEntry: {
+				agentHarnessId: "codex",
+				modelSelectionLocked: true,
+				pluginExtensions: { codex: { supervision: {
+					...marker,
+					initializing: true,
+					modelLocked: true
+				} } }
+			},
+			afterImport: async (entry, initialization) => {
+				const identity = sessionBindingIdentity({
+					sessionId: entry.sessionId,
+					sessionKey: entry.key,
+					config: params.config
+				});
+				await ensurePendingAdoptionBinding({
+					bindingStore: params.bindingStore,
+					config: params.config,
+					identity,
+					initialization,
+					sourceThreadId: params.sourceThread.id,
+					connectionFingerprint: params.connectionFingerprint,
+					cwd: spawnedCwd ?? "",
+					...pendingLastTurnId ? { lastTurnId: pendingLastTurnId } : {}
+				});
+				return { pluginExtensions: { codex: { supervision: {
+					...marker,
+					modelLocked: true
+				} } } };
+			}
+		});
+		return {
+			key: created.key,
+			sessionId: created.sessionId,
+			agentId: created.agentId,
+			boundThreadId: params.sourceThread.id
+		};
+	} catch (error) {
+		const raced = await findAdoptedSessionEntry(lookup);
+		if (raced) return raced;
+		throw error;
+	}
+}
+async function continueLocalCodexSessionInner(params) {
+	await params.control.requireEligibleThread(params.threadId);
+	const existing = await findAdoptedSessionEntry({
+		...params,
+		runtime: params.api.runtime
+	});
+	if (existing) {
+		const boundThreadId = requireBoundThread(existing);
+		const boundThread = await params.control.readThread(boundThreadId, true);
+		if (boundThread.id !== boundThreadId) throw new Error("Codex app-server returned a different thread than requested");
+		const changedError = () => new CatalogParamsError("Codex OpenClaw session changed before it could be opened. Retry.");
+		if (!await params.api.runtime.agent.session.patchSessionEntry({
+			sessionKey: existing.key,
+			readConsistency: "latest",
+			preserveActivity: true,
+			update: (entry) => {
+				if (entry.sessionId?.trim() !== existing.sessionId || entry.initializationPending === true || entry.agentHarnessId !== "codex" || entry.modelSelectionLocked !== true) throw changedError();
+				return {
+					archivedAt: void 0,
+					archivedBy: void 0,
+					archiveReason: void 0
+				};
+			}
+		})) throw changedError();
+		const connectionFingerprint = params.control.connectionFingerprint;
+		if (connectionFingerprint) params.onContinued?.({
+			connectionFingerprint,
+			...codexUpstreamBaseline(boundThread, boundCatalogSessionId)
+		});
+		return {
+			sessionKey: existing.key,
+			disposition: "existing"
+		};
+	}
+	const sourceThread = await params.control.readThread(params.threadId, true);
+	if (sourceThread.id !== params.threadId) throw new Error("Codex app-server returned a different thread than requested");
+	if (sourceThread.status?.type !== "notLoaded") requireIdleThread(sourceThread, "continue");
+	const connectionFingerprint = params.control.connectionFingerprint;
+	if (!connectionFingerprint) throw new Error("Codex Continue requires a pinned app-server connection");
+	const adopted = await createOrReuseAdoptedSession({
+		...params,
+		sourceThread,
+		connectionFingerprint
+	});
+	const boundThreadId = requireBoundThread(adopted);
+	const baselineThread = boundThreadId === sourceThread.id ? sourceThread : await params.control.readThread(boundThreadId, true);
+	if (baselineThread.id !== boundThreadId) throw new Error("Codex app-server returned a different thread than requested");
+	params.onContinued?.({
+		connectionFingerprint,
+		...codexUpstreamBaseline(baselineThread, boundCatalogSessionId)
+	});
+	return {
+		sessionKey: adopted.key,
+		disposition: "forked"
+	};
+}
+/** Creates one locked OpenClaw branch whose first harness run forks the Codex source. */
+async function continueLocalCodexSession(params) {
+	const sourceKey = sessionCatalogAdoptedSourceKey(params.hostId ?? "gateway:local", params.threadId);
+	const operationKey = sessionCatalogAdoptedSourceKey(params.agentId, sourceKey);
+	const current = continueOperations.get(operationKey);
+	if (current) return await current;
+	const run = async (control) => await continueLocalCodexSessionInner({
+		...params,
+		control
+	});
+	const operation = runSessionActionExclusive(sourceKey, async () => params.control.withPinnedConnection(run));
+	continueOperations.set(operationKey, operation);
+	try {
+		return await operation;
+	} finally {
+		if (continueOperations.get(operationKey) === operation) continueOperations.delete(operationKey);
+	}
+}
+//#endregion
+export { continueLocalCodexSession, isAdoptionSessionKeyForThread, listAdoptedSessionEntries, requireIdleThread };

package/dist/session-catalog-archive-CwKg8Xz2.js

@@ -0,0 +1,56 @@
+import { l as sessionBindingIdentity } from "./session-binding-record-Bcvslnhf.js";
+import { t as assertCodexArchiveDescendantsUnowned } from "./thread-archive-guard-DfpBr-Sz.js";
+import { c as CatalogParamsError } from "./thread-history-page-D0JIp48V.js";
+import "./session-binding-CI8UuilT.js";
+import { runSessionActionExclusive } from "./session-catalog-node-adoption-B1tgDW-m.js";
+import { isAdoptionSessionKeyForThread, requireIdleThread } from "./session-catalog-adoption-tcZi1IfX.js";
+import { listAgentIds } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
+//#region extensions/codex/src/session-catalog-archive.ts
+function assertNoPendingSupervisionBranch(params) {
+	const adoptedEntries = [params.agentId, ...listAgentIds(params.config).filter((agentId) => agentId !== params.agentId)].flatMap((agentId) => params.runtime.agent.session.listSessionEntries({
+		agentId,
+		readOnly: true
+	})).filter((candidate) => isAdoptionSessionKeyForThread(candidate.sessionKey, params.threadId, params.sourceHomeId) || params.sourceHomeId !== void 0 && params.allowLegacy === true && isAdoptionSessionKeyForThread(candidate.sessionKey, params.threadId));
+	for (const adopted of adoptedEntries) {
+		if (adopted.entry.initializationPending === true) throw new CatalogParamsError("Codex session cannot be archived while its OpenClaw branch is initializing");
+		const sessionId = adopted.entry.sessionId?.trim();
+		if (!sessionId) continue;
+		const binding = params.bindingStore.read(sessionBindingIdentity({
+			sessionId,
+			sessionKey: adopted.sessionKey,
+			config: params.config
+		}));
+		if (binding?.connectionScope === "supervision" && binding.supervisionSourceThreadId === params.threadId && binding.pendingSupervisionBranch?.sourceThreadId === params.threadId) throw new CatalogParamsError("Codex session cannot be archived until its OpenClaw branch starts");
+	}
+}
+/** Archives one inactive Gateway-local Codex thread after a fresh status read. */
+async function archiveLocalCodexSession(params) {
+	return await runSessionActionExclusive(sessionCatalogAdoptedSourceKey(params.hostId ?? "gateway:local", params.threadId), async () => {
+		return await params.bindingStore.withThreadArchiveFence(async () => {
+			const run = async (control) => {
+				assertNoPendingSupervisionBranch(params);
+				await control.requireEligibleThread(params.threadId);
+				const thread = await control.readThread(params.threadId, false);
+				if (thread.id !== params.threadId) throw new Error("Codex app-server returned a different thread than requested");
+				requireIdleThread(thread, "archive");
+				if (await params.bindingStore.hasOtherThreadOwner(params.threadId)) throw new CatalogParamsError("Codex session cannot be archived while it is attached to an OpenClaw session");
+				await assertCodexArchiveDescendantsUnowned({
+					bindingStore: params.bindingStore,
+					threadId: params.threadId,
+					listPage: (request) => control.listDescendantPage(request),
+					assertDescendantIdle: async (descendantThreadId) => {
+						const descendant = await control.readThread(descendantThreadId, false);
+						if (descendant.id !== descendantThreadId) throw new Error("Codex app-server returned a different descendant than requested");
+						requireIdleThread(descendant, "archive");
+					}
+				});
+				await control.archiveThread(params.threadId);
+				return { archived: true };
+			};
+			return await params.control.withPinnedConnection(run);
+		});
+	});
+}
+//#endregion
+export { archiveLocalCodexSession };