@openclaw/codex 2026.9.2 → 2026.9.3

package/dist/session-catalog-node-continue-CBtc4wkI.js

@@ -0,0 +1,238 @@
+import { n as createCodexCliNodeConversationBindingData } from "./conversation-binding-data-BiodpIzq.js";
+import { t as CODEX_CLI_SESSION_RESUME_COMMAND } from "./node-cli-sessions-rj0ysJwM.js";
+import { a as lookupNodeCodexCatalogRecord } from "./session-catalog-HaDcp7Sv.js";
+import { T as unwrapNodeInvokePayload, _ as parseTranscriptPage, d as catalogError, f as filterCatalogPageByTitle, h as parseCatalogPage, l as NODE_INVOKE_TIMEOUT_MS, n as CODEX_APP_SERVER_THREADS_LIST_COMMAND, o as CatalogParamsError, p as isInteractiveThreadSource, r as CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND, u as boundedCatalogString } from "./session-catalog-parsing-CdD3JhdM.js";
+import { t as codexLastTerminalTurnId } from "./session-upstream-marker-D15C9NHp.js";
+import { n as withTimeout } from "./timeout-BVw8aaM1.js";
+import { createOrReuseNodeAdoptedSession, finalizeNodeAdoptedSession, findNodeAdoptedSessionEntry, nodeSessionMarker, runSessionActionExclusive } from "./session-catalog-node-adoption-BUuDYY8R.js";
+import { resolveSessionAgentIdsStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { createSessionCatalogAdoptionCoordinator, publishSessionCatalogHost, sessionCatalogAdoptedSourceKey } from "openclaw/plugin-sdk/session-catalog";
+//#region extensions/codex/src/session-catalog-node-continue.ts
+const CODEX_NODE_CONTINUE_COMMANDS = [
+	CODEX_APP_SERVER_THREADS_LIST_COMMAND,
+	CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
+	CODEX_CLI_SESSION_RESUME_COMMAND
+];
+const NODE_CATALOG_LIST_RESPONSE_TIMEOUT_MS = 8e3;
+const continueNodeAdoption = createSessionCatalogAdoptionCoordinator();
+function nodeLabel(node) {
+	return node.displayName?.trim() || node.remoteIp?.trim() || node.nodeId;
+}
+function compareNodeLabels(left, right) {
+	const leftLabel = nodeLabel(left);
+	const rightLabel = nodeLabel(right);
+	if (leftLabel < rightLabel) return -1;
+	if (leftLabel > rightLabel) return 1;
+	return 0;
+}
+function canContinueCodexOnNode(node) {
+	return node.connected === true && CODEX_NODE_CONTINUE_COMMANDS.every((command) => node.commands?.includes(command) === true && node.invocableCommands?.includes(command) === true);
+}
+async function listPairedNode(params) {
+	const hostId = `node:${params.node.nodeId}`;
+	const common = {
+		hostId,
+		label: nodeLabel(params.node),
+		kind: "node",
+		nodeId: params.node.nodeId,
+		canContinueCodex: canContinueCodexOnNode(params.node),
+		...params.terminalCapabilities
+	};
+	if (params.node.connected !== true) {
+		const host = {
+			...common,
+			connected: false,
+			sessions: [],
+			error: {
+				code: "NODE_OFFLINE",
+				message: "Paired node is offline"
+			}
+		};
+		params.onHost?.(host);
+		return host;
+	}
+	if (!params.node.commands?.includes("codex.appServer.threads.list.v1")) {
+		const host = {
+			...common,
+			connected: true,
+			sessions: []
+		};
+		params.onHost?.(host);
+		return host;
+	}
+	const eventualHost = Promise.resolve().then(async () => {
+		const raw = await params.runtime.nodes.invoke({
+			nodeId: params.node.nodeId,
+			command: CODEX_APP_SERVER_THREADS_LIST_COMMAND,
+			params: {
+				agentId: params.agentId,
+				cursor: params.query.cursors?.[hostId],
+				limit: params.query.limitPerHost,
+				searchTerm: params.query.search
+			},
+			timeoutMs: NODE_INVOKE_TIMEOUT_MS,
+			scopes: ["operator.write"],
+			signal: params.signal
+		});
+		const page = filterCatalogPageByTitle(parseCatalogPage(unwrapNodeInvokePayload(raw)), params.query.search);
+		return {
+			...common,
+			connected: true,
+			...page,
+			sessions: page.sessions.map((session) => {
+				const adopted = params.adoptedSessions.get(sessionCatalogAdoptedSourceKey(hostId, session.threadId));
+				return adopted ? Object.assign({}, session, { sessionKey: adopted.key }) : session;
+			})
+		};
+	}).catch((error) => ({
+		...common,
+		connected: true,
+		sessions: [],
+		error: catalogError("NODE_INVOKE_FAILED", error)
+	}));
+	publishSessionCatalogHost(params, eventualHost);
+	try {
+		return await withTimeout(eventualHost, NODE_CATALOG_LIST_RESPONSE_TIMEOUT_MS, "paired node Codex session catalog timed out");
+	} catch (error) {
+		return {
+			...common,
+			connected: true,
+			sessions: [],
+			error: catalogError("NODE_INVOKE_FAILED", error)
+		};
+	}
+}
+async function requireNodeForCodexContinue(params) {
+	const nodeId = params.hostId.slice(5).trim();
+	if (!nodeId || params.hostId !== `node:${nodeId}`) throw new CatalogParamsError("Codex session catalog hostId is invalid");
+	const node = (await params.runtime.nodes.list()).nodes.find((candidate) => candidate.nodeId === nodeId);
+	if (!node || !canContinueCodexOnNode(node)) throw new CatalogParamsError("paired node does not permit Codex session continuation");
+	return {
+		node,
+		nodeId
+	};
+}
+function requireContinuableNodeRecord(record) {
+	if (record.archived) throw new CatalogParamsError("Codex session is archived on the paired node");
+	if (!isInteractiveThreadSource(record.source)) throw new CatalogParamsError("Codex session is not a non-archived interactive Codex session");
+	if (record.status === "idle" || record.status === "notLoaded") return;
+	if (record.status === "active") throw new CatalogParamsError("Codex session is active on the paired node; wait for it to finish before continuing");
+	throw new CatalogParamsError("Codex session cannot be continued in its current state");
+}
+async function readNodeCodexHistory(params) {
+	const raw = await params.runtime.nodes.invoke({
+		nodeId: params.nodeId,
+		command: CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND,
+		params: {
+			agentId: params.agentId,
+			threadId: params.record.threadId,
+			limit: 50
+		},
+		timeoutMs: NODE_INVOKE_TIMEOUT_MS,
+		scopes: ["operator.write"]
+	});
+	const page = parseTranscriptPage(unwrapNodeInvokePayload(raw));
+	const thread = {
+		id: params.record.threadId,
+		createdAt: params.record.createdAt ?? 0,
+		modelProvider: params.record.modelProvider ?? "openai",
+		projectId: null,
+		turns: page.data.toReversed()
+	};
+	return {
+		thread,
+		throughTurnId: codexLastTerminalTurnId(thread, (value) => boundedCatalogString(value, 256)) ?? null
+	};
+}
+async function continueNodeCodexSessionInner(params) {
+	const { nodeId } = await requireNodeForCodexContinue({
+		runtime: params.api.runtime,
+		hostId: params.hostId
+	});
+	const lookup = await lookupNodeCodexCatalogRecord({
+		agentId: params.agentId,
+		runtime: params.api.runtime,
+		nodeId,
+		threadId: params.threadId
+	});
+	if (lookup.kind !== "found") throw new CatalogParamsError(lookup.kind === "cursor-cycle" ? "Codex session eligibility could not be verified" : "Codex session is unavailable on the paired node");
+	const record = lookup.record;
+	requireContinuableNodeRecord(record);
+	const existing = findNodeAdoptedSessionEntry({
+		agentId: params.agentId,
+		config: params.config,
+		runtime: params.api.runtime,
+		hostId: params.hostId,
+		threadId: params.threadId,
+		includeInitializing: true
+	});
+	let adopted;
+	let disposition;
+	if (existing) {
+		adopted = existing;
+		disposition = "existing";
+	} else {
+		const history = await readNodeCodexHistory({
+			agentId: params.agentId,
+			runtime: params.api.runtime,
+			nodeId,
+			record
+		});
+		adopted = await createOrReuseNodeAdoptedSession({
+			agentId: params.agentId,
+			api: params.api,
+			config: params.config,
+			hostId: params.hostId,
+			nodeId,
+			record,
+			history
+		});
+		disposition = "forked";
+	}
+	const marker = nodeSessionMarker({
+		hostId: params.hostId,
+		threadId: params.threadId,
+		nodeId
+	});
+	return {
+		sessionKey: adopted.key,
+		disposition,
+		conversationBinding: {
+			summary: "Continue this Codex session on its paired node.",
+			detachHint: "Start a new chat to leave the paired-node Codex session.",
+			data: createCodexCliNodeConversationBindingData({
+				nodeId,
+				sessionId: params.threadId,
+				agentId: adopted.agentId,
+				cwd: record.cwd
+			})
+		},
+		afterConversationBound: async () => await finalizeNodeAdoptedSession({
+			api: params.api,
+			adopted,
+			marker
+		})
+	};
+}
+async function continueNodeCodexSession(params) {
+	if (params.clientScopes?.includes("operator.admin") !== true) throw new CatalogParamsError("continuing a paired-node Codex session requires operator.admin");
+	const nodeId = params.hostId.slice(5).trim();
+	if (!nodeId || params.hostId !== `node:${nodeId}`) throw new CatalogParamsError("Codex session catalog hostId is invalid");
+	const agentId = resolveSessionAgentIdsStrict({
+		config: params.config,
+		agentId: params.agentId
+	}).sessionAgentId;
+	const sourceKey = sessionCatalogAdoptedSourceKey(`node:${nodeId}`, params.threadId);
+	const operationKey = sessionCatalogAdoptedSourceKey(agentId, sourceKey);
+	return await continueNodeAdoption({
+		sourceKey: operationKey,
+		findExisting: () => void 0,
+		create: () => runSessionActionExclusive(sourceKey, async () => continueNodeCodexSessionInner({
+			...params,
+			agentId
+		})),
+		complete: async (continued) => continued
+	});
+}
+//#endregion
+export { compareNodeLabels, continueNodeCodexSession, listPairedNode, nodeLabel };

package/dist/session-catalog-parsing-CdD3JhdM.js

@@ -0,0 +1,280 @@
+import { n as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, t as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES } from "./protocol-CAAcVIKF.js";
+import { asFiniteNumber, isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+//#region extensions/codex/src/session-catalog-parsing.ts
+const DEFAULT_PAGE_LIMIT = 50;
+const CODEX_APP_SERVER_THREADS_CAPABILITY = "codex-app-server-threads";
+const CODEX_APP_SERVER_THREADS_LIST_COMMAND = "codex.appServer.threads.list.v1";
+const CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND = "codex.appServer.thread.turns.list.v1";
+const CODEX_CATALOG_TRANSCRIPT_READ_COMMAND = "codex.sessionCatalog.transcript.read.v1";
+const CODEX_LOCAL_SESSION_HOST_ID = "gateway:local";
+const NODE_INVOKE_TIMEOUT_MS = 65e3;
+const MAX_SEARCH_LENGTH = 500;
+const MAX_CURSOR_LENGTH = 4096;
+const MAX_CURSOR_COUNT = 100;
+const MAX_HOST_ID_LENGTH = 256;
+const MAX_CWD_LENGTH = 4096;
+const MAX_SESSION_NAME_LENGTH = 500;
+const MAX_SESSION_PREVIEW_LENGTH = 500;
+const MAX_SESSION_KEY_LENGTH = 1024;
+const MAX_METADATA_LENGTH = 500;
+const MAX_ACTIVE_FLAGS = 16;
+const MAX_TRANSCRIPT_PAGE_BYTES = 20971520;
+var CatalogParamsError = class extends Error {};
+function readControlCursor(value, label) {
+	if (value === void 0 || value === null) return;
+	if (typeof value !== "string" || !value.trim() || value.length > 4096) throw new CatalogParamsError(`invalid Codex session catalog ${label} cursor`);
+	return value;
+}
+function boundedCatalogString(value, maxLength, overflow = "omit") {
+	if (typeof value !== "string") return;
+	const normalized = value.trim();
+	if (!normalized) return;
+	if (normalized.length <= maxLength) return normalized;
+	return overflow === "truncate" ? truncateUtf16Safe(normalized, maxLength) : void 0;
+}
+function catalogPreview(value, sanitize) {
+	if (typeof value !== "string") return;
+	return boundedCatalogString(sanitize(value.replace(/\s+/g, " ")), MAX_SESSION_PREVIEW_LENGTH, "truncate");
+}
+function normalizeInteractiveThreadSource(source) {
+	if (CODEX_INTERACTIVE_THREAD_SOURCE_KINDS.some((kind) => kind === source) || CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES.some((kind) => kind === source)) return source;
+	if (isRecord(source) && CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES.some((kind) => kind === source.custom)) return source.custom;
+}
+function isInteractiveThreadSource(source) {
+	return normalizeInteractiveThreadSource(source) !== void 0;
+}
+function toCatalogSession(thread, archived, sanitize) {
+	const source = normalizeInteractiveThreadSource(thread.source);
+	if (!source) return;
+	const record = thread;
+	const threadId = boundedCatalogString(thread.id, 256);
+	if (!threadId) return;
+	const activeFlags = thread.status?.type === "active" ? thread.status.activeFlags?.flatMap((flag) => {
+		const normalized = boundedCatalogString(flag, 128);
+		return normalized ? [normalized] : [];
+	}).slice(0, MAX_ACTIVE_FLAGS) : void 0;
+	const gitInfo = isRecord(record.gitInfo) ? record.gitInfo : void 0;
+	const sessionId = boundedCatalogString(thread.sessionId, 256);
+	const name = boundedCatalogString(thread.name, MAX_SESSION_NAME_LENGTH, "truncate");
+	const fallbackName = name ? void 0 : catalogPreview(thread.preview, sanitize);
+	const cwd = boundedCatalogString(thread.cwd, MAX_CWD_LENGTH);
+	const modelProvider = boundedCatalogString(record.modelProvider, MAX_METADATA_LENGTH, "truncate");
+	const cliVersion = boundedCatalogString(record.cliVersion, MAX_METADATA_LENGTH, "truncate");
+	const gitBranch = boundedCatalogString(gitInfo?.branch, MAX_METADATA_LENGTH, "truncate");
+	return {
+		threadId,
+		status: thread.status?.type ?? "notLoaded",
+		archived,
+		...sessionId ? { sessionId } : {},
+		...thread.name === null ? { name: null } : name ? { name } : {},
+		...fallbackName ? { fallbackName } : {},
+		...cwd ? { cwd } : {},
+		...activeFlags?.length ? { activeFlags } : {},
+		...typeof thread.createdAt === "number" && Number.isFinite(thread.createdAt) ? { createdAt: thread.createdAt } : {},
+		...typeof thread.updatedAt === "number" && Number.isFinite(thread.updatedAt) ? { updatedAt: thread.updatedAt } : {},
+		...typeof record.recencyAt === "number" && Number.isFinite(record.recencyAt) ? { recencyAt: record.recencyAt } : record.recencyAt === null ? { recencyAt: null } : {},
+		source,
+		...modelProvider ? { modelProvider } : {},
+		...cliVersion ? { cliVersion } : {},
+		...gitBranch ? { gitBranch } : {}
+	};
+}
+function normalizeLimit(value, key) {
+	if (value === void 0) return DEFAULT_PAGE_LIMIT;
+	if (!Number.isInteger(value) || value < 1 || value > 100) throw new CatalogParamsError(`${key} must be an integer from 1 to 100`);
+	return value;
+}
+function readBoundedOptionalString(params, key, maxLength) {
+	const value = params[key];
+	if (value === void 0) return;
+	if (typeof value !== "string") throw new CatalogParamsError(`${key} must be a string`);
+	const trimmed = value.trim();
+	if (!trimmed) return;
+	if (trimmed.length > maxLength) throw new CatalogParamsError(`${key} must be at most ${maxLength} characters`);
+	return trimmed;
+}
+function requireOnlyKeys(params, allowed) {
+	const unknown = Object.keys(params).find((key) => !allowed.has(key));
+	if (unknown) throw new CatalogParamsError(`unknown Codex session catalog parameter: ${unknown}`);
+}
+function readPageParams(value) {
+	if (!isRecord(value)) throw new CatalogParamsError("Codex session catalog parameters must be an object");
+	const params = value;
+	requireOnlyKeys(params, /* @__PURE__ */ new Set([
+		"cursor",
+		"limit",
+		"searchTerm",
+		"cwd"
+	]));
+	const cursor = readBoundedOptionalString(params, "cursor", MAX_CURSOR_LENGTH);
+	const searchTerm = readBoundedOptionalString(params, "searchTerm", MAX_SEARCH_LENGTH);
+	const cwd = readBoundedOptionalString(params, "cwd", MAX_CWD_LENGTH);
+	return {
+		limit: normalizeLimit(params.limit, "limit"),
+		...cursor ? { cursor } : {},
+		...searchTerm ? { searchTerm } : {},
+		...cwd ? { cwd } : {}
+	};
+}
+function readGatewayParams(value) {
+	if (value !== void 0 && !isRecord(value)) throw new CatalogParamsError("Codex session catalog parameters must be an object");
+	const params = isRecord(value) ? value : {};
+	requireOnlyKeys(params, /* @__PURE__ */ new Set([
+		"search",
+		"limitPerHost",
+		"hostIds",
+		"cursors"
+	]));
+	const search = readBoundedOptionalString(params, "search", MAX_SEARCH_LENGTH);
+	let hostIds;
+	if (params.hostIds !== void 0) {
+		if (!Array.isArray(params.hostIds) || params.hostIds.length > 100) throw new CatalogParamsError(`hostIds must contain at most 100 host ids`);
+		hostIds = [...new Set(params.hostIds.map((hostId) => readHostId(hostId)))];
+	}
+	let cursors;
+	if (params.cursors !== void 0) {
+		if (!isRecord(params.cursors)) throw new CatalogParamsError("cursors must be an object");
+		const entries = Object.entries(params.cursors);
+		if (entries.length > MAX_CURSOR_COUNT) throw new CatalogParamsError(`cursors may contain at most ${MAX_CURSOR_COUNT} hosts`);
+		cursors = {};
+		for (const [hostId, cursor] of entries) {
+			const normalizedHostId = hostId.trim();
+			if (normalizedHostId.length === 0 || normalizedHostId.length > MAX_HOST_ID_LENGTH || !normalizedHostId.startsWith("gateway:") && !normalizedHostId.startsWith("node:")) throw new CatalogParamsError(`invalid Codex session catalog host id: ${hostId}`);
+			if (typeof cursor !== "string" || !cursor.trim() || cursor.trim().length > 4096) throw new CatalogParamsError(`invalid cursor for Codex session catalog host: ${hostId}`);
+			cursors[normalizedHostId] = cursor.trim();
+		}
+	}
+	return {
+		limitPerHost: normalizeLimit(params.limitPerHost, "limitPerHost"),
+		...search ? { search } : {},
+		...hostIds && hostIds.length > 0 ? { hostIds } : {},
+		...cursors && Object.keys(cursors).length > 0 ? { cursors } : {}
+	};
+}
+function readHostId(value) {
+	if (typeof value !== "string") throw new CatalogParamsError("Codex session catalog host ids must be strings");
+	const hostId = value.trim();
+	if (hostId.length === 0 || hostId.length > MAX_HOST_ID_LENGTH || !hostId.startsWith("gateway:") && !hostId.startsWith("node:")) throw new CatalogParamsError(`invalid Codex session catalog host id: ${value}`);
+	return hostId;
+}
+function parseJsonParams(paramsJSON) {
+	if (!paramsJSON?.trim()) return {};
+	try {
+		return JSON.parse(paramsJSON);
+	} catch (error) {
+		throw new Error("Codex session catalog parameters must be valid JSON", { cause: error });
+	}
+}
+function parseOptionalCatalogString(value, field, maxLength) {
+	if (value === void 0) return;
+	if (typeof value !== "string" || value.length > maxLength) throw new Error(`Codex session catalog returned an invalid ${field}`);
+	return value;
+}
+function parseCatalogSession(value, options = {}) {
+	if (!isRecord(value) || typeof value.threadId !== "string" || !value.threadId.trim() || value.threadId.length > 256 || value.archived !== false) throw new Error("Codex session catalog returned an invalid session");
+	const status = parseOptionalCatalogString(value.status, "status", 64);
+	if (!status?.trim()) throw new Error("Codex session catalog returned an invalid status");
+	if (value.activeFlags !== void 0 && !Array.isArray(value.activeFlags)) throw new Error("Codex session catalog returned invalid active flags");
+	if (Array.isArray(value.activeFlags) && value.activeFlags.length > MAX_ACTIVE_FLAGS) throw new Error("Codex session catalog returned too many active flags");
+	const activeFlags = Array.isArray(value.activeFlags) ? value.activeFlags.map((entry) => {
+		const flag = parseOptionalCatalogString(entry, "active flag", 128);
+		if (flag === void 0) throw new Error("Codex session catalog returned an invalid active flag");
+		return flag;
+	}) : void 0;
+	const sessionId = parseOptionalCatalogString(value.sessionId, "session id", 256);
+	const name = value.name === null ? null : parseOptionalCatalogString(value.name, "session name", MAX_SESSION_NAME_LENGTH);
+	const fallbackName = parseOptionalCatalogString(value.fallbackName, "session fallback name", MAX_SESSION_PREVIEW_LENGTH);
+	const cwd = parseOptionalCatalogString(value.cwd, "cwd", MAX_CWD_LENGTH);
+	const source = parseOptionalCatalogString(value.source, "source", MAX_METADATA_LENGTH);
+	const modelProvider = parseOptionalCatalogString(value.modelProvider, "model provider", MAX_METADATA_LENGTH);
+	const cliVersion = parseOptionalCatalogString(value.cliVersion, "CLI version", MAX_METADATA_LENGTH);
+	const gitBranch = parseOptionalCatalogString(value.gitBranch, "Git branch", MAX_METADATA_LENGTH);
+	const sessionKey = options.allowSessionKey ? parseOptionalCatalogString(value.sessionKey, "OpenClaw session key", MAX_SESSION_KEY_LENGTH) : void 0;
+	const createdAt = asFiniteNumber(value.createdAt);
+	const updatedAt = asFiniteNumber(value.updatedAt);
+	const recencyAt = value.recencyAt === null ? null : asFiniteNumber(value.recencyAt);
+	return {
+		threadId: value.threadId,
+		status,
+		archived: value.archived,
+		...sessionId !== void 0 ? { sessionId } : {},
+		...name !== void 0 ? { name } : {},
+		...fallbackName !== void 0 ? { fallbackName } : {},
+		...cwd !== void 0 ? { cwd } : {},
+		...activeFlags && activeFlags.length > 0 ? { activeFlags } : {},
+		...createdAt !== void 0 ? { createdAt } : {},
+		...updatedAt !== void 0 ? { updatedAt } : {},
+		...recencyAt !== void 0 ? { recencyAt } : {},
+		...source !== void 0 ? { source } : {},
+		...modelProvider !== void 0 ? { modelProvider } : {},
+		...cliVersion !== void 0 ? { cliVersion } : {},
+		...gitBranch !== void 0 ? { gitBranch } : {},
+		...sessionKey !== void 0 ? { sessionKey } : {}
+	};
+}
+function parseCatalogPage(value, options = {}) {
+	if (!isRecord(value) || !Array.isArray(value.sessions) || value.sessions.length > 100) throw new Error("Codex session catalog returned an invalid page");
+	const nextCursor = parseOptionalCatalogString(value.nextCursor, "next cursor", MAX_CURSOR_LENGTH);
+	const backwardsCursor = parseOptionalCatalogString(value.backwardsCursor, "backwards cursor", MAX_CURSOR_LENGTH);
+	return {
+		sessions: value.sessions.map((session) => parseCatalogSession(session, options)),
+		...nextCursor ? { nextCursor } : {},
+		...backwardsCursor ? { backwardsCursor } : {}
+	};
+}
+function filterCatalogPageByTitle(page, searchTerm) {
+	if (!searchTerm) return page;
+	return {
+		...page,
+		sessions: page.sessions.filter((session) => (session.name ?? session.fallbackName)?.toLocaleLowerCase().includes(searchTerm.toLocaleLowerCase()))
+	};
+}
+function unwrapNodeInvokePayload(value) {
+	if (!isRecord(value)) return value;
+	if (typeof value.payloadJSON === "string" && value.payloadJSON.trim()) try {
+		return JSON.parse(value.payloadJSON);
+	} catch (error) {
+		throw new Error("Codex node returned malformed session catalog JSON", { cause: error });
+	}
+	return "payload" in value ? value.payload : value;
+}
+function catalogErrorDetail(error) {
+	if (error instanceof Error) return error.message.trim();
+	if (typeof error === "string") return error.trim();
+	if (error && typeof error === "object" && "message" in error) {
+		const message = error.message;
+		return typeof message === "string" ? message.trim() : "";
+	}
+	return "";
+}
+function catalogError(code, error) {
+	const summary = {
+		APP_SERVER_UNAVAILABLE: "Codex app-server is unavailable on this host",
+		NODE_INVOKE_FAILED: "The paired node could not return its Codex session catalog",
+		NODE_LIST_FAILED: "Paired nodes could not be listed"
+	}[code] ?? "Codex session catalog request failed";
+	const detail = code === "NODE_LIST_FAILED" ? catalogErrorDetail(error) : "";
+	return {
+		code,
+		message: detail && detail !== summary ? `${summary}: ${detail}` : summary
+	};
+}
+function parseTranscriptPage(value) {
+	if (!isRecord(value) || !Array.isArray(value.data) || value.data.length > 50 || value.data.some((turn) => !isRecord(turn) || !Array.isArray(turn.items) || turn.items.some((item) => !isRecord(item)))) throw new Error("Codex app-server returned an invalid transcript page");
+	const nextCursor = readControlCursor(value.nextCursor, "transcript next response");
+	const backwardsCursor = readControlCursor(value.backwardsCursor, "transcript backwards response");
+	const page = {
+		data: value.data,
+		...nextCursor ? { nextCursor } : {},
+		...backwardsCursor ? { backwardsCursor } : {}
+	};
+	if (Buffer.byteLength(JSON.stringify(page), "utf8") > 20971520) throw new Error("Codex app-server transcript page exceeds the safe response size");
+	return page;
+}
+function requireBoundThread(entry) {
+	if (!entry.boundThreadId) throw new CatalogParamsError("Codex adoption is missing its bound thread. Retry.");
+	return entry.boundThreadId;
+}
+//#endregion
+export { requireOnlyKeys as C, requireBoundThread as S, unwrapNodeInvokePayload as T, parseTranscriptPage as _, CODEX_LOCAL_SESSION_HOST_ID as a, readGatewayParams as b, MAX_TRANSCRIPT_PAGE_BYTES as c, catalogError as d, filterCatalogPageByTitle as f, parseJsonParams as g, parseCatalogPage as h, CODEX_CATALOG_TRANSCRIPT_READ_COMMAND as i, NODE_INVOKE_TIMEOUT_MS as l, normalizeLimit as m, CODEX_APP_SERVER_THREADS_LIST_COMMAND as n, CatalogParamsError as o, isInteractiveThreadSource as p, CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND as r, MAX_CURSOR_LENGTH as s, CODEX_APP_SERVER_THREADS_CAPABILITY as t, boundedCatalogString as u, readBoundedOptionalString as v, toCatalogSession as w, readPageParams as x, readControlCursor as y };

package/dist/session-catalog-provenance-DkJHo735.js

@@ -0,0 +1,124 @@
+import { o as isJsonObject } from "./protocol-CAAcVIKF.js";
+import path from "node:path";
+import { createZstdDecompress } from "node:zlib";
+import { root } from "openclaw/plugin-sdk/file-access-runtime";
+//#region extensions/codex/src/app-server/rpc-error.ts
+/** RPC error wrapper that preserves app-server error code and data. */
+var CodexAppServerRpcError = class extends Error {
+	constructor(error, method) {
+		super(formatCodexAppServerRpcErrorMessage(error, method));
+		this.name = "CodexAppServerRpcError";
+		this.code = error.code;
+		this.data = error.data;
+		this.method = method;
+	}
+};
+function isCodexThreadReadMissingError(error, threadId) {
+	return error instanceof CodexAppServerRpcError && error.method === "thread/read" && error.code === -32600 && error.message === `thread not loaded: ${threadId}`;
+}
+function formatCodexAppServerRpcErrorMessage(error, method) {
+	const message = error.message || `${method} failed`;
+	const detail = readCodexAppServerRpcReloginDetail(error.data);
+	return detail && !message.includes(detail) ? `${message}: ${detail}` : message;
+}
+function readCodexAppServerRpcReloginDetail(data) {
+	const record = isJsonObject(data) ? data : void 0;
+	const nested = isJsonObject(record?.error) ? record.error : record;
+	if (!nested) return;
+	const isRelogin = nested.action === "relogin" || nested.reason === "cloudRequirements" && nested.errorCode === "Auth";
+	const detail = typeof nested.detail === "string" ? nested.detail.trim() : "";
+	return isRelogin && detail ? detail : void 0;
+}
+//#endregion
+//#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
+export { isCodexThreadReadMissingError as i, readCodexSessionMeta as n, CodexAppServerRpcError as r, isOpenClawManagedCodexThread as t };

package/dist/{session-cli-BjLhpmS1.js → session-cli-CbgaHh0f.js}

@@ -1,8 +1,9 @@
-import "./session-catalog-B47uwekb.js";
+import "./session-catalog-HaDcp7Sv.js";
+import "./session-catalog-parsing-CdD3JhdM.js";
 import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
-import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
+import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";
 import { addGatewayClientOptions, callGatewayFromCli } from "openclaw/plugin-sdk/gateway-runtime";
 //#region extensions/codex/src/session-cli.ts
 const CODEX_SESSION_CATALOG_CLI_TIMEOUT_MS = 75e3;

package/dist/{session-history-DWmMqiqW.js → session-history-Cz-tOOYj.js}

@@ -1,6 +1,6 @@
-import { n as readCodexNativeHistory, t as consumeCodexHistory } from "./session-history-read-LHldwvyh.js";
-import { getSessionEntry, parseSqliteSessionFileMarker, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
+import { n as readCodexNativeHistory, t as consumeCodexHistory } from "./session-history-read-cxPUxyVV.js";
 import { SessionManager } from "openclaw/plugin-sdk/agent-sessions";
+import { getSessionEntry, parseSqliteSessionFileMarker, resolveTranscriptSessionKeyBySessionId } from "openclaw/plugin-sdk/session-store-runtime";
 //#region extensions/codex/src/app-server/session-history.ts
 function resolveCodexHistoryTarget(target, admission) {
 	if (target.sessionTarget) {
@@ -64,7 +64,10 @@ async function readCodexMirroredSessionHistoryMessages(target, admission, view =
 					signal
 				});
 				result = consumeCodexHistory(loaded.buildSessionContext().messages, loaded.getHeader(), target.sessionId, read, "codex mirrored model context");
-			} else result = await readCodexNativeHistory(resolved, target.sessionId, read, admission);
+			} else {
+				const history = await readCodexNativeHistory(resolved, target.sessionId, read, admission);
+				result = history.status === "ok" ? history.value : void 0;
+			}
 		}
 		signal?.throwIfAborted();
 		return result;