spiracha 1.3.3 → 1.4.0

package/apps/ui/dist/server/assets/{cursor-db-B7agkAvM.js → cursor-db-cYZEU3WQ.js}

@@ -3,6 +3,7 @@ import { getCursorGlobalDbPath, getCursorProjectsDir, getCursorWorkspaceStorageD
 import { Database, constants } from "bun:sqlite";
 import { readdir, stat } from "node:fs/promises";
 import path from "node:path";
+import { createHash } from "node:crypto";
 //#region ../../src/lib/cursor-db.ts
 var CURSOR_READONLY_DB_OPEN_FLAGS = constants.SQLITE_OPEN_READONLY | constants.SQLITE_OPEN_URI;
 var getCursorReadonlyDbUri = (dbPath) => {
@@ -52,10 +53,23 @@ var normalizeCursorPath = (value) => {
 	if (!decoded) return "";
 	return decoded.replace(/\/+$/u, "") || decoded;
 };
+var warnCursorDataIssue = (event, details) => {
+	console.warn(`[spiracha:cursor] ${event}`, details);
+};
+var stripJsonComments = (value) => {
+	return value.replace(/\/\*[\s\S]*?\*\//gu, "").replace(/(^|\s)\/\/.*$/gmu, "$1");
+};
+var parseCodeWorkspaceJson = (text) => {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return JSON.parse(stripJsonComments(text));
+	}
+};
 var parseCodeWorkspaceFolders = async (workspaceFilePath) => {
 	if (!workspaceFilePath.endsWith(".code-workspace")) return [];
 	try {
-		const data = await Bun.file(workspaceFilePath).json();
+		const data = parseCodeWorkspaceJson(await Bun.file(workspaceFilePath).text());
 		const folders = [];
 		for (const entry of data.folders ?? []) {
 			const folderPath = entry.path;
@@ -63,16 +77,28 @@ var parseCodeWorkspaceFolders = async (workspaceFilePath) => {
 			folders.push(folderPath.startsWith("/") ? normalizeCursorPath(folderPath) : normalizeCursorPath(path.join(path.dirname(workspaceFilePath), folderPath)));
 		}
 		return folders;
-	} catch {
+	} catch (error) {
+		warnCursorDataIssue("invalid_code_workspace_json", {
+			error: error instanceof Error ? error.message : String(error),
+			workspaceFilePath
+		});
 		return [];
 	}
 };
 var loadGlobalComposerHeaders = (globalDbPath) => {
-	const db = openCursorReadonlyDb(globalDbPath);
 	try {
-		return readItemValue(db, "composer.composerHeaders")?.allComposers ?? [];
-	} finally {
-		db.close();
+		const db = openCursorReadonlyDb(globalDbPath);
+		try {
+			return readItemValue(db, "composer.composerHeaders")?.allComposers ?? [];
+		} finally {
+			db.close();
+		}
+	} catch (error) {
+		warnCursorDataIssue("global_composer_headers_unavailable", {
+			error: error instanceof Error ? error.message : String(error),
+			globalDbPath
+		});
+		return [];
 	}
 };
 var readBucketWorkspaceJson = async (workspaceJsonPath) => {
@@ -613,6 +639,162 @@ var readBubble = (db, composerId, bubbleId) => {
 var isRenderableBubble = (bubble) => {
 	return Boolean(bubble.text.trim() || bubble.thinking?.trim() || bubble.toolCall);
 };
+var normalizeBubbleText = (value) => {
+	return (value ?? "").replace(/\s+/gu, " ").trim();
+};
+var hashText = (value) => createHash("sha1").update(value).digest("hex").slice(0, 12);
+var stableStringifyJson = (value) => {
+	if (Array.isArray(value)) return `[${value.map(stableStringifyJson).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringifyJson(value[key])}`).join(",")}}`;
+	return JSON.stringify(value);
+};
+var normalizeToolArgumentsText = (value) => {
+	if (!value?.trim()) return "";
+	try {
+		return stableStringifyJson(JSON.parse(value));
+	} catch {
+		return normalizeBubbleText(value);
+	}
+};
+var hasRenderableTextSuperset = (left, right) => {
+	const normalizedLeft = normalizeBubbleText(left);
+	const normalizedRight = normalizeBubbleText(right);
+	if (!normalizedLeft && !normalizedRight) return true;
+	return normalizedLeft === normalizedRight || normalizedLeft.startsWith(normalizedRight) || normalizedRight.startsWith(normalizedLeft);
+};
+var haveSameToolIdentity = (left, right) => {
+	if (!left && !right) return true;
+	if (!left || !right) return false;
+	return left.name === right.name && normalizeToolArgumentsText(left.argumentsText) === normalizeToolArgumentsText(right.argumentsText);
+};
+var areEquivalentBubbles = (left, right) => {
+	return left.kind === right.kind && hasRenderableTextSuperset(left.text, right.text) && Boolean(normalizeBubbleText(left.thinking)) === Boolean(normalizeBubbleText(right.thinking)) && haveSameToolIdentity(left.toolCall, right.toolCall);
+};
+var findAgentTailStartIndex = (existingBubbles, agentBubbles) => {
+	const maxOverlap = Math.min(existingBubbles.length, agentBubbles.length);
+	for (let overlapLength = maxOverlap; overlapLength > 0; overlapLength -= 1) {
+		const existingStart = existingBubbles.length - overlapLength;
+		if (agentBubbles.slice(0, overlapLength).every((bubble, index) => areEquivalentBubbles(existingBubbles[existingStart + index], bubble))) return overlapLength;
+	}
+	return 0;
+};
+var hasEquivalentBubble = (bubbles, candidate) => {
+	return bubbles.some((bubble) => areEquivalentBubbles(bubble, candidate));
+};
+var getAgentTranscriptContentParts = (entry) => {
+	const content = asObject(entry.message ?? null)?.content ?? entry.content ?? null;
+	if (Array.isArray(content)) return content.map((part) => asObject(part)).filter((part) => Boolean(part));
+	if (typeof content === "string") return [{
+		text: content,
+		type: "text"
+	}];
+	return [];
+};
+var parseAgentTranscriptToolCall = (parts) => {
+	const toolUse = parts.find((part) => asString(part.type ?? null) === "tool_use");
+	if (!toolUse) return null;
+	const name = asString(toolUse.name ?? null);
+	if (!name) return null;
+	return {
+		argumentsText: toolUse.input === void 0 ? null : JSON.stringify(toolUse.input),
+		callId: asString(toolUse.id ?? null),
+		name,
+		resultText: null,
+		status: null
+	};
+};
+var parseAgentTranscriptBubble = (filePath, lineNumber, raw) => {
+	const message = asObject(raw.message ?? null);
+	const role = asString(raw.role ?? message?.role ?? null);
+	const kind = role === "user" || role === "assistant" ? role : "unknown";
+	const parts = getAgentTranscriptContentParts(raw);
+	const text = parts.filter((part) => asString(part.type ?? null) === "text").map((part) => asString(part.text ?? null)).filter((value) => Boolean(value?.trim())).join("\n\n");
+	const toolCall = parseAgentTranscriptToolCall(parts);
+	const bubble = {
+		bubbleId: `agent-transcript:${hashText(path.resolve(filePath))}:${path.basename(filePath)}:${lineNumber}`,
+		createdAtMs: null,
+		kind,
+		text,
+		thinking: null,
+		toolCall
+	};
+	return isRenderableBubble(bubble) ? bubble : null;
+};
+var readCursorAgentTranscriptFile = async (filePath) => {
+	let text = "";
+	try {
+		text = await Bun.file(filePath).text();
+	} catch (error) {
+		warnCursorDataIssue("agent_transcript_unreadable", {
+			error: error instanceof Error ? error.message : String(error),
+			filePath
+		});
+		return [];
+	}
+	const bubbles = [];
+	for (const [index, line] of text.split(/\n/u).entries()) {
+		if (!line.trim()) continue;
+		let raw;
+		try {
+			raw = JSON.parse(line);
+		} catch (error) {
+			warnCursorDataIssue("invalid_agent_transcript_jsonl", {
+				error: error instanceof Error ? error.message : String(error),
+				filePath,
+				lineNumber: index + 1
+			});
+			continue;
+		}
+		const entry = asObject(raw);
+		if (!entry) continue;
+		const bubble = parseAgentTranscriptBubble(filePath, index + 1, entry);
+		if (bubble) bubbles.push(bubble);
+	}
+	return bubbles;
+};
+var listCursorAgentTranscriptFiles = async (transcriptDir, composerId) => {
+	const preferred = path.join(transcriptDir, `${composerId}.jsonl`);
+	const files = /* @__PURE__ */ new Set();
+	if (await pathExists(preferred)) files.add(preferred);
+	let entries = [];
+	try {
+		entries = await readdir(transcriptDir);
+	} catch {
+		return [...files];
+	}
+	for (const entry of entries) if (entry.endsWith(".jsonl")) files.add(path.join(transcriptDir, entry));
+	return [...files].sort();
+};
+var readCursorAgentTranscriptBubbles = async (composerId, userDir) => {
+	const transcriptDirs = await findCursorTranscriptDirs(composerId, userDir);
+	const bubbles = [];
+	for (const transcriptDir of transcriptDirs.sort()) {
+		const files = await listCursorAgentTranscriptFiles(transcriptDir, composerId);
+		for (const file of files) bubbles.push(...await readCursorAgentTranscriptFile(file));
+	}
+	return bubbles;
+};
+var mergeAgentTranscriptTail = (transcript, agentBubbles) => {
+	const tailStartIndex = findAgentTailStartIndex(transcript.bubbles, agentBubbles);
+	const seen = [...transcript.bubbles];
+	const appended = [];
+	const candidates = agentBubbles.slice(tailStartIndex);
+	for (const bubble of candidates) {
+		if (hasEquivalentBubble(seen, bubble)) continue;
+		seen.push(bubble);
+		appended.push(bubble);
+	}
+	if (appended.length === 0) return transcript;
+	return {
+		...transcript,
+		bubbles: [...transcript.bubbles, ...appended],
+		renderableBubbleCount: transcript.renderableBubbleCount + appended.length
+	};
+};
+var inferCursorUserDirFromGlobalDbPath = (globalDbPath) => {
+	const globalStorageDir = path.dirname(globalDbPath);
+	return path.basename(globalStorageDir) === "globalStorage" ? path.dirname(globalStorageDir) : resolveCursorUserDir();
+};
 var readCursorThreadTranscript = (globalDbPath, composerId) => {
 	const head = readCursorThreadHead(globalDbPath, composerId);
 	if (!head) return null;
@@ -635,9 +817,14 @@ var readCursorThreadTranscript = (globalDbPath, composerId) => {
 		db.close();
 	}
 };
+var readCursorThreadTranscriptWithAgentFiles = async (globalDbPath, composerId, userDir = inferCursorUserDirFromGlobalDbPath(globalDbPath)) => {
+	const transcript = readCursorThreadTranscript(globalDbPath, composerId);
+	if (!transcript) return null;
+	return mergeAgentTranscriptTail(transcript, await readCursorAgentTranscriptBubbles(composerId, userDir));
+};
 var readAllBubbleIds = (db, composerId) => {
 	const prefix = `bubbleId:${composerId}:`;
 	return db.query("SELECT key FROM cursorDiskKV WHERE key LIKE ? ORDER BY key ASC").all(`${prefix}%`).map((row) => row.key.slice(prefix.length));
 };
 //#endregion
-export { findCursorTranscriptDirs, invalidateCursorDiscoveryCache, listCursorThreadsForGroup, listCursorWorkspaceGroups, loadGlobalComposerHeaders, openCursorReadonlyDb, readCursorThreadTranscript };
+export { findCursorTranscriptDirs, invalidateCursorDiscoveryCache, listCursorThreadsForGroup, listCursorWorkspaceGroups, loadGlobalComposerHeaders, openCursorReadonlyDb, readCursorThreadTranscriptWithAgentFiles };

package/apps/ui/dist/server/assets/{cursor-queries-f7DjBKSD.js → cursor-queries-NCIM0Nat.js}

@@ -1,6 +1,6 @@
 import { t as createServerFn } from "../server.js";
 import { t as isRetryableSqliteError } from "./sqlite-error-LZDrnxdd.js";
-import { t as createSsrRpc } from "./createSsrRpc-DVnVQhGx.js";
+import { t as createSsrRpc } from "./createSsrRpc-C754NPki.js";
 import { z } from "zod";
 import { queryOptions } from "@tanstack/react-query";
 //#region src/lib/cursor-server.ts
@@ -15,24 +15,26 @@ var exportSchema = z.object({
 	includeCommentary: z.boolean().default(true),
 	includeMetadata: z.boolean().default(true),
 	includeTools: z.boolean().default(true),
-	outputFormat: z.enum(["md", "txt"]).default("md")
+	outputFormat: z.enum(["md", "txt"]).default("md"),
+	zipArchive: z.boolean().default(false)
 });
 var exportThreadsSchema = z.object({
 	composerIds: z.array(z.string().min(1)).min(1),
 	includeCommentary: z.boolean().default(true),
 	includeMetadata: z.boolean().default(true),
 	includeTools: z.boolean().default(true),
-	outputFormat: z.enum(["md", "txt"]).default("md")
+	outputFormat: z.enum(["md", "txt"]).default("md"),
+	zipArchive: z.boolean().default(true)
 });
 var deleteThreadsSchema = z.object({ composerIds: z.array(z.string().min(1)).min(1) });
 var listCursorWorkspacesFn = createServerFn({ method: "GET" }).handler(createSsrRpc("8fcf452a4587a4d4dc0c2f6439255e98123f23d863ca0e861403ae2a687272f2"));
-var listCursorThreadsFn = createServerFn({ method: "GET" }).inputValidator(workspaceSchema).handler(createSsrRpc("23fb197bac88fb9e4950ef7608cd311d67c0867e424136c8373071dc54746806"));
-var getCursorThreadDetailFn = createServerFn({ method: "GET" }).inputValidator(threadSchema).handler(createSsrRpc("6e893e740c05aad65a8eb32901b4c39277ebf718f0ba14b04d8df989bed2f32b"));
-var exportCursorThreadFn = createServerFn({ method: "POST" }).inputValidator(exportSchema).handler(createSsrRpc("03050b86e5481024283bee890347a9da7b2493493044dcde6df989b3334d6b73"));
-var exportCursorThreadsFn = createServerFn({ method: "POST" }).inputValidator(exportThreadsSchema).handler(createSsrRpc("e9609d5ab12ea0bc4dbd3289fad95417dd01a0a719c8ee588c0b8c8a9dc80c99"));
-var recoverCursorWorkspaceFn = createServerFn({ method: "POST" }).inputValidator(recoverSchema).handler(createSsrRpc("a9bd5d510f2d1173d2ef610dda4d59a795af17e7c2a4affaba7e1f99822b2c40"));
-var deleteCursorThreadsFn = createServerFn({ method: "POST" }).inputValidator(deleteThreadsSchema).handler(createSsrRpc("17afb84da4a3d5022132756ead0adaf0323660f50fc58d7f14830b01fdd59a13"));
-var deleteCursorWorkspaceFn = createServerFn({ method: "POST" }).inputValidator(workspaceSchema).handler(createSsrRpc("fc72eb7835fc18130f6d7c20e15e560320521cd01c93e08667b340bfe6b90930"));
+var listCursorThreadsFn = createServerFn({ method: "GET" }).validator(workspaceSchema).handler(createSsrRpc("23fb197bac88fb9e4950ef7608cd311d67c0867e424136c8373071dc54746806"));
+var getCursorThreadDetailFn = createServerFn({ method: "GET" }).validator(threadSchema).handler(createSsrRpc("6e893e740c05aad65a8eb32901b4c39277ebf718f0ba14b04d8df989bed2f32b"));
+var exportCursorThreadFn = createServerFn({ method: "POST" }).validator(exportSchema).handler(createSsrRpc("03050b86e5481024283bee890347a9da7b2493493044dcde6df989b3334d6b73"));
+var exportCursorThreadsFn = createServerFn({ method: "POST" }).validator(exportThreadsSchema).handler(createSsrRpc("e9609d5ab12ea0bc4dbd3289fad95417dd01a0a719c8ee588c0b8c8a9dc80c99"));
+var recoverCursorWorkspaceFn = createServerFn({ method: "POST" }).validator(recoverSchema).handler(createSsrRpc("a9bd5d510f2d1173d2ef610dda4d59a795af17e7c2a4affaba7e1f99822b2c40"));
+var deleteCursorThreadsFn = createServerFn({ method: "POST" }).validator(deleteThreadsSchema).handler(createSsrRpc("17afb84da4a3d5022132756ead0adaf0323660f50fc58d7f14830b01fdd59a13"));
+var deleteCursorWorkspaceFn = createServerFn({ method: "POST" }).validator(workspaceSchema).handler(createSsrRpc("fc72eb7835fc18130f6d7c20e15e560320521cd01c93e08667b340bfe6b90930"));
 //#endregion
 //#region src/lib/cursor-queries.ts
 var retrySqliteQuery = (failureCount, error) => {

package/apps/ui/dist/server/assets/{cursor-recovery-9bJLs7vG.js → cursor-recovery-nq-kR62j.js}

@@ -1,5 +1,5 @@
 import { COMPOSER_DATA_KEY, COMPOSER_HEADERS_KEY, getCursorGlobalDbPath, resolveCursorUserDir } from "./cursor-exporter-types-CI3goo-c.js";
-import { findCursorTranscriptDirs, invalidateCursorDiscoveryCache, listCursorWorkspaceGroups, loadGlobalComposerHeaders, openCursorReadonlyDb } from "./cursor-db-B7agkAvM.js";
+import { findCursorTranscriptDirs, invalidateCursorDiscoveryCache, listCursorWorkspaceGroups, loadGlobalComposerHeaders, openCursorReadonlyDb } from "./cursor-db-cYZEU3WQ.js";
 import { Database } from "bun:sqlite";
 import { rm } from "node:fs/promises";
 //#region ../../src/lib/cursor-recovery.ts

package/apps/ui/dist/server/assets/{cursor-server-nPzojHN3.js → cursor-server-C3q7hrp-.js}

@@ -1,6 +1,11 @@
 import { t as createServerFn } from "../server.js";
-import { t as createServerRpc } from "./createServerRpc-Cg-Zr1rq.js";
+import { t as createServerRpc } from "./createServerRpc-CF_DEwnm.js";
+import { a as sanitizeExportFileName, i as resolveUniqueExportFileBaseName, n as ensureUiExportDir, o as zipExportDirectory, r as getExportMimeType, t as buildUiExportDownloadUrl } from "./ui-export-files-BHLX9bhN.js";
 import { z } from "zod";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
 //#region src/lib/cursor-server.ts?tss-serverfn-split
 var workspaceSchema = z.object({ workspaceKey: z.string().min(1) });
 var threadSchema = z.object({ composerId: z.string().min(1) });
@@ -13,28 +18,58 @@ var exportSchema = z.object({
 	includeCommentary: z.boolean().default(true),
 	includeMetadata: z.boolean().default(true),
 	includeTools: z.boolean().default(true),
-	outputFormat: z.enum(["md", "txt"]).default("md")
+	outputFormat: z.enum(["md", "txt"]).default("md"),
+	zipArchive: z.boolean().default(false)
 });
 var exportThreadsSchema = z.object({
 	composerIds: z.array(z.string().min(1)).min(1),
 	includeCommentary: z.boolean().default(true),
 	includeMetadata: z.boolean().default(true),
 	includeTools: z.boolean().default(true),
-	outputFormat: z.enum(["md", "txt"]).default("md")
+	outputFormat: z.enum(["md", "txt"]).default("md"),
+	zipArchive: z.boolean().default(true)
 });
 var deleteThreadsSchema = z.object({ composerIds: z.array(z.string().min(1)).min(1) });
 var ensureCursorClosedForWrite = async () => {
-	const { isCursorRunning } = await import("./cursor-recovery-9bJLs7vG.js");
+	const { isCursorRunning } = await import("./cursor-recovery-nq-kR62j.js");
 	if (await isCursorRunning()) throw new Error("Quit Cursor before deleting. It rewrites chat history on exit, which can resurrect deleted threads.");
 };
 var findGroupByKey = async (workspaceKey) => {
-	const { listCursorWorkspaceGroups } = await import("./cursor-db-B7agkAvM.js");
+	const { listCursorWorkspaceGroups } = await import("./cursor-db-cYZEU3WQ.js");
 	const group = (await listCursorWorkspaceGroups()).find((candidate) => candidate.key === workspaceKey);
 	if (!group) throw new Error(`Cursor workspace not found: ${workspaceKey}`);
 	return group;
 };
+var toSafeExportName = (value) => {
+	return sanitizeExportFileName(value) || "cursor-thread";
+};
+var renderCursorZipDownload = async (rendered, outputFormat) => {
+	const exportDir = await ensureUiExportDir();
+	const exportBaseName = rendered.length === 1 ? `${toSafeExportName(rendered[0].composerId)}` : `cursor-threads-${rendered.length}`;
+	const workspaceDir = await mkdtemp(path.join(os.tmpdir(), `${exportBaseName}-`));
+	const zipPath = path.join(exportDir, `${exportBaseName}-${randomUUID()}.zip`);
+	const usedBaseNames = /* @__PURE__ */ new Map();
+	try {
+		for (const entry of rendered) {
+			const fileBaseName = resolveUniqueExportFileBaseName(toSafeExportName(entry.composerId), usedBaseNames);
+			await Bun.write(path.join(workspaceDir, `${fileBaseName}.${outputFormat}`), entry.content);
+		}
+		await zipExportDirectory(workspaceDir, zipPath);
+	} finally {
+		await rm(workspaceDir, {
+			force: true,
+			recursive: true
+		});
+	}
+	return {
+		downloadUrl: buildUiExportDownloadUrl(zipPath),
+		fileName: `${exportBaseName}.zip`,
+		mimeType: "application/zip",
+		mode: "download_url"
+	};
+};
 var findCursorThreadByComposerId = async (composerId) => {
-	const { listCursorThreadsForGroup, listCursorWorkspaceGroups } = await import("./cursor-db-B7agkAvM.js");
+	const { listCursorThreadsForGroup, listCursorWorkspaceGroups } = await import("./cursor-db-cYZEU3WQ.js");
 	for (const group of await listCursorWorkspaceGroups()) {
 		const thread = (await listCursorThreadsForGroup(group, void 0, { includeTranscriptDirs: false })).find((candidate) => candidate.composerId === composerId);
 		if (thread) return thread;
@@ -42,11 +77,12 @@ var findCursorThreadByComposerId = async (composerId) => {
 	return null;
 };
 var renderCursorDownload = async (input) => {
-	const { readCursorThreadTranscript } = await import("./cursor-db-B7agkAvM.js");
+	const { readCursorThreadTranscriptWithAgentFiles } = await import("./cursor-db-cYZEU3WQ.js");
 	const { getCursorGlobalDbPath } = await import("./cursor-exporter-types-CI3goo-c.js");
 	const { renderCursorTranscript } = await import("./cursor-transcript-2iL3KFSK.js");
-	const rendered = input.composerIds.map((composerId) => {
-		const transcript = readCursorThreadTranscript(getCursorGlobalDbPath(), composerId);
+	const globalDbPath = getCursorGlobalDbPath();
+	const rendered = await Promise.all(input.composerIds.map(async (composerId) => {
+		const transcript = await readCursorThreadTranscriptWithAgentFiles(globalDbPath, composerId);
 		if (!transcript) throw new Error(`No transcript found for thread: ${composerId}`);
 		const content = renderCursorTranscript(transcript, {
 			includeCommentary: input.includeCommentary,
@@ -59,16 +95,15 @@ var renderCursorDownload = async (input) => {
 			composerId,
 			content
 		};
-	});
+	}));
+	if (input.zipArchive || rendered.length > 1) return renderCursorZipDownload(rendered, input.outputFormat);
 	if (rendered.length === 1) return {
 		content: rendered[0].content,
-		filename: `${rendered[0].composerId}.${input.outputFormat}`
-	};
-	const separator = input.outputFormat === "md" ? "\n\n---\n\n" : "\n\n================================================================\n\n";
-	return {
-		content: rendered.map((entry) => entry.content.trimEnd()).join(separator).concat("\n"),
-		filename: `cursor-threads-${rendered.length}.${input.outputFormat}`
+		fileName: `${toSafeExportName(rendered[0].composerId)}.${input.outputFormat}`,
+		mimeType: getExportMimeType(input.outputFormat),
+		mode: "download"
 	};
+	throw new Error("No Cursor threads selected for export");
 };
 var listCursorWorkspacesFn_createServerFn_handler = createServerRpc({
 	id: "8fcf452a4587a4d4dc0c2f6439255e98123f23d863ca0e861403ae2a687272f2",
@@ -76,7 +111,7 @@ var listCursorWorkspacesFn_createServerFn_handler = createServerRpc({
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => listCursorWorkspacesFn.__executeServer(opts));
 var listCursorWorkspacesFn = createServerFn({ method: "GET" }).handler(listCursorWorkspacesFn_createServerFn_handler, async () => {
-	const { listCursorWorkspaceGroups } = await import("./cursor-db-B7agkAvM.js");
+	const { listCursorWorkspaceGroups } = await import("./cursor-db-cYZEU3WQ.js");
 	return listCursorWorkspaceGroups();
 });
 var listCursorThreadsFn_createServerFn_handler = createServerRpc({
@@ -84,8 +119,8 @@ var listCursorThreadsFn_createServerFn_handler = createServerRpc({
 	name: "listCursorThreadsFn",
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => listCursorThreadsFn.__executeServer(opts));
-var listCursorThreadsFn = createServerFn({ method: "GET" }).inputValidator(workspaceSchema).handler(listCursorThreadsFn_createServerFn_handler, async ({ data }) => {
-	const { listCursorThreadsForGroup } = await import("./cursor-db-B7agkAvM.js");
+var listCursorThreadsFn = createServerFn({ method: "GET" }).validator(workspaceSchema).handler(listCursorThreadsFn_createServerFn_handler, async ({ data }) => {
+	const { listCursorThreadsForGroup } = await import("./cursor-db-cYZEU3WQ.js");
 	return listCursorThreadsForGroup(await findGroupByKey(data.workspaceKey), void 0, { includeTranscriptDirs: false });
 });
 var getCursorThreadDetailFn_createServerFn_handler = createServerRpc({
@@ -93,22 +128,14 @@ var getCursorThreadDetailFn_createServerFn_handler = createServerRpc({
 	name: "getCursorThreadDetailFn",
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => getCursorThreadDetailFn.__executeServer(opts));
-var getCursorThreadDetailFn = createServerFn({ method: "GET" }).inputValidator(threadSchema).handler(getCursorThreadDetailFn_createServerFn_handler, async ({ data }) => {
-	const { readCursorThreadTranscript } = await import("./cursor-db-B7agkAvM.js");
+var getCursorThreadDetailFn = createServerFn({ method: "GET" }).validator(threadSchema).handler(getCursorThreadDetailFn_createServerFn_handler, async ({ data }) => {
+	const { readCursorThreadTranscriptWithAgentFiles } = await import("./cursor-db-cYZEU3WQ.js");
 	const { getCursorGlobalDbPath } = await import("./cursor-exporter-types-CI3goo-c.js");
-	const { renderCursorTranscript } = await import("./cursor-transcript-2iL3KFSK.js");
 	const thread = await findCursorThreadByComposerId(data.composerId);
 	if (!thread) throw new Error(`Cursor thread not found: ${data.composerId}`);
-	const transcript = readCursorThreadTranscript(getCursorGlobalDbPath(), data.composerId);
 	return {
-		renderedTranscript: transcript ? renderCursorTranscript(transcript, {
-			includeCommentary: true,
-			includeMetadata: false,
-			includeTools: true,
-			outputFormat: "md"
-		}) : null,
 		thread,
-		transcript
+		transcript: await readCursorThreadTranscriptWithAgentFiles(getCursorGlobalDbPath(), data.composerId)
 	};
 });
 var exportCursorThreadFn_createServerFn_handler = createServerRpc({
@@ -116,13 +143,14 @@ var exportCursorThreadFn_createServerFn_handler = createServerRpc({
 	name: "exportCursorThreadFn",
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => exportCursorThreadFn.__executeServer(opts));
-var exportCursorThreadFn = createServerFn({ method: "POST" }).inputValidator(exportSchema).handler(exportCursorThreadFn_createServerFn_handler, async ({ data }) => {
+var exportCursorThreadFn = createServerFn({ method: "POST" }).validator(exportSchema).handler(exportCursorThreadFn_createServerFn_handler, async ({ data }) => {
 	return await renderCursorDownload({
 		composerIds: [data.composerId],
 		includeCommentary: data.includeCommentary,
 		includeMetadata: data.includeMetadata,
 		includeTools: data.includeTools,
-		outputFormat: data.outputFormat
+		outputFormat: data.outputFormat,
+		zipArchive: data.zipArchive
 	});
 });
 var exportCursorThreadsFn_createServerFn_handler = createServerRpc({
@@ -130,13 +158,14 @@ var exportCursorThreadsFn_createServerFn_handler = createServerRpc({
 	name: "exportCursorThreadsFn",
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => exportCursorThreadsFn.__executeServer(opts));
-var exportCursorThreadsFn = createServerFn({ method: "POST" }).inputValidator(exportThreadsSchema).handler(exportCursorThreadsFn_createServerFn_handler, async ({ data }) => {
+var exportCursorThreadsFn = createServerFn({ method: "POST" }).validator(exportThreadsSchema).handler(exportCursorThreadsFn_createServerFn_handler, async ({ data }) => {
 	return await renderCursorDownload({
 		composerIds: data.composerIds,
 		includeCommentary: data.includeCommentary,
 		includeMetadata: data.includeMetadata,
 		includeTools: data.includeTools,
-		outputFormat: data.outputFormat
+		outputFormat: data.outputFormat,
+		zipArchive: data.zipArchive
 	});
 });
 var recoverCursorWorkspaceFn_createServerFn_handler = createServerRpc({
@@ -144,8 +173,8 @@ var recoverCursorWorkspaceFn_createServerFn_handler = createServerRpc({
 	name: "recoverCursorWorkspaceFn",
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => recoverCursorWorkspaceFn.__executeServer(opts));
-var recoverCursorWorkspaceFn = createServerFn({ method: "POST" }).inputValidator(recoverSchema).handler(recoverCursorWorkspaceFn_createServerFn_handler, async ({ data }) => {
-	const { isCursorRunning, recoverCursorWorkspaceGroup } = await import("./cursor-recovery-9bJLs7vG.js");
+var recoverCursorWorkspaceFn = createServerFn({ method: "POST" }).validator(recoverSchema).handler(recoverCursorWorkspaceFn_createServerFn_handler, async ({ data }) => {
+	const { isCursorRunning, recoverCursorWorkspaceGroup } = await import("./cursor-recovery-nq-kR62j.js");
 	const group = await findGroupByKey(data.workspaceKey);
 	if (data.apply && await isCursorRunning()) throw new Error("Quit Cursor before recovering. It overwrites chat history on exit, undoing the recovery.");
 	return recoverCursorWorkspaceGroup(group, data.apply);
@@ -155,8 +184,8 @@ var deleteCursorThreadsFn_createServerFn_handler = createServerRpc({
 	name: "deleteCursorThreadsFn",
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => deleteCursorThreadsFn.__executeServer(opts));
-var deleteCursorThreadsFn = createServerFn({ method: "POST" }).inputValidator(deleteThreadsSchema).handler(deleteCursorThreadsFn_createServerFn_handler, async ({ data }) => {
-	const { collectCursorThreadsForDeletion, pruneCursorThreads } = await import("./cursor-recovery-9bJLs7vG.js");
+var deleteCursorThreadsFn = createServerFn({ method: "POST" }).validator(deleteThreadsSchema).handler(deleteCursorThreadsFn_createServerFn_handler, async ({ data }) => {
+	const { collectCursorThreadsForDeletion, pruneCursorThreads } = await import("./cursor-recovery-nq-kR62j.js");
 	await ensureCursorClosedForWrite();
 	return pruneCursorThreads(await collectCursorThreadsForDeletion(data.composerIds), true);
 });
@@ -165,9 +194,9 @@ var deleteCursorWorkspaceFn_createServerFn_handler = createServerRpc({
 	name: "deleteCursorWorkspaceFn",
 	filename: "src/lib/cursor-server.ts"
 }, (opts) => deleteCursorWorkspaceFn.__executeServer(opts));
-var deleteCursorWorkspaceFn = createServerFn({ method: "POST" }).inputValidator(workspaceSchema).handler(deleteCursorWorkspaceFn_createServerFn_handler, async ({ data }) => {
-	const { listCursorThreadsForGroup } = await import("./cursor-db-B7agkAvM.js");
-	const { collectCursorThreadsForDeletion, pruneCursorThreads } = await import("./cursor-recovery-9bJLs7vG.js");
+var deleteCursorWorkspaceFn = createServerFn({ method: "POST" }).validator(workspaceSchema).handler(deleteCursorWorkspaceFn_createServerFn_handler, async ({ data }) => {
+	const { listCursorThreadsForGroup } = await import("./cursor-db-cYZEU3WQ.js");
+	const { collectCursorThreadsForDeletion, pruneCursorThreads } = await import("./cursor-recovery-nq-kR62j.js");
 	await ensureCursorClosedForWrite();
 	const composerIds = (await listCursorThreadsForGroup(await findGroupByKey(data.workspaceKey), void 0, { includeTranscriptDirs: false })).map((thread) => thread.composerId);
 	if (composerIds.length === 0) return {

package/apps/ui/dist/server/assets/{cursor-threads._composerId-B3qcsh9C.js → cursor-threads._composerId-BPJFWfJj.js}

@@ -1,10 +1,10 @@
-import { t as cursorThreadDetailQueryOptions } from "./cursor-queries-f7DjBKSD.js";
+import { t as cursorThreadDetailQueryOptions } from "./cursor-queries-NCIM0Nat.js";
 import { t as LoadingPanel } from "./loading-panel-BGFnWseS.js";
 import { createFileRoute, lazyRouteComponent } from "@tanstack/react-router";
 import { jsx } from "react/jsx-runtime";
 //#region src/routes/cursor-threads.$composerId.tsx
 var $$splitErrorComponentImporter = () => import("./cursor-threads._composerId-BB0Y_Mao.js");
-var $$splitComponentImporter = () => import("./cursor-threads._composerId-BK3iW-3e.js");
+var $$splitComponentImporter = () => import("./cursor-threads._composerId-BkMMTQ3v.js");
 var Route = createFileRoute("/cursor-threads/$composerId")({
 	component: lazyRouteComponent($$splitComponentImporter, "component"),
 	errorComponent: lazyRouteComponent($$splitErrorComponentImporter, "errorComponent"),