@openclaw/codex 2026.9.5 → 2026.9.7

package/dist/.setup/session-catalog-events-jMcYfQyd.mjs

@@ -1,250 +0,0 @@
-import { n as defineCodexBuildState } from "./build-state-Xx9ybZqa.mjs";
-import { g as resolveCodexAppServerLocalHomeDir, m as isJsonObject, r as inferCodexAppServerConnectionClass } from "./config-security-BRQ2mgW9.mjs";
-import { o as codexCatalogSourceForClient, r as projectCodexCatalogNativeThread, v as MAX_CWD_LENGTH, x as boundedCatalogString } from "./session-catalog-native-projection-ChV3cCtm.mjs";
-import { t as buildCodexAppServerConnectionFingerprint } from "./plugin-app-cache-key-BOxKP7db.mjs";
-import { createHash } from "node:crypto";
-import { embeddedAgentLog } from "openclaw/plugin-sdk/agent-harness-registration";
-import fs from "node:fs";
-import path from "node:path";
-import fs$1 from "node:fs/promises";
-import { createZstdDecompress } from "node:zlib";
-import { root } from "openclaw/plugin-sdk/file-access-runtime";
-//#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);
-		}
-	}
-}
-/** Passive local listing uses native creation provenance, with rollout fallback for older records. */
-async function isOpenClawManagedCodexThread(thread, localSessionsRoot, diagnostics) {
-	const started = diagnostics ? performance.now() : 0;
-	if (diagnostics) diagnostics.fields.provenanceChecks++;
-	try {
-		const rolloutPath = typeof thread.path === "string" ? thread.path.trim() : "";
-		if (!localSessionsRoot || !rolloutPath) return false;
-		if (typeof thread.originator === "string" && thread.originator.length > 0) return thread.originator === "openclaw";
-		const cacheKey = `${localSessionsRoot}\0${rolloutPath}`;
-		const cached = provenanceByPath.get(cacheKey);
-		if (cached !== void 0) {
-			if (diagnostics) diagnostics.fields.provenanceCacheHits++;
-			return cached;
-		}
-		if (diagnostics) diagnostics.fields.provenanceReadCalls++;
-		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;
-	} finally {
-		if (diagnostics) diagnostics.fields.provenanceMs = (diagnostics.fields.provenanceMs ?? 0) + performance.now() - started;
-	}
-}
-//#endregion
-//#region extensions/codex/src/session-catalog-home-id.ts
-function canonicalCodexCatalogHome(value) {
-	const resolved = path.resolve(value);
-	try {
-		return fs.realpathSync.native(resolved);
-	} catch {
-		return resolved;
-	}
-}
-/** One canonical identity for catalog discovery and durable ownership rows. */
-function codexCatalogHomeId(codexHome) {
-	return codexCatalogHomeIdFromCanonicalPath(canonicalCodexCatalogHome(codexHome));
-}
-/** Hashes lifecycle-prepared paths without repeating filesystem discovery. */
-function codexCatalogHomeIdFromCanonicalPath(codexHome) {
-	return createHash("sha256").update("openclaw:codex-session-catalog-home:v1\0").update(codexHome).digest("hex");
-}
-//#endregion
-//#region extensions/codex/src/session-catalog-events.ts
-const getCatalogEvents = defineCodexBuildState("openclaw.codexCatalogEvents", () => ({
-	listeners: /* @__PURE__ */ new Map(),
-	clients: /* @__PURE__ */ new WeakMap()
-}));
-const CATALOG_NOTIFICATION_METHODS = /* @__PURE__ */ new Set([
-	"thread/started",
-	"turn/started",
-	"turn/completed",
-	"thread/archived",
-	"thread/deleted",
-	"thread/unarchived",
-	"thread/reverted",
-	"thread/name/updated",
-	"thread/status/changed",
-	"thread/settings/updated"
-]);
-/** Uses prepared local identity or resolves it once during client/index startup. */
-async function codexCatalogResidentHomeKey(params) {
-	if (inferCodexAppServerConnectionClass(params.startOptions) === "remote") {
-		const fingerprint = buildCodexAppServerConnectionFingerprint({
-			start: params.startOptions,
-			connectionClass: "remote"
-		}, params.agentDir);
-		return `remote:${createHash("sha256").update(fingerprint).digest("hex")}`;
-	}
-	if (params.sourceHomeId) return params.sourceHomeId;
-	const home = path.resolve(params.runtimeIdentity?.codexHome ?? resolveCodexAppServerLocalHomeDir(params.startOptions, params.agentDir));
-	return codexCatalogHomeIdFromCanonicalPath(await fs$1.realpath(home).catch(() => home));
-}
-function subscribeCodexCatalogEvents(homeKey, listener, callbacks = {}) {
-	const { listeners } = getCatalogEvents();
-	let homeListeners = listeners.get(homeKey);
-	if (!homeListeners) {
-		homeListeners = /* @__PURE__ */ new Set();
-		listeners.set(homeKey, homeListeners);
-	}
-	const subscription = {
-		notify: listener,
-		...callbacks
-	};
-	homeListeners.add(subscription);
-	return () => {
-		homeListeners.delete(subscription);
-		if (homeListeners.size === 0 && listeners.get(homeKey) === homeListeners) listeners.delete(homeKey);
-	};
-}
-/** Observes physical clients without extending their lease or native thread lifetime. */
-function observeCodexCatalogClient(client, params) {
-	const state = getCatalogEvents();
-	const existing = state.clients.get(client);
-	if (existing) return existing.then(() => void 0);
-	const observing = (async () => {
-		const homeKey = await codexCatalogResidentHomeKey({
-			...params,
-			runtimeIdentity: client.getRuntimeIdentity()
-		});
-		if (client.getCloseError()) return;
-		const source = codexCatalogSourceForClient(client);
-		const notifyLifecycle = (callback) => {
-			for (const listener of state.listeners.get(homeKey) ?? []) try {
-				listener[callback]?.(source);
-			} catch (error) {
-				embeddedAgentLog.warn("Codex catalog lifecycle observer failed", {
-					callback,
-					error
-				});
-			}
-		};
-		const readThread = async (threadId) => (await client.request("thread/read", {
-			threadId,
-			includeTurns: false
-		}, { timeoutMs: 6e4 })).thread;
-		const stopNotifications = client.addNotificationHandler((event) => {
-			if (!CATALOG_NOTIFICATION_METHODS.has(event.method)) return;
-			for (const listener of state.listeners.get(homeKey) ?? []) listener.notify(event, readThread, source);
-		});
-		const stopClose = client.addCloseHandler(() => {
-			stopNotifications();
-			stopClose();
-			notifyLifecycle("onClose");
-		});
-		if (inferCodexAppServerConnectionClass(params.startOptions) === "remote") notifyLifecycle("onRemoteReady");
-		return {
-			homeKey,
-			source
-		};
-	})();
-	state.clients.set(client, observing);
-	return observing.then(() => void 0);
-}
-/** Acknowledged resume settings may differ from the response thread's persisted metadata. */
-function publishCodexCatalogResume(client, response, sanitize) {
-	try {
-		return publishPreparedResume(client, {
-			thread: projectCodexCatalogNativeThread(response.thread, sanitize),
-			cwd: boundedCatalogString(response.cwd, MAX_CWD_LENGTH),
-			modelProvider: boundedCatalogString(response.modelProvider, 500, "truncate")
-		});
-	} catch (error) {
-		embeddedAgentLog.warn("Codex catalog resume publication failed", { error });
-		return Promise.resolve();
-	}
-}
-async function publishPreparedResume(client, response) {
-	try {
-		const state = getCatalogEvents();
-		const binding = await state.clients.get(client);
-		if (!binding || binding.source.closed) return;
-		await Promise.all(Array.from(state.listeners.get(binding.homeKey) ?? [], async (listener) => {
-			try {
-				await listener.onResume?.(response, binding.source);
-			} catch (error) {
-				embeddedAgentLog.warn("Codex catalog resume observer failed", { error });
-			}
-		}));
-	} catch (error) {
-		embeddedAgentLog.warn("Codex catalog resume publication failed", { error });
-	}
-}
-//#endregion
-export { codexCatalogHomeId as a, readCodexSessionMeta as c, subscribeCodexCatalogEvents as i, observeCodexCatalogClient as n, codexCatalogHomeIdFromCanonicalPath as o, publishCodexCatalogResume as r, isOpenClawManagedCodexThread as s, codexCatalogResidentHomeKey as t };

package/dist/.setup/session-history-read-B3ZfSUbF.mjs

@@ -1,50 +0,0 @@
-import { n as codexHistoryRejectionReason, t as CodexHistoryRejection } from "./history-rejection-B4nOXNXF.mjs";
-import { n as sanitizeCodexHistoryImagePayloads } from "./image-payload-sanitizer-tupAr-2o.mjs";
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import fs from "node:fs/promises";
-import { SessionTranscriptReadFenceError, readCodexSessionContext } from "openclaw/plugin-sdk/codex-session-transcript-runtime";
-//#region extensions/codex/src/app-server/session-history-read.ts
-function consumeCodexHistory(messages, header, sessionId, read, imageLabel = "codex mirrored history") {
-	if (!isRecord(header) || header.type !== "session") return read([]);
-	if (typeof header.id !== "string") throw new CodexHistoryRejection("malformed_header");
-	if (header.id !== sessionId) return read([]);
-	return read((function* () {
-		for (const message of messages) yield sanitizeCodexHistoryImagePayloads(message, imageLabel);
-	})());
-}
-/** Keeps native evidence and its synchronous consumer inside the same readonly snapshot. */
-async function readCodexNativeHistory(target, sessionId, read, admission, onSnapshot) {
-	const consume = (messages, header, version) => {
-		try {
-			onSnapshot?.(version);
-			return {
-				status: "ok",
-				value: consumeCodexHistory(messages, header, sessionId, read)
-			};
-		} catch (error) {
-			return {
-				status: "rejected",
-				reason: codexHistoryRejectionReason(error)
-			};
-		}
-	};
-	try {
-		if (target.kind === "empty") return consume([], void 0);
-		if (target.kind === "sqlite") return readCodexSessionContext(target.target, consume, admission);
-		const { buildSessionContext, migrateSessionEntries, parseSessionEntries } = await import("openclaw/plugin-sdk/agent-sessions");
-		const entries = parseSessionEntries(await fs.readFile(target.sessionFile, "utf-8"));
-		return consume((function* () {
-			migrateSessionEntries(entries);
-			const sessionEntries = entries.filter((entry) => isRecord(entry) && entry.type !== "session");
-			yield* buildSessionContext(sessionEntries).messages;
-		})(), entries[0]);
-	} catch (error) {
-		if (isRecord(error) && error.code === "ENOENT") return consume([], void 0);
-		return {
-			status: "rejected",
-			reason: error instanceof SessionTranscriptReadFenceError || isRecord(error) && (error.code === "EACCES" || error.code === "EPERM") ? "access_rejected" : codexHistoryRejectionReason(error)
-		};
-	}
-}
-//#endregion
-export { readCodexNativeHistory as n, consumeCodexHistory as t };

package/dist/.setup/session-initialization-DH1z6fXn.mjs

@@ -1,75 +0,0 @@
-import { h as validateBindingForWrite } from "./session-binding-record-TH3xA0zj.mjs";
-import "./session-binding-_0W_fHRr.mjs";
-import { isDeepStrictEqual } from "node:util";
-import { deleteSessionUpstreamLink, upsertSessionUpstreamLink } from "openclaw/plugin-sdk/session-catalog";
-//#region extensions/codex/src/app-server/session-initialization.ts
-const initializations = /* @__PURE__ */ new WeakMap();
-/** Associate the host's exact handle before any potentially committing plugin write. */
-function prepareCodexSessionInitialization(params) {
-	const { initialization, bindingStore, identity } = params;
-	initialization.assertCurrent();
-	let link;
-	const ownership = {
-		store: bindingStore,
-		identity: structuredClone(identity),
-		assertCleanupAllowed: params.assertCleanupAllowed,
-		cleanup: async () => {
-			initialization.assertRollbackCurrent();
-			if (link && deleteSessionUpstreamLink(link.sessionKey, link.agentId, {
-				expected: link,
-				assertCommitAllowed: initialization.assertRollbackCurrent
-			}) === "changed") throw new Error("Codex initialization link changed before cleanup");
-			initialization.assertRollbackCurrent();
-			await cleanup?.(initialization.assertRollbackCurrent);
-			initialization.assertRollbackCurrent();
-		}
-	};
-	initializations.set(initialization, ownership);
-	const cleanup = params.prepareCleanup?.();
-	return {
-		assertCurrent: initialization.assertCurrent,
-		async bind(binding) {
-			initialization.assertCurrent();
-			ownership.binding = validateBindingForWrite(binding);
-			if (!await bindingStore.mutate(identity, {
-				kind: "set",
-				if: { kind: "absent" },
-				binding: ownership.binding
-			}, initialization.assertCurrent)) {
-				ownership.binding = void 0;
-				throw new Error("Codex session binding changed during initialization");
-			}
-			initialization.assertCurrent();
-		},
-		link(input) {
-			initialization.assertCurrent();
-			const now = Date.now();
-			link = structuredClone({
-				...input,
-				createdAt: now,
-				updatedAt: now
-			});
-			if (!upsertSessionUpstreamLink(input, {
-				now,
-				ifAbsent: true,
-				assertCommitAllowed: initialization.assertCurrent
-			})) {
-				link = void 0;
-				throw new Error("Codex initialization link could not be persisted");
-			}
-			initialization.assertCurrent();
-		}
-	};
-}
-function getCodexSessionInitializationRollback(store, params, identity, binding) {
-	const handle = params.initialization;
-	if (!handle) return;
-	handle.assertRollbackCurrent();
-	const ownership = initializations.get(handle);
-	if (!ownership && !binding) return;
-	if (!ownership || ownership.store !== store || !isDeepStrictEqual(ownership.identity, identity) || binding && !isDeepStrictEqual(ownership.binding, binding)) throw new Error("Codex initialization binding owner changed before rollback");
-	ownership.assertCleanupAllowed?.();
-	return ownership.cleanup;
-}
-//#endregion
-export { prepareCodexSessionInitialization as n, getCodexSessionInitializationRollback as t };

package/dist/.setup/thread-history-page-BTx-4xsg.mjs

@@ -1,83 +0,0 @@
-import { A as parseTranscriptPage, M as readControlCursor, g as CatalogParamsError } from "./session-catalog-native-projection-ChV3cCtm.mjs";
-//#region extensions/codex/src/app-server/thread-history-page.ts
-const TURN_ITEM_CURSOR_PREFIX = "turn-item:";
-function encodeTurnItemCursor(turnCursor, itemId) {
-	return TURN_ITEM_CURSOR_PREFIX + Buffer.from(JSON.stringify([turnCursor, itemId])).toString("base64url");
-}
-function decodeTurnItemCursor(cursor) {
-	if (!cursor?.startsWith(TURN_ITEM_CURSOR_PREFIX)) return { turnCursor: cursor };
-	let value;
-	try {
-		value = JSON.parse(Buffer.from(cursor.slice(10), "base64url").toString());
-	} catch {
-		throw new CatalogParamsError("invalid Codex transcript item cursor");
-	}
-	if (!Array.isArray(value) || value.length !== 2 || typeof value[0] !== "string" || !value[0] || typeof value[1] !== "string" || !value[1]) throw new CatalogParamsError("invalid Codex transcript item cursor");
-	return {
-		turnCursor: value[0],
-		itemId: value[1]
-	};
-}
-/** Legacy stores expose only turn cursors; an item identity preserves paging across appends. */
-async function readLegacyCodexHistoryPage(readTurns, request, projection) {
-	const { turnCursor, itemId } = decodeTurnItemCursor(request.cursor);
-	const page = parseTranscriptPage(await readTurns({
-		threadId: request.threadId,
-		limit: 1,
-		sortDirection: "desc",
-		itemsView: "full",
-		...turnCursor ? { cursor: turnCursor } : {}
-	}));
-	const source = page.data.flatMap(({ items, ...turn }) => items.toReversed().map((item) => ({
-		turnId: turn.id,
-		item,
-		turn
-	})));
-	const anchorIndex = itemId ? source.findIndex(({ item }) => item.id === itemId) : -1;
-	if (itemId && anchorIndex < 0) throw new CatalogParamsError("Codex transcript changed; refresh the session before loading older items");
-	const remaining = source.slice(anchorIndex + 1);
-	const items = projection.project(remaining.slice(0, request.limit), request.limit);
-	const result = () => {
-		const lastSource = remaining[items.length - 1];
-		const partial = lastSource !== void 0 && items.length < remaining.length;
-		const nativeCursor = partial ? page.backwardsCursor : page.nextCursor;
-		const cursor = nativeCursor ? partial ? encodeTurnItemCursor(nativeCursor, lastSource.item.id) : nativeCursor : void 0;
-		if (partial && !cursor) throw new Error("Codex app-server did not provide a transcript continuation anchor");
-		return {
-			items,
-			...cursor ? { nextCursor: cursor } : {}
-		};
-	};
-	let bounded = result();
-	while (!projection.fits(bounded)) {
-		if (items.length <= 1) throw new Error("Codex transcript item exceeds the safe response size");
-		items.pop();
-		bounded = result();
-	}
-	return bounded;
-}
-/** Callers authorize the thread; this reader owns native cursor and response-size semantics. */
-async function readCodexThreadHistoryPage(control, thread, request, projection) {
-	if (thread.historyMode !== "paginated") return readLegacyCodexHistoryPage((params) => control.listTurnPage(params), request, projection);
-	let limit = request.limit;
-	for (;;) {
-		const page = await control.listItemPage({
-			threadId: request.threadId,
-			limit,
-			sortDirection: "desc",
-			...request.cursor ? { cursor: request.cursor } : {}
-		});
-		const nextCursor = readControlCursor(page.nextCursor, "transcript next response");
-		const items = projection.project(page.data, limit);
-		const result = {
-			items,
-			...nextCursor ? { nextCursor } : {}
-		};
-		const fittingCount = items.length - (projection.fits(result) ? 0 : 1);
-		if (fittingCount === page.data.length) return result;
-		if (fittingCount < 1) throw new Error("Codex transcript item exceeds the safe response size");
-		limit = fittingCount;
-	}
-}
-//#endregion
-export { readLegacyCodexHistoryPage as n, readCodexThreadHistoryPage as t };