spiracha 1.2.0 → 1.3.0

package/apps/ui/dist/server/assets/cursor-queries-BMhuJeUO.js

@@ -0,0 +1,65 @@
+import { t as createServerFn } from "../server.js";
+import { t as isRetryableSqliteError } from "./sqlite-error-LZDrnxdd.js";
+import { t as createSsrRpc } from "./createSsrRpc-COf5Zuye.js";
+import { queryOptions } from "@tanstack/react-query";
+import { z } from "zod";
+//#region src/lib/cursor-server.ts
+var workspaceSchema = z.object({ workspaceKey: z.string().min(1) });
+var threadSchema = z.object({ composerId: z.string().min(1) });
+var recoverSchema = z.object({
+	apply: z.boolean().default(false),
+	workspaceKey: z.string().min(1)
+});
+var exportSchema = z.object({
+	composerId: z.string().min(1),
+	includeCommentary: z.boolean().default(true),
+	includeMetadata: z.boolean().default(true),
+	includeTools: z.boolean().default(true),
+	outputFormat: z.enum(["md", "txt"]).default("md")
+});
+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")
+});
+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"));
+//#endregion
+//#region src/lib/cursor-queries.ts
+var retrySqliteQuery = (failureCount, error) => {
+	return failureCount < 3 && isRetryableSqliteError(error);
+};
+var retryDelay = (attemptIndex) => {
+	return [150, 400][attemptIndex] ?? 800;
+};
+var cursorWorkspacesQueryOptions = () => queryOptions({
+	queryFn: () => listCursorWorkspacesFn(),
+	queryKey: ["cursor-workspaces"],
+	retry: retrySqliteQuery,
+	retryDelay
+});
+var cursorThreadsQueryOptions = (workspaceKey) => queryOptions({
+	enabled: workspaceKey !== null,
+	queryFn: () => listCursorThreadsFn({ data: { workspaceKey: workspaceKey ?? "" } }),
+	queryKey: ["cursor-threads", workspaceKey ?? "none"],
+	retry: retrySqliteQuery,
+	retryDelay
+});
+var cursorThreadDetailQueryOptions = (composerId) => queryOptions({
+	enabled: composerId !== null,
+	queryFn: () => getCursorThreadDetailFn({ data: { composerId: composerId ?? "" } }),
+	queryKey: ["cursor-thread", composerId ?? "none"],
+	retry: retrySqliteQuery,
+	retryDelay
+});
+//#endregion
+export { deleteCursorWorkspaceFn as a, recoverCursorWorkspaceFn as c, deleteCursorThreadsFn as i, cursorThreadsQueryOptions as n, exportCursorThreadFn as o, cursorWorkspacesQueryOptions as r, exportCursorThreadsFn as s, cursorThreadDetailQueryOptions as t };

package/apps/ui/dist/server/assets/cursor-recovery-9bJLs7vG.js

@@ -0,0 +1,361 @@
+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 { Database } from "bun:sqlite";
+import { rm } from "node:fs/promises";
+//#region ../../src/lib/cursor-recovery.ts
+var isCursorRunning = async () => {
+	return await Bun.spawn([
+		"pgrep",
+		"-x",
+		"Cursor"
+	], {
+		stderr: "ignore",
+		stdout: "ignore"
+	}).exited === 0;
+};
+var backupStamp = () => (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/gu, "").replace(/\..+/u, "").replace("T", "-");
+var backupComposerHeaders = async (globalDbPath) => {
+	const db = openCursorReadonlyDb(globalDbPath);
+	let headers;
+	try {
+		headers = readJsonItem(db, "composer.composerHeaders") ?? { allComposers: [] };
+	} finally {
+		db.close();
+	}
+	const backupPath = `${globalDbPath}.composerHeaders.${backupStamp()}.json`;
+	await Bun.write(backupPath, JSON.stringify(headers));
+	return backupPath;
+};
+var backupPrunedThreads = async (globalDbPath, composerIds) => {
+	const db = openCursorReadonlyDb(globalDbPath);
+	try {
+		const dump = composerIds.map((composerId) => ({
+			bubbles: db.query("SELECT key, value FROM cursorDiskKV WHERE key LIKE ?").all(`bubbleId:${composerId}:%`),
+			composerData: readJsonItemFromKv(db, `composerData:${composerId}`),
+			composerId
+		}));
+		const backupPath = `${globalDbPath}.prunedThreads.${backupStamp()}.json`;
+		await Bun.write(backupPath, JSON.stringify(dump));
+		return backupPath;
+	} finally {
+		db.close();
+	}
+};
+var readJsonItemFromKv = (db, key) => {
+	const row = db.query("SELECT value FROM cursorDiskKV WHERE key = ?").get(key);
+	if (!row?.value) return null;
+	try {
+		return JSON.parse(row.value);
+	} catch {
+		return null;
+	}
+};
+var readJsonItem = (db, key) => {
+	const row = db.query("SELECT value FROM ItemTable WHERE key = ?").get(key);
+	if (!row?.value) return null;
+	try {
+		return JSON.parse(row.value);
+	} catch {
+		return null;
+	}
+};
+var writeJsonItem = (db, key, value) => {
+	db.run(`INSERT INTO ItemTable (key, value) VALUES (?, ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value`, [key, JSON.stringify(value)]);
+};
+var scoreComposer = (entry) => Number(Boolean(entry.name)) + Number(entry.lastUpdatedAt ?? 0) + Number(entry.totalLinesAdded ?? 0);
+var mergeComposerEntries = (entries) => {
+	const byId = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const id = entry.composerId;
+		if (!id) continue;
+		const current = byId.get(id);
+		if (!current || scoreComposer(entry) >= scoreComposer(current)) byId.set(id, entry);
+	}
+	return [...byId.values()].sort((a, b) => Number(b.lastUpdatedAt ?? b.createdAt ?? 0) - Number(a.lastUpdatedAt ?? a.createdAt ?? 0));
+};
+var buildWorkspaceIdentifier = (bucket) => {
+	if (bucket.kind === "folder" && bucket.folders[0]) {
+		const folder = bucket.folders[0];
+		return {
+			id: bucket.bucketId,
+			uri: {
+				$mid: 1,
+				external: `file://${folder}`,
+				fsPath: folder,
+				path: folder,
+				scheme: "file"
+			}
+		};
+	}
+	return { id: bucket.bucketId };
+};
+var composersForBucket = (bucket, headers) => {
+	let fromBucket = [];
+	try {
+		const db = openCursorReadonlyDb(bucket.dbPath);
+		try {
+			fromBucket = readJsonItem(db, "composer.composerData")?.allComposers ?? [];
+		} finally {
+			db.close();
+		}
+	} catch {
+		fromBucket = [];
+	}
+	const linked = headers.filter((header) => header.workspaceIdentifier?.id === bucket.bucketId);
+	return mergeComposerEntries([...fromBucket, ...linked]);
+};
+var chooseTargetBucket = (group) => {
+	const [target, ...sources] = [...group.buckets].sort((a, b) => b.mtimeMs - a.mtimeMs || b.dbSizeBytes - a.dbSizeBytes);
+	return {
+		sources,
+		target
+	};
+};
+var relinkHeaders = (db, composers, sourceBucketIds, target) => {
+	const headers = (readJsonItem(db, "composer.composerHeaders") ?? { allComposers: [] }).allComposers ?? [];
+	const byId = new Map(headers.filter((header) => header.composerId).map((header) => [header.composerId, header]));
+	const workspaceIdentifier = buildWorkspaceIdentifier(target);
+	let relinked = 0;
+	let added = 0;
+	for (const composer of composers) {
+		const id = composer.composerId;
+		if (!id) continue;
+		const existing = byId.get(id);
+		if (existing) {
+			const currentId = existing.workspaceIdentifier?.id;
+			if (currentId !== target.bucketId && (currentId === void 0 || sourceBucketIds.has(currentId))) {
+				existing.workspaceIdentifier = workspaceIdentifier;
+				relinked += 1;
+			}
+			continue;
+		}
+		headers.push({
+			...composer,
+			type: composer.type ?? "head",
+			workspaceIdentifier
+		});
+		byId.set(id, headers[headers.length - 1]);
+		added += 1;
+	}
+	if (relinked > 0 || added > 0) {
+		headers.sort((a, b) => Number(b.lastUpdatedAt ?? b.createdAt ?? 0) - Number(a.lastUpdatedAt ?? a.createdAt ?? 0));
+		writeJsonItem(db, COMPOSER_HEADERS_KEY, { allComposers: headers });
+	}
+	return {
+		added,
+		relinked
+	};
+};
+var countBubbles = (db, composerId) => {
+	return db.query("SELECT COUNT(*) AS count FROM cursorDiskKV WHERE key LIKE ?").get(`bubbleId:${composerId}:%`).count;
+};
+var recoverCursorWorkspaceGroup = async (group, apply, userDir = resolveCursorUserDir()) => {
+	if (group.buckets.length === 0) throw new Error(`"${group.label}" has no on-disk Cursor storage bucket to recover into. Its threads can still be exported or deleted.`);
+	const globalDbPath = getCursorGlobalDbPath(userDir);
+	const headers = loadGlobalComposerHeaders(globalDbPath);
+	const { target, sources } = chooseTargetBucket(group);
+	const sourceBucketIds = new Set(sources.map((bucket) => bucket.bucketId));
+	const merged = mergeComposerEntries([...composersForBucket(target, headers), ...sources.flatMap((bucket) => composersForBucket(bucket, headers))]);
+	if (!apply) return buildRecoverResult(group, target, merged, globalDbPath, 0, merged.length);
+	const currentBucketData = readTargetBucketComposerData(target);
+	await backupComposerHeaders(globalDbPath);
+	await backupTargetBucketComposerData(target, currentBucketData);
+	const db = new Database(globalDbPath);
+	let committed = false;
+	let relinked = 0;
+	let added = 0;
+	try {
+		db.exec("BEGIN IMMEDIATE");
+		writeTargetBucketComposerData(target, buildTargetBucketComposerData(currentBucketData.data, merged));
+		({relinked, added} = relinkHeaders(db, merged, sourceBucketIds, target));
+		db.exec("COMMIT");
+		committed = true;
+	} catch (error) {
+		if (!committed) {
+			try {
+				db.exec("ROLLBACK");
+			} catch {}
+			try {
+				writeTargetBucketComposerData(target, currentBucketData);
+			} catch {}
+		}
+		throw error;
+	} finally {
+		db.close();
+		invalidateCursorDiscoveryCache();
+	}
+	return buildRecoverResult(group, target, merged, globalDbPath, relinked, added);
+};
+var readTargetBucketComposerData = (target) => {
+	const db = openCursorReadonlyDb(target.dbPath);
+	try {
+		const data = readJsonItem(db, COMPOSER_DATA_KEY);
+		return {
+			data: data ?? {},
+			exists: data !== null
+		};
+	} finally {
+		db.close();
+	}
+};
+var backupTargetBucketComposerData = async (target, snapshot) => {
+	const backupPath = `${target.dbPath}.composerData.${backupStamp()}.json`;
+	await Bun.write(backupPath, JSON.stringify(snapshot));
+	return backupPath;
+};
+var buildTargetBucketComposerData = (existing, merged) => {
+	const selectedIds = merged.map((entry) => entry.composerId).filter((value) => Boolean(value));
+	return {
+		...existing,
+		allComposers: merged,
+		hasMigratedComposerData: true,
+		hasMigratedMultipleComposers: true,
+		lastFocusedComposerIds: selectedIds.slice(0, 1),
+		selectedComposerIds: selectedIds.slice(0, 5)
+	};
+};
+var writeTargetBucketComposerData = (target, snapshot) => {
+	const db = new Database(target.dbPath);
+	try {
+		if ("exists" in snapshot && !snapshot.exists) {
+			db.run("DELETE FROM ItemTable WHERE key = ?", [COMPOSER_DATA_KEY]);
+			return;
+		}
+		writeJsonItem(db, COMPOSER_DATA_KEY, "exists" in snapshot ? snapshot.data : snapshot);
+	} finally {
+		db.close();
+	}
+};
+var buildRecoverResult = (group, target, merged, globalDbPath, relinked, added) => {
+	const db = openCursorReadonlyDb(globalDbPath);
+	try {
+		return {
+			activeBucketId: target.bucketId,
+			addedHeaderCount: added,
+			mergedThreadCount: merged.length,
+			relinkedHeaderCount: relinked,
+			threads: merged.filter((entry) => entry.composerId).map((entry) => ({
+				bubbleCount: countBubbles(db, entry.composerId),
+				composerId: entry.composerId,
+				name: typeof entry.name === "string" && entry.name ? entry.name : "(untitled)"
+			})),
+			workspaceKey: group.key
+		};
+	} finally {
+		db.close();
+	}
+};
+var removeThreadFromBucket = (db, composerIds) => {
+	const data = readJsonItem(db, COMPOSER_DATA_KEY);
+	if (!data?.allComposers?.length) return false;
+	const before = data.allComposers.length;
+	data.allComposers = data.allComposers.filter((entry) => !composerIds.has(entry.composerId ?? ""));
+	if (data.allComposers.length === before) return false;
+	data.selectedComposerIds = (data.selectedComposerIds ?? []).filter((id) => !composerIds.has(id));
+	data.lastFocusedComposerIds = (data.lastFocusedComposerIds ?? []).filter((id) => !composerIds.has(id));
+	writeJsonItem(db, COMPOSER_DATA_KEY, data);
+	return true;
+};
+var pruneGlobalThread = (db, composerId) => {
+	const bubbleResult = db.run("DELETE FROM cursorDiskKV WHERE key LIKE ?", [`bubbleId:${composerId}:%`]);
+	const headResult = db.run("DELETE FROM cursorDiskKV WHERE key = ?", [`composerData:${composerId}`]);
+	return {
+		bubbles: bubbleResult.changes ?? 0,
+		composerData: headResult.changes ?? 0
+	};
+};
+var removeThreadHeaders = (db, composerIds) => {
+	const data = readJsonItem(db, COMPOSER_HEADERS_KEY);
+	if (!data?.allComposers?.length) return 0;
+	const before = data.allComposers.length;
+	data.allComposers = data.allComposers.filter((entry) => !composerIds.has(entry.composerId ?? ""));
+	const removed = before - data.allComposers.length;
+	if (removed > 0) writeJsonItem(db, COMPOSER_HEADERS_KEY, data);
+	return removed;
+};
+var pruneCursorThreads = async (threads, apply, userDir = resolveCursorUserDir()) => {
+	const composerIds = new Set(threads.map((thread) => thread.composerId));
+	const globalDbPath = getCursorGlobalDbPath(userDir);
+	const result = {
+		bubblesDeleted: 0,
+		composerDataDeleted: 0,
+		composerIds: [...composerIds],
+		headersRemoved: 0,
+		transcriptDirsRemoved: 0,
+		workspaceBucketsUpdated: 0
+	};
+	if (composerIds.size === 0) return result;
+	if (!apply) {
+		result.bubblesDeleted = threads.reduce((sum, thread) => sum + thread.bubbleCount, 0);
+		result.composerDataDeleted = threads.length;
+		result.headersRemoved = threads.length;
+		result.transcriptDirsRemoved = threads.reduce((sum, thread) => sum + thread.transcriptDirs.length, 0);
+		return result;
+	}
+	await backupPrunedThreads(globalDbPath, [...composerIds]);
+	await pruneGlobalThreads(globalDbPath, threads, composerIds, result);
+	await pruneWorkspaceBuckets(threads, composerIds, result, userDir);
+	await pruneTranscriptDirs(threads, result);
+	invalidateCursorDiscoveryCache();
+	return result;
+};
+var pruneGlobalThreads = async (globalDbPath, threads, composerIds, result) => {
+	const db = new Database(globalDbPath);
+	try {
+		for (const thread of threads) {
+			const deleted = pruneGlobalThread(db, thread.composerId);
+			result.bubblesDeleted += deleted.bubbles;
+			result.composerDataDeleted += deleted.composerData;
+		}
+		result.headersRemoved = removeThreadHeaders(db, composerIds);
+	} finally {
+		db.close();
+	}
+};
+var pruneWorkspaceBuckets = async (_threads, composerIds, result, userDir) => {
+	const groups = await listCursorWorkspaceGroups(userDir);
+	const dbPaths = /* @__PURE__ */ new Set();
+	for (const group of groups) for (const bucket of group.buckets) dbPaths.add(bucket.dbPath);
+	for (const dbPath of dbPaths) {
+		const db = new Database(dbPath);
+		try {
+			if (removeThreadFromBucket(db, composerIds)) result.workspaceBucketsUpdated += 1;
+		} finally {
+			db.close();
+		}
+	}
+};
+var pruneTranscriptDirs = async (threads, result) => {
+	for (const thread of threads) for (const dir of thread.transcriptDirs) {
+		await rm(dir, {
+			force: true,
+			recursive: true
+		});
+		result.transcriptDirsRemoved += 1;
+	}
+};
+var collectCursorThreadsForDeletion = async (composerIds, userDir = resolveCursorUserDir()) => {
+	const db = openCursorReadonlyDb(getCursorGlobalDbPath(userDir));
+	const summaries = [];
+	try {
+		for (const composerId of composerIds) summaries.push({
+			bubbleBytes: 0,
+			bubbleCount: countBubbles(db, composerId),
+			bucketId: null,
+			composerId,
+			createdAtMs: null,
+			lastUpdatedAtMs: null,
+			mode: null,
+			name: "",
+			transcriptDirs: await findCursorTranscriptDirs(composerId, userDir),
+			workspaceKey: "",
+			workspaceLabel: ""
+		});
+	} finally {
+		db.close();
+	}
+	return summaries;
+};
+//#endregion
+export { collectCursorThreadsForDeletion, isCursorRunning, pruneCursorThreads, recoverCursorWorkspaceGroup };

package/apps/ui/dist/server/assets/cursor-server-BgylIFgn.js

@@ -0,0 +1,184 @@
+import { t as createServerFn } from "../server.js";
+import { t as createServerRpc } from "./createServerRpc-BtXIw2iP.js";
+import { z } from "zod";
+//#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) });
+var recoverSchema = z.object({
+	apply: z.boolean().default(false),
+	workspaceKey: z.string().min(1)
+});
+var exportSchema = z.object({
+	composerId: z.string().min(1),
+	includeCommentary: z.boolean().default(true),
+	includeMetadata: z.boolean().default(true),
+	includeTools: z.boolean().default(true),
+	outputFormat: z.enum(["md", "txt"]).default("md")
+});
+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")
+});
+var deleteThreadsSchema = z.object({ composerIds: z.array(z.string().min(1)).min(1) });
+var ensureCursorClosedForWrite = async () => {
+	const { isCursorRunning } = await import("./cursor-recovery-9bJLs7vG.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 group = (await listCursorWorkspaceGroups()).find((candidate) => candidate.key === workspaceKey);
+	if (!group) throw new Error(`Cursor workspace not found: ${workspaceKey}`);
+	return group;
+};
+var findCursorThreadByComposerId = async (composerId) => {
+	const { listCursorThreadsForGroup, listCursorWorkspaceGroups } = await import("./cursor-db-B7agkAvM.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;
+	}
+	return null;
+};
+var renderCursorDownload = async (input) => {
+	const { readCursorThreadTranscript } = await import("./cursor-db-B7agkAvM.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);
+		if (!transcript) throw new Error(`No transcript found for thread: ${composerId}`);
+		const content = renderCursorTranscript(transcript, {
+			includeCommentary: input.includeCommentary,
+			includeMetadata: input.includeMetadata,
+			includeTools: input.includeTools,
+			outputFormat: input.outputFormat
+		});
+		if (!content) throw new Error(`Thread has no exportable content: ${composerId}`);
+		return {
+			composerId,
+			content
+		};
+	});
+	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}`
+	};
+};
+var listCursorWorkspacesFn_createServerFn_handler = createServerRpc({
+	id: "8fcf452a4587a4d4dc0c2f6439255e98123f23d863ca0e861403ae2a687272f2",
+	name: "listCursorWorkspacesFn",
+	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");
+	return listCursorWorkspaceGroups();
+});
+var listCursorThreadsFn_createServerFn_handler = createServerRpc({
+	id: "23fb197bac88fb9e4950ef7608cd311d67c0867e424136c8373071dc54746806",
+	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");
+	return listCursorThreadsForGroup(await findGroupByKey(data.workspaceKey), void 0, { includeTranscriptDirs: false });
+});
+var getCursorThreadDetailFn_createServerFn_handler = createServerRpc({
+	id: "6e893e740c05aad65a8eb32901b4c39277ebf718f0ba14b04d8df989bed2f32b",
+	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");
+	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
+	};
+});
+var exportCursorThreadFn_createServerFn_handler = createServerRpc({
+	id: "03050b86e5481024283bee890347a9da7b2493493044dcde6df989b3334d6b73",
+	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 }) => {
+	return await renderCursorDownload({
+		composerIds: [data.composerId],
+		includeCommentary: data.includeCommentary,
+		includeMetadata: data.includeMetadata,
+		includeTools: data.includeTools,
+		outputFormat: data.outputFormat
+	});
+});
+var exportCursorThreadsFn_createServerFn_handler = createServerRpc({
+	id: "e9609d5ab12ea0bc4dbd3289fad95417dd01a0a719c8ee588c0b8c8a9dc80c99",
+	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 }) => {
+	return await renderCursorDownload({
+		composerIds: data.composerIds,
+		includeCommentary: data.includeCommentary,
+		includeMetadata: data.includeMetadata,
+		includeTools: data.includeTools,
+		outputFormat: data.outputFormat
+	});
+});
+var recoverCursorWorkspaceFn_createServerFn_handler = createServerRpc({
+	id: "a9bd5d510f2d1173d2ef610dda4d59a795af17e7c2a4affaba7e1f99822b2c40",
+	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");
+	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);
+});
+var deleteCursorThreadsFn_createServerFn_handler = createServerRpc({
+	id: "17afb84da4a3d5022132756ead0adaf0323660f50fc58d7f14830b01fdd59a13",
+	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");
+	await ensureCursorClosedForWrite();
+	return pruneCursorThreads(await collectCursorThreadsForDeletion(data.composerIds), true);
+});
+var deleteCursorWorkspaceFn_createServerFn_handler = createServerRpc({
+	id: "fc72eb7835fc18130f6d7c20e15e560320521cd01c93e08667b340bfe6b90930",
+	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");
+	await ensureCursorClosedForWrite();
+	const composerIds = (await listCursorThreadsForGroup(await findGroupByKey(data.workspaceKey), void 0, { includeTranscriptDirs: false })).map((thread) => thread.composerId);
+	if (composerIds.length === 0) return {
+		bubblesDeleted: 0,
+		composerDataDeleted: 0,
+		composerIds: [],
+		headersRemoved: 0,
+		transcriptDirsRemoved: 0,
+		workspaceBucketsUpdated: 0
+	};
+	return pruneCursorThreads(await collectCursorThreadsForDeletion(composerIds), true);
+});
+//#endregion
+export { deleteCursorThreadsFn_createServerFn_handler, deleteCursorWorkspaceFn_createServerFn_handler, exportCursorThreadFn_createServerFn_handler, exportCursorThreadsFn_createServerFn_handler, getCursorThreadDetailFn_createServerFn_handler, listCursorThreadsFn_createServerFn_handler, listCursorWorkspacesFn_createServerFn_handler, recoverCursorWorkspaceFn_createServerFn_handler };

package/apps/ui/dist/server/assets/cursor-threads._composerId-BB0Y_Mao.js

@@ -0,0 +1,11 @@
+import { t as ReloadErrorPanel } from "./reload-error-panel-BJMxY3U1.js";
+import { jsx } from "react/jsx-runtime";
+//#region src/routes/cursor-threads.$composerId.tsx?tsr-split=errorComponent
+var CursorThreadDetailErrorComponent = ({ error }) => {
+	return /* @__PURE__ */ jsx(ReloadErrorPanel, {
+		description: error.message,
+		title: "Failed to load Cursor thread"
+	});
+};
+//#endregion
+export { CursorThreadDetailErrorComponent as errorComponent };