@openclaw/codex 2026.9.3 → 2026.9.5

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

@@ -0,0 +1,250 @@
+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 };