@openclaw/codex 2026.9.2 → 2026.9.4

package/dist/thread-history-page-D0JIp48V.js

@@ -0,0 +1,361 @@
+import { n as CODEX_INTERACTIVE_THREAD_SOURCE_KINDS, t as CODEX_INTERACTIVE_CUSTOM_THREAD_SOURCES } from "./protocol-5bh1G-H7.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
+//#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 { readPageParams as C, unwrapNodeInvokePayload as D, toCatalogSession as E, readGatewayParams as S, requireOnlyKeys as T, parseCatalogPage as _, CODEX_APP_SERVER_THREAD_TURNS_LIST_COMMAND as a, readBoundedOptionalString as b, CatalogParamsError as c, NODE_INVOKE_TIMEOUT_MS as d, boundedCatalogString as f, normalizeLimit as g, isInteractiveThreadSource as h, CODEX_APP_SERVER_THREADS_LIST_COMMAND as i, MAX_CURSOR_LENGTH as l, filterCatalogPageByTitle as m, readLegacyCodexHistoryPage as n, CODEX_CATALOG_TRANSCRIPT_READ_COMMAND as o, catalogError as p, CODEX_APP_SERVER_THREADS_CAPABILITY as r, CODEX_LOCAL_SESSION_HOST_ID as s, readCodexThreadHistoryPage as t, MAX_TRANSCRIPT_PAGE_BYTES as u, parseJsonParams as v, requireBoundThread as w, readControlCursor as x, parseTranscriptPage as y };