@openclaw/codex 2026.8.2 → 2026.9.1

package/dist/session-catalog-home-id-Dt2GiG5o.js

@@ -1,112 +0,0 @@
-import { Ht as isJsonObject } from "./shared-client-B1tT5U6r.js";
-import path from "node:path";
-import { createHash } from "node:crypto";
-import fsSync from "node:fs";
-import { root } from "openclaw/plugin-sdk/file-access-runtime";
-import { createZstdDecompress } from "node:zlib";
-//#region extensions/codex/src/session-catalog-provenance.ts
-const MAX_SESSION_META_BYTES = 1048576;
-const SESSION_META_READ_CHUNK_BYTES = 65536;
-const MAX_PROVENANCE_CACHE_ENTRIES = 2e4;
-const provenanceByPath = /* @__PURE__ */ new Map();
-function cacheProvenance(key, value) {
-	provenanceByPath.delete(key);
-	provenanceByPath.set(key, value);
-	while (provenanceByPath.size > MAX_PROVENANCE_CACHE_ENTRIES) {
-		const oldest = provenanceByPath.keys().next().value;
-		if (oldest === void 0) break;
-		provenanceByPath.delete(oldest);
-	}
-}
-/** Undefined means the metadata line is not durable enough to cache yet. */
-async function readCodexSessionMeta(sessionsRoot, rolloutPath, threadId) {
-	let safeRoot;
-	try {
-		safeRoot = await root(sessionsRoot, {
-			hardlinks: "reject",
-			maxBytes: Number.MAX_SAFE_INTEGER,
-			symlinks: "reject"
-		});
-	} catch {
-		return;
-	}
-	const candidates = rolloutPath.endsWith(".zst") ? [rolloutPath, rolloutPath.slice(0, -4)] : [rolloutPath, `${rolloutPath}.zst`];
-	for (const candidate of candidates) {
-		let opened;
-		try {
-			opened = await safeRoot.open(path.relative(sessionsRoot, candidate));
-		} catch {
-			continue;
-		}
-		const input = opened.handle.createReadStream({
-			autoClose: false,
-			highWaterMark: SESSION_META_READ_CHUNK_BYTES
-		});
-		const reader = candidate.endsWith(".zst") ? input.pipe(createZstdDecompress()) : input;
-		try {
-			const chunks = [];
-			let bytesReadTotal = 0;
-			let line;
-			for await (const value of reader) {
-				const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
-				const remaining = MAX_SESSION_META_BYTES - bytesReadTotal;
-				if (remaining <= 0) break;
-				const bounded = chunk.subarray(0, remaining);
-				bytesReadTotal += bounded.length;
-				const newline = bounded.indexOf(10);
-				chunks.push(newline >= 0 ? bounded.subarray(0, newline) : bounded);
-				if (newline >= 0) {
-					line = Buffer.concat(chunks).toString("utf8");
-					break;
-				}
-			}
-			if (!line) continue;
-			let parsed;
-			try {
-				parsed = JSON.parse(line);
-			} catch {
-				continue;
-			}
-			if (!isJsonObject(parsed) || parsed.type !== "session_meta" || !isJsonObject(parsed.payload)) return null;
-			const payload = parsed.payload;
-			return payload.id === threadId ? payload : null;
-		} catch {
-			continue;
-		} finally {
-			reader.destroy();
-			input.destroy();
-			await opened.handle.close().catch(() => void 0);
-		}
-	}
-}
-/**
-* Codex 0.147 reports OpenClaw app-server rollouts as `vscode`, so the rollout's
-* immutable session metadata is the authoritative historical provenance.
-*/
-async function isOpenClawManagedCodexThread(thread, localSessionsRoot) {
-	const rolloutPath = typeof thread.path === "string" ? thread.path.trim() : "";
-	if (!localSessionsRoot || !rolloutPath) return false;
-	const cacheKey = `${localSessionsRoot}\0${rolloutPath}`;
-	const cached = provenanceByPath.get(cacheKey);
-	if (cached !== void 0) return cached;
-	const metadata = await readCodexSessionMeta(localSessionsRoot, rolloutPath, thread.id);
-	const managed = metadata === void 0 ? void 0 : metadata?.originator === "openclaw";
-	if (managed !== void 0) cacheProvenance(cacheKey, managed);
-	return managed ?? false;
-}
-//#endregion
-//#region extensions/codex/src/session-catalog-home-id.ts
-function canonicalCodexCatalogHome(value) {
-	const resolved = path.resolve(value);
-	try {
-		return fsSync.realpathSync.native(resolved);
-	} catch {
-		return resolved;
-	}
-}
-/** One canonical identity for catalog discovery and durable ownership rows. */
-function codexCatalogHomeId(codexHome) {
-	return createHash("sha256").update("openclaw:codex-session-catalog-home:v1\0").update(canonicalCodexCatalogHome(codexHome)).digest("hex");
-}
-//#endregion
-export { readCodexSessionMeta as i, codexCatalogHomeId as n, isOpenClawManagedCodexThread as r, canonicalCodexCatalogHome as t };

package/dist/upstream-session-fork-Dc8BFExw.js

@@ -1,312 +0,0 @@
-import { d as sessionBindingIdentity } from "./session-binding-D0zinCP1.js";
-import { a as assertCodexThreadForkResponse } from "./protocol-validators-Bg5rpNxk.js";
-import { i as readUpstreamUserText, r as readMirrorIdentity } from "./upstream-prompt-provenance-LphB8slG.js";
-import { c as fingerprintCodexMirrorSourceMessage, m as projectCodexUserItemText, u as readCodexMirrorSourceFingerprint } from "./transcript-mirror-1ep4XjzF.js";
-import { i as createImportedCodexSession, n as codexUpstreamBaseline, t as codexLastTerminalTurnId } from "./session-upstream-marker-gqrYIRHk.js";
-import { isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { readVisibleSessionTranscriptMessageEntries } from "openclaw/plugin-sdk/session-transcript-runtime";
-import { deleteSessionUpstreamLink, upsertSessionUpstreamLink } from "openclaw/plugin-sdk/session-catalog";
-//#region extensions/codex/src/app-server/upstream-fork-boundary.ts
-const TURN_PAGE_LIMIT = 100;
-function failure(code, message) {
-	return {
-		ok: false,
-		code,
-		message
-	};
-}
-function textOnlyMessage(content) {
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return;
-	const texts = [];
-	for (const block of content) {
-		if (!block || typeof block !== "object" || Array.isArray(block)) return;
-		const typed = block;
-		if (typed.type !== "text" || typeof typed.text !== "string") return;
-		texts.push(typed.text);
-	}
-	return texts.join("\n");
-}
-function resolveCodexUpstreamForkBoundaryFromTurns(params) {
-	let localIndex = 0;
-	let matchedPrefix = false;
-	for (const [turnIndex, turn] of params.turns.entries()) {
-		let userMessagesInTurn = 0;
-		for (const item of turn.items) {
-			if (item.type !== "userMessage") continue;
-			const isSteer = userMessagesInTurn > 0;
-			userMessagesInTurn += 1;
-			const nativeText = textOnlyMessage(item.content);
-			if (nativeText === void 0) return failure("drift-mismatch", "A message before the fork point contains images or attachments that cannot be verified across OpenClaw and Codex. Fork from a text-only span instead.");
-			const local = params.localPrefix[localIndex];
-			const upstreamText = local && readUpstreamUserText(local.message);
-			const text = upstreamText ? nativeText : projectCodexUserItemText(item);
-			if (!text) continue;
-			const identity = local && readMirrorIdentity(local.message);
-			const matchesIdentity = identity === `${turn.id}:${item.id}` || !isSteer && identity === `${turn.id}:prompt`;
-			if (!matchedPrefix && !matchesIdentity) continue;
-			matchedPrefix = true;
-			const localText = textOnlyMessage(local && "content" in local.message ? local.message.content : void 0);
-			const upstreamPromptVerified = !upstreamText || local?.message.role === "user" && readCodexMirrorSourceFingerprint(local.message) === fingerprintCodexMirrorSourceMessage(local.message);
-			if (!matchesIdentity || !upstreamPromptVerified || localText === void 0 || text !== (upstreamText ?? localText)) return failure("drift-mismatch", "The local conversation no longer matches the Codex thread. Refresh the session and try again.");
-			if (localIndex < params.localPrefix.length - 1) {
-				localIndex += 1;
-				continue;
-			}
-			if (isSteer) return failure("steer-message", "This message steered an existing Codex turn and cannot be forked independently. Fork from the turn's first message instead.");
-			if (turn.status === "inProgress") return failure("in-progress-turn", "This Codex turn is still in progress. Wait for it to finish, then try forking again.");
-			const retained = turnIndex > 0 ? params.turns[turnIndex - 1] : void 0;
-			return {
-				ok: true,
-				boundary: {
-					beforeTurnId: turn.id,
-					targetTurnId: turn.id,
-					retainedMarker: retained ? {
-						turnId: retained.id,
-						userMessageCount: retained.items.filter((retainedItem) => retainedItem.type === "userMessage").length
-					} : {
-						turnId: null,
-						userMessageCount: 0
-					}
-				}
-			};
-		}
-	}
-	return failure("drift-mismatch", "The local history has no verified boundary in this Codex thread. Use native Codex to fork this conversation.");
-}
-async function listCodexUpstreamTurns(control, threadId) {
-	const turns = [];
-	const seenCursors = /* @__PURE__ */ new Set();
-	let cursor;
-	for (;;) {
-		const page = await control.listTurnPage({
-			threadId,
-			limit: TURN_PAGE_LIMIT,
-			sortDirection: "asc",
-			itemsView: "full",
-			...cursor ? { cursor } : {}
-		});
-		turns.push(...page.data);
-		const nextCursor = page.nextCursor?.trim() || void 0;
-		if (!nextCursor) return turns;
-		if (seenCursors.has(nextCursor)) throw new Error("Codex returned a repeated thread/turns/list cursor");
-		seenCursors.add(nextCursor);
-		cursor = nextCursor;
-	}
-}
-async function resolveCodexUpstreamForkBoundary(params) {
-	try {
-		const visibleUserEntries = (await readVisibleSessionTranscriptMessageEntries({
-			agentId: params.agentId,
-			sessionId: params.sessionId,
-			sessionKey: params.sessionKey,
-			storePath: params.storePath
-		})).filter((entry) => entry.role === "user");
-		const targetIndex = visibleUserEntries.findIndex((entry) => entry.entryId === params.entryId);
-		if (targetIndex < 0) return failure("drift-mismatch", "The local message could not be mapped to the Codex thread. Refresh the session and try again.");
-		const localPrefix = visibleUserEntries.slice(0, targetIndex + 1);
-		const resolved = resolveCodexUpstreamForkBoundaryFromTurns({
-			turns: await listCodexUpstreamTurns(params.control, params.threadId),
-			localPrefix
-		});
-		const target = localPrefix.at(-1)?.message;
-		return resolved.ok ? {
-			...resolved,
-			editorText: textOnlyMessage(target && "content" in target ? target.content : void 0)
-		} : resolved;
-	} catch {
-		return failure("upstream-unavailable", "The Codex thread could not be read. Check that Codex is available, then try again.");
-	}
-}
-function precheckCodexUpstreamForkBoundary(params) {
-	const target = params.turns.find((turn) => turn.id === params.boundary.targetTurnId);
-	if (!target) return failure("upstream-unavailable", "The Codex thread changed before it could be forked. Refresh the session and try again.");
-	if (target.status === "inProgress") return failure("in-progress-turn", "This Codex turn is still in progress. Wait for it to finish, then try forking again.");
-	return {
-		ok: true,
-		boundary: params.boundary
-	};
-}
-//#endregion
-//#region extensions/codex/src/app-server/upstream-session-fork.ts
-function readConnectionFingerprint(ref) {
-	if (!isRecord(ref)) return;
-	return typeof ref.connectionFingerprint === "string" && ref.connectionFingerprint.trim() ? ref.connectionFingerprint : void 0;
-}
-async function forkCodexUpstreamSession(params, options) {
-	try {
-		const sourceFingerprint = params.upstream.kind === "codex-app-server" ? readConnectionFingerprint(params.upstream.ref) : void 0;
-		const requestControl = sourceFingerprint ? options.controlFactory.forUpstream(params.source.agentId, sourceFingerprint) : void 0;
-		if (!sourceFingerprint || !requestControl) return {
-			status: "failed",
-			code: "upstream-unavailable",
-			message: "This Codex thread is not available on the current connection. Reconnect to its host and try again."
-		};
-		return await requestControl.withPinnedConnection(async (control) => {
-			const sourceBinding = await options.bindingStore.read(sessionBindingIdentity({
-				...params.source,
-				config: options.resolveConfig?.()
-			}));
-			const supervised = sourceBinding?.connectionScope === "supervision";
-			const sourceThreadId = params.upstream.threadId;
-			let linked = false;
-			let createdBinding;
-			const compensateFork = async (forkedThreadId) => {
-				if (createdBinding) {
-					if (!await options.bindingStore.mutate(createdBinding.identity, {
-						kind: "clear",
-						threadId: forkedThreadId,
-						expectedPendingSupervisionBranch: createdBinding.pending
-					}).catch(() => false)) return;
-				}
-				if (linked) deleteSessionUpstreamLink(params.targetKey, params.source.agentId);
-				await control.archiveThread(forkedThreadId).catch(() => void 0);
-			};
-			if (sourceFingerprint !== control.connectionFingerprint || supervised && (sourceBinding.supervisionSourceThreadId !== params.upstream.threadId || (sourceBinding.pendingSupervisionBranch?.connectionFingerprint ?? sourceBinding.appServerRuntimeFingerprint) !== sourceFingerprint)) return {
-				status: "failed",
-				code: "upstream-unavailable",
-				message: "This Codex thread is not available on the current connection. Reconnect to its host and try again."
-			};
-			const resolved = await resolveCodexUpstreamForkBoundary({
-				...params.source,
-				threadId: sourceThreadId,
-				control
-			});
-			if (!resolved.ok) return {
-				status: "failed",
-				code: resolved.code,
-				message: resolved.message
-			};
-			const liveTurns = await listCodexUpstreamTurns(control, sourceThreadId);
-			const precheck = precheckCodexUpstreamForkBoundary({
-				boundary: resolved.boundary,
-				turns: liveTurns
-			});
-			if (!precheck.ok) return {
-				status: "failed",
-				code: precheck.code,
-				message: precheck.message
-			};
-			const rawResponse = await control.forkThread({
-				threadId: sourceThreadId,
-				beforeTurnId: resolved.boundary.beforeTurnId,
-				...params.sandbox === "required" ? { sandbox: "workspace-write" } : {},
-				excludeTurns: true
-			});
-			let response;
-			try {
-				response = assertCodexThreadForkResponse(rawResponse);
-			} catch (error) {
-				const orphanThreadId = isRecord(rawResponse.thread) && typeof rawResponse.thread.id === "string" ? rawResponse.thread.id.trim() : "";
-				if (orphanThreadId && orphanThreadId !== sourceThreadId && orphanThreadId !== sourceBinding?.threadId) await control.archiveThread(orphanThreadId).catch(() => void 0);
-				throw error;
-			}
-			const threadId = response.thread.id.trim();
-			if (!threadId) throw new Error("Codex thread/fork response did not include a thread id");
-			if (threadId === sourceThreadId || threadId === sourceBinding?.threadId) throw new Error("Codex thread/fork response reused the source thread id");
-			const forkedThreadId = threadId;
-			try {
-				const connectionFingerprint = normalizeOptionalString(control.connectionFingerprint);
-				if (!connectionFingerprint) throw new Error("Codex fork connection did not include a fingerprint");
-				const forkedTurns = await listCodexUpstreamTurns(control, threadId);
-				const expectedLastTurnId = resolved.boundary.retainedMarker.turnId;
-				if ((forkedTurns.at(-1)?.id ?? null) !== expectedLastTurnId) {
-					await compensateFork(forkedThreadId);
-					return {
-						status: "failed",
-						code: "upstream-unavailable",
-						message: "This Codex version does not support message-level forks. Update Codex, reconnect, and try again."
-					};
-				}
-				const forkedThread = {
-					...response.thread,
-					turns: forkedTurns
-				};
-				const throughTurnId = codexLastTerminalTurnId(forkedThread, normalizeOptionalString) ?? null;
-				const marker = codexUpstreamBaseline(forkedThread, normalizeOptionalString);
-				const config = options.resolveConfig?.() ?? {};
-				return {
-					status: "created",
-					key: (await createImportedCodexSession({
-						runtime: options.runtime,
-						config,
-						key: params.targetKey,
-						agentId: params.source.agentId,
-						thread: forkedThread,
-						throughTurnId,
-						initialEntry: {
-							agentHarnessId: options.harnessRuntimeId,
-							modelSelectionLocked: true
-						},
-						afterImport: async (entry) => {
-							const bindingIdentity = sessionBindingIdentity({
-								agentId: entry.agentId,
-								sessionId: entry.sessionId,
-								sessionKey: entry.key,
-								config
-							});
-							linked = upsertSessionUpstreamLink({
-								sessionKey: entry.key,
-								agentId: entry.agentId,
-								catalogId: params.upstream.catalogId,
-								hostId: params.upstream.hostId,
-								threadId,
-								upstreamKind: params.upstream.kind,
-								upstreamRef: {
-									connectionFingerprint,
-									threadId
-								},
-								marker
-							});
-							if (!linked) throw new Error("Codex fork link could not be persisted");
-							createdBinding = {
-								identity: bindingIdentity,
-								pending: {
-									sourceThreadId: threadId,
-									connectionFingerprint,
-									...throughTurnId ? { lastTurnId: throughTurnId } : {}
-								}
-							};
-							if (!await options.bindingStore.mutate(bindingIdentity, {
-								kind: "set",
-								if: { kind: "absent" },
-								binding: {
-									threadId,
-									connectionScope: "supervision",
-									supervisionSourceThreadId: threadId,
-									preserveNativeModel: true,
-									conversationSourceTransferComplete: true,
-									pendingSupervisionBranch: createdBinding.pending,
-									cwd: forkedThread.cwd ?? "",
-									model: response.model,
-									modelProvider: response.modelProvider ?? void 0,
-									historyCoveredThrough: (/* @__PURE__ */ new Date()).toISOString()
-								}
-							})) {
-								createdBinding = void 0;
-								throw new Error("Codex session binding changed before the fork could be attached");
-							}
-							return { pluginExtensions: entry.entry.pluginExtensions };
-						}
-					})).key,
-					...resolved.editorText !== void 0 ? { editorText: resolved.editorText } : {}
-				};
-			} catch {
-				await compensateFork(forkedThreadId);
-				return {
-					status: "failed",
-					code: "upstream-unavailable",
-					message: "The Codex fork could not be verified or imported into a new session. Refresh sessions and try again."
-				};
-			}
-		});
-	} catch {
-		return {
-			status: "failed",
-			code: "upstream-unavailable",
-			message: "The Codex thread could not be forked. Check that Codex is available, then try again."
-		};
-	}
-}
-//#endregion
-export { forkCodexUpstreamSession };