spiracha 1.2.0 → 1.3.0

package/apps/ui/dist/server/assets/cursor-db-B7agkAvM.js

@@ -0,0 +1,643 @@
+import { n as asObject, r as asString, t as asNumber } from "./shared-CPRNYIql.js";
+import { getCursorGlobalDbPath, getCursorProjectsDir, getCursorWorkspaceStorageDir, resolveCursorUserDir } from "./cursor-exporter-types-CI3goo-c.js";
+import { Database, constants } from "bun:sqlite";
+import { readdir, stat } from "node:fs/promises";
+import path from "node:path";
+//#region ../../src/lib/cursor-db.ts
+var CURSOR_READONLY_DB_OPEN_FLAGS = constants.SQLITE_OPEN_READONLY | constants.SQLITE_OPEN_URI;
+var getCursorReadonlyDbUri = (dbPath) => {
+	const normalizedPath = dbPath.replace(/\\/gu, "/");
+	return `file://${(normalizedPath.startsWith("/") ? normalizedPath : `/${normalizedPath}`).split("/").map((segment) => /^[A-Za-z]:$/u.test(segment) ? segment : encodeURIComponent(segment)).join("/")}?immutable=1`;
+};
+var openCursorReadonlyDb = (dbPath) => {
+	return new Database(getCursorReadonlyDbUri(dbPath), CURSOR_READONLY_DB_OPEN_FLAGS);
+};
+var pathExists = async (target) => {
+	try {
+		await stat(target);
+		return true;
+	} catch {
+		return false;
+	}
+};
+var isMissingOrUnreadableCursorStoreError = (error) => {
+	const code = error.code;
+	return code === "ENOENT" || code === "ENOTDIR" || code === "SQLITE_CANTOPEN";
+};
+var readItemValue = (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 readKvValue = (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 decodeCursorUri = (uri) => {
+	if (!uri) return "";
+	if (uri.startsWith("file://")) return decodeURIComponent(uri.slice(7));
+	return uri;
+};
+var normalizeCursorPath = (value) => {
+	const decoded = decodeCursorUri(value.trim());
+	if (!decoded) return "";
+	return decoded.replace(/\/+$/u, "") || decoded;
+};
+var parseCodeWorkspaceFolders = async (workspaceFilePath) => {
+	if (!workspaceFilePath.endsWith(".code-workspace")) return [];
+	try {
+		const data = await Bun.file(workspaceFilePath).json();
+		const folders = [];
+		for (const entry of data.folders ?? []) {
+			const folderPath = entry.path;
+			if (!folderPath) continue;
+			folders.push(folderPath.startsWith("/") ? normalizeCursorPath(folderPath) : normalizeCursorPath(path.join(path.dirname(workspaceFilePath), folderPath)));
+		}
+		return folders;
+	} catch {
+		return [];
+	}
+};
+var loadGlobalComposerHeaders = (globalDbPath) => {
+	const db = openCursorReadonlyDb(globalDbPath);
+	try {
+		return readItemValue(db, "composer.composerHeaders")?.allComposers ?? [];
+	} finally {
+		db.close();
+	}
+};
+var readBucketWorkspaceJson = async (workspaceJsonPath) => {
+	try {
+		return await Bun.file(workspaceJsonPath).json();
+	} catch {
+		return null;
+	}
+};
+var resolveBucketIdentity = async (wsData, bucketId) => {
+	if (wsData.folder) {
+		const folder = normalizeCursorPath(wsData.folder);
+		return {
+			folders: folder ? [folder] : [],
+			kind: "folder",
+			label: folder ? path.basename(folder) : bucketId,
+			uri: wsData.folder
+		};
+	}
+	if (wsData.workspace) {
+		const workspacePath = normalizeCursorPath(wsData.workspace);
+		return {
+			folders: workspacePath ? await parseCodeWorkspaceFolders(workspacePath) : [],
+			kind: "workspace",
+			label: workspacePath ? path.basename(workspacePath) : bucketId,
+			uri: wsData.workspace
+		};
+	}
+	return {
+		folders: [],
+		kind: "unknown",
+		label: bucketId,
+		uri: ""
+	};
+};
+var readBucketComposerIds = (dbPath) => {
+	try {
+		const db = openCursorReadonlyDb(dbPath);
+		try {
+			return (readItemValue(db, "composer.composerData")?.allComposers ?? []).map((entry) => entry.composerId).filter((value) => Boolean(value));
+		} finally {
+			db.close();
+		}
+	} catch {
+		return [];
+	}
+};
+var loadCursorBuckets = async (userDir = resolveCursorUserDir()) => {
+	const workspaceStorageDir = getCursorWorkspaceStorageDir(userDir);
+	let bucketIds = [];
+	try {
+		bucketIds = await readdir(workspaceStorageDir);
+	} catch {
+		return [];
+	}
+	const globalDbPath = getCursorGlobalDbPath(userDir);
+	const headerIdsByBucket = /* @__PURE__ */ new Map();
+	if (await pathExists(globalDbPath)) for (const header of loadGlobalComposerHeaders(globalDbPath)) {
+		const id = header.workspaceIdentifier?.id;
+		if (id && header.composerId) {
+			const set = headerIdsByBucket.get(id) ?? /* @__PURE__ */ new Set();
+			set.add(header.composerId);
+			headerIdsByBucket.set(id, set);
+		}
+	}
+	const buckets = [];
+	for (const bucketId of bucketIds) {
+		const bucket = await buildBucket(workspaceStorageDir, bucketId, headerIdsByBucket);
+		if (bucket) buckets.push(bucket);
+	}
+	return buckets;
+};
+var buildBucket = async (workspaceStorageDir, bucketId, headerIdsByBucket) => {
+	const root = path.join(workspaceStorageDir, bucketId);
+	const workspaceJsonPath = path.join(root, "workspace.json");
+	const dbPath = path.join(root, "state.vscdb");
+	if (!await pathExists(workspaceJsonPath) || !await pathExists(dbPath)) return null;
+	const wsData = await readBucketWorkspaceJson(workspaceJsonPath);
+	if (!wsData || !wsData.folder && !wsData.workspace) return null;
+	let identity;
+	let dbStat;
+	let composerIds;
+	try {
+		identity = await resolveBucketIdentity(wsData, bucketId);
+		dbStat = await stat(dbPath);
+		composerIds = readBucketComposerIds(dbPath);
+	} catch (error) {
+		if (isMissingOrUnreadableCursorStoreError(error)) return null;
+		throw error;
+	}
+	const headerIds = headerIdsByBucket.get(bucketId) ?? /* @__PURE__ */ new Set();
+	const threadComposerIds = [...new Set([...composerIds, ...headerIds])];
+	return {
+		bucketId,
+		composerCount: composerIds.length,
+		dbPath,
+		dbSizeBytes: dbStat.size,
+		folders: identity.folders,
+		globalHeaderCount: headerIds.size,
+		kind: identity.kind,
+		label: identity.label,
+		mtimeMs: dbStat.mtimeMs,
+		threadComposerIds,
+		uri: identity.uri,
+		workspaceJsonPath
+	};
+};
+var getCursorWorkspaceGroupKey = (bucket) => {
+	if (bucket.kind === "folder" && bucket.folders[0]) return `folder:${bucket.folders[0]}`;
+	if (bucket.kind === "workspace") return `workspace:${normalizeCursorPath(bucket.uri)}`;
+	return `unknown:${bucket.bucketId}`;
+};
+var groupCursorBuckets = (buckets) => {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const bucket of buckets) {
+		const key = getCursorWorkspaceGroupKey(bucket);
+		const list = grouped.get(key) ?? [];
+		list.push(bucket);
+		grouped.set(key, list);
+	}
+	const groups = [];
+	for (const [key, list] of grouped.entries()) {
+		const ranked = [...list].sort((a, b) => b.mtimeMs - a.mtimeMs || b.dbSizeBytes - a.dbSizeBytes);
+		const primary = ranked[0];
+		const newest = ranked[0];
+		const threadCount = new Set(ranked.flatMap((bucket) => bucket.threadComposerIds)).size;
+		const olderWithData = ranked.slice(1).some((bucket) => bucket.composerCount > 0 || bucket.globalHeaderCount > 0);
+		groups.push({
+			buckets: ranked,
+			folders: primary.folders,
+			key,
+			kind: primary.kind,
+			label: primary.label,
+			lastActiveMs: Math.max(...ranked.map((bucket) => bucket.mtimeMs)),
+			needsRecovery: ranked.length > 1 && olderWithData && newest.composerCount === 0,
+			threadCount,
+			uri: primary.uri
+		});
+	}
+	return groups.sort((a, b) => b.lastActiveMs - a.lastActiveMs);
+};
+var listCursorWorkspaceGroups = async (userDir = resolveCursorUserDir()) => {
+	return (await discoverCursorWorkspaces(userDir)).groups;
+};
+var countBubbles = (db, composerId) => {
+	const row = db.query("SELECT COUNT(*) AS count, COALESCE(SUM(length(value)), 0) AS bytes FROM cursorDiskKV WHERE key LIKE ?").get(`bubbleId:${composerId}:%`);
+	return {
+		bytes: row.bytes,
+		count: row.count
+	};
+};
+var findCursorTranscriptDirs = async (composerId, userDir = resolveCursorUserDir()) => {
+	const projectsDir = getCursorProjectsDir(userDir);
+	if (!await pathExists(projectsDir)) return [];
+	const matches = [];
+	let projectDirs = [];
+	try {
+		projectDirs = await readdir(projectsDir);
+	} catch {
+		return [];
+	}
+	for (const projectDir of projectDirs) {
+		const transcriptDir = path.join(projectsDir, projectDir, "agent-transcripts", composerId);
+		if (await pathExists(transcriptDir)) matches.push(transcriptDir);
+	}
+	return matches;
+};
+var listCursorThreadsForGroup = async (group, userDir = resolveCursorUserDir(), options = {}) => {
+	const threads = (await discoverCursorWorkspaces(userDir)).threadsByKey.get(group.key) ?? [];
+	if (options.includeTranscriptDirs === false) return threads;
+	return Promise.all(threads.map(async (thread) => ({
+		...thread,
+		transcriptDirs: await findCursorTranscriptDirs(thread.composerId, userDir)
+	})));
+};
+var DISCOVERY_TTL_MS = 6e4;
+var UNKNOWN_GROUP_KEY = "unknown";
+var discoveryCache = null;
+var invalidateCursorDiscoveryCache = () => {
+	discoveryCache = null;
+};
+var DEV_CONTAINER_DIRS = [
+	"workspace",
+	"projects",
+	"dev",
+	"code",
+	"repos",
+	"src",
+	"Documents",
+	"Downloads",
+	"Desktop"
+];
+var REVERSE_WORKSPACE_ROOT_RE = /^\/Users\/[^/]+\/workspace\/reverse\/[^/]+/u;
+var CONTAINER_ROOT_RE = new RegExp(`^(/Users/[^/]+/(?:${DEV_CONTAINER_DIRS.join("|")})/[^/]+)`);
+var ABS_PATH_RE = /\/Users\/[^"'\s:,)\]]+/g;
+var isNoisePath = (value) => /\/Library(?:\/|$)|\/\.cursor(?:\/|$)|\/node_modules\/|\/\.git\/|^\/tmp|^\/var|^\/private|\/\.Trash\//u.test(value) || /^\/Users\/[^/]+\/(?:Downloads|Desktop)$/u.test(value);
+var stripLikelyFileName = (value) => {
+	return path.basename(value).includes(".") ? path.dirname(value) : value;
+};
+var containerRootFromPath = (value) => {
+	const candidate = stripLikelyFileName(normalizeCursorPath(value));
+	const reverseMatch = candidate.match(REVERSE_WORKSPACE_ROOT_RE);
+	if (reverseMatch) return reverseMatch[0] ?? null;
+	const match = candidate.match(CONTAINER_ROOT_RE);
+	if (match) return match[1] ?? null;
+	const parts = candidate.split("/");
+	if (parts.length >= 4 && parts[1] === "Users") return `/${parts.slice(1, 4).join("/")}`;
+	return null;
+};
+var inferFolderFromPaths = (paths) => {
+	const counts = /* @__PURE__ */ new Map();
+	for (const value of paths) {
+		if (isNoisePath(value)) continue;
+		const root = containerRootFromPath(value);
+		if (root) counts.set(root, (counts.get(root) ?? 0) + 1);
+	}
+	let best = null;
+	let bestCount = 0;
+	for (const [root, count] of counts) if (count > bestCount) {
+		best = root;
+		bestCount = count;
+	}
+	return best;
+};
+var inferFolderFromBlob = (blob) => {
+	const matches = blob.match(ABS_PATH_RE);
+	return matches ? inferFolderFromPaths(matches) : null;
+};
+var readCursorFileHistoryProjectActivity = async (userDir) => {
+	const historyDir = path.join(userDir, "History");
+	let entries = [];
+	try {
+		entries = await readdir(historyDir, { withFileTypes: true });
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+	const activity = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const entriesPath = path.join(historyDir, entry.name, "entries.json");
+		let data;
+		try {
+			data = await Bun.file(entriesPath).json();
+		} catch {
+			continue;
+		}
+		const folder = containerRootFromPath(typeof data.resource === "string" ? data.resource : "");
+		if (!folder || isNoisePath(folder)) continue;
+		const lastActiveMs = Math.max(0, ...(data.entries ?? []).map((item) => item.timestamp ?? 0));
+		activity.set(folder, Math.max(activity.get(folder) ?? 0, lastActiveMs));
+	}
+	return activity;
+};
+var inferFolderFromBubbles = (db, composerId) => {
+	const rows = db.query("SELECT value FROM cursorDiskKV WHERE key LIKE ? LIMIT 80").all(`bubbleId:${composerId}:%`);
+	const paths = [];
+	for (const { value } of rows) {
+		let bubble;
+		try {
+			bubble = JSON.parse(value);
+		} catch {
+			continue;
+		}
+		const tool = asObject(bubble.toolFormerData ?? null);
+		if (!tool) continue;
+		const matches = `${asString(tool.rawArgs ?? null) ?? ""} ${asString(tool.params ?? null) ?? ""}`.match(ABS_PATH_RE);
+		if (matches) paths.push(...matches);
+		if (paths.length > 200) break;
+	}
+	return inferFolderFromPaths(paths);
+};
+var readAllHeads = (db) => {
+	const rows = db.query(`SELECT substr(key, 14) AS id, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'`).all();
+	return new Map(rows.map((row) => [row.id, parseGlobalHead(row.value)]));
+};
+var parseGlobalHead = (value) => {
+	let parsed = {};
+	try {
+		parsed = JSON.parse(value);
+	} catch {
+		return {
+			createdAtMs: null,
+			lastUpdatedAtMs: null,
+			mode: null,
+			name: null,
+			pathHint: inferFolderFromBlob(value)
+		};
+	}
+	return {
+		createdAtMs: asNumber(parsed.createdAt ?? null),
+		lastUpdatedAtMs: asNumber(parsed.lastUpdatedAt ?? null),
+		mode: asString(parsed.unifiedMode ?? null),
+		name: asString(parsed.name ?? null),
+		pathHint: inferFolderFromBlob(value)
+	};
+};
+var readBubbleStats = (db) => {
+	const rows = db.query(`SELECT substr(key, 10, instr(substr(key, 10), ':') - 1) AS id,
+                    COUNT(*) AS count,
+                    COALESCE(SUM(length(value)), 0) AS bytes
+             FROM cursorDiskKV WHERE key GLOB 'bubbleId:*:*' GROUP BY id`).all();
+	return new Map(rows.map((row) => [row.id, {
+		bytes: row.bytes,
+		count: row.count
+	}]));
+};
+var readHeaderInfo = (globalDbPath) => {
+	const info = /* @__PURE__ */ new Map();
+	for (const header of loadGlobalComposerHeaders(globalDbPath)) {
+		if (!header.composerId) continue;
+		const identifier = header.workspaceIdentifier;
+		const uriPath = identifier?.uri?.path ?? identifier?.uri?.fsPath ?? null;
+		info.set(header.composerId, {
+			bucketId: identifier?.id ?? null,
+			name: typeof header.name === "string" ? header.name : null,
+			uriPath: uriPath ? normalizeCursorPath(uriPath) : null
+		});
+	}
+	return info;
+};
+var collectBucketComposerIds = (buckets) => {
+	const map = /* @__PURE__ */ new Map();
+	for (const bucket of buckets) for (const composerId of readBucketComposerIds(bucket.dbPath)) if (!map.has(composerId)) map.set(composerId, bucket.bucketId);
+	return map;
+};
+var findLinkedBucketId = (composerId, headerInfo, bucketIdToGroupKey, bucketComposerIds) => {
+	if (headerInfo?.bucketId && bucketIdToGroupKey.has(headerInfo.bucketId)) return headerInfo.bucketId;
+	return bucketComposerIds.get(composerId) ?? null;
+};
+var resolveThreadFolderHint = (composerId, head, headerInfo, stat, linkedBucketId, bucketIdToGroupKey, bucketIdToFolder, db) => {
+	if (linkedBucketId && bucketIdToGroupKey.has(linkedBucketId)) return {
+		folder: bucketIdToFolder.get(linkedBucketId) ?? null,
+		groupKey: bucketIdToGroupKey.get(linkedBucketId)
+	};
+	if (headerInfo?.uriPath) return {
+		folder: headerInfo.uriPath,
+		groupKey: `folder:${headerInfo.uriPath}`
+	};
+	if (head?.pathHint) return {
+		folder: head.pathHint,
+		groupKey: `folder:${head.pathHint}`
+	};
+	if (stat.count > 0) {
+		const folder = inferFolderFromBubbles(db, composerId);
+		return {
+			folder,
+			groupKey: folder ? `folder:${folder}` : UNKNOWN_GROUP_KEY
+		};
+	}
+	return {
+		folder: null,
+		groupKey: UNKNOWN_GROUP_KEY
+	};
+};
+var resolveThreadFolder = (composerId, head, headerInfo, stat, bucketIdToGroupKey, bucketIdToFolder, bucketComposerIds, db) => {
+	const linkedBucketId = findLinkedBucketId(composerId, headerInfo, bucketIdToGroupKey, bucketComposerIds);
+	const { folder, groupKey } = resolveThreadFolderHint(composerId, head, headerInfo, stat, linkedBucketId, bucketIdToGroupKey, bucketIdToFolder, db);
+	return {
+		bucketId: linkedBucketId,
+		composerId,
+		createdAtMs: head?.createdAtMs ?? null,
+		folder,
+		groupKey,
+		groupLabel: folder ? path.basename(folder) : "Unknown project",
+		lastUpdatedAtMs: head?.lastUpdatedAtMs ?? null,
+		mode: head?.mode ?? null,
+		name: head?.name || headerInfo?.name || "(untitled)",
+		stat
+	};
+};
+var toThreadSummary = (resolved) => ({
+	bubbleBytes: resolved.stat.bytes,
+	bubbleCount: resolved.stat.count,
+	bucketId: resolved.bucketId,
+	composerId: resolved.composerId,
+	createdAtMs: resolved.createdAtMs,
+	lastUpdatedAtMs: resolved.lastUpdatedAtMs,
+	mode: resolved.mode,
+	name: resolved.name,
+	transcriptDirs: [],
+	workspaceKey: resolved.groupKey,
+	workspaceLabel: resolved.groupLabel
+});
+var assembleDiscovery = (resolved, bucketGroups, fileHistoryActivity) => {
+	const threadsByKey = /* @__PURE__ */ new Map();
+	const lastActiveByKey = /* @__PURE__ */ new Map();
+	for (const thread of resolved) {
+		if (thread.groupKey === UNKNOWN_GROUP_KEY && thread.stat.count === 0) continue;
+		const list = threadsByKey.get(thread.groupKey) ?? [];
+		list.push(toThreadSummary(thread));
+		threadsByKey.set(thread.groupKey, list);
+		lastActiveByKey.set(thread.groupKey, Math.max(lastActiveByKey.get(thread.groupKey) ?? 0, thread.lastUpdatedAtMs ?? 0));
+	}
+	for (const [folder, lastActiveMs] of fileHistoryActivity) {
+		const key = `folder:${folder}`;
+		lastActiveByKey.set(key, Math.max(lastActiveByKey.get(key) ?? 0, lastActiveMs));
+	}
+	for (const list of threadsByKey.values()) list.sort((a, b) => (b.lastUpdatedAtMs ?? 0) - (a.lastUpdatedAtMs ?? 0));
+	return {
+		groups: buildDiscoveryGroups(threadsByKey, bucketGroups, lastActiveByKey),
+		threadsByKey
+	};
+};
+var mergeBucketGroup = (bucketGroup, threadsByKey, lastActiveByKey) => {
+	const threads = threadsByKey.get(bucketGroup.key) ?? [];
+	return {
+		...bucketGroup,
+		lastActiveMs: Math.max(bucketGroup.lastActiveMs, lastActiveByKey.get(bucketGroup.key) ?? 0),
+		threadCount: threads.length || bucketGroup.threadCount
+	};
+};
+var buildBucketlessGroup = (key, threadCount, lastActiveMs) => {
+	const isUnknown = key === UNKNOWN_GROUP_KEY;
+	const folder = isUnknown ? "" : key.slice(7);
+	return {
+		buckets: [],
+		folders: folder ? [folder] : [],
+		key,
+		kind: isUnknown ? "unknown" : "folder",
+		label: isUnknown ? "Unknown project" : path.basename(folder),
+		lastActiveMs,
+		needsRecovery: false,
+		threadCount,
+		uri: folder ? `file://${folder}` : ""
+	};
+};
+var buildDiscoveryGroups = (threadsByKey, bucketGroups, lastActiveByKey) => {
+	const seen = new Set(bucketGroups.map((group) => group.key));
+	const groups = bucketGroups.map((group) => mergeBucketGroup(group, threadsByKey, lastActiveByKey));
+	const keys = new Set([...threadsByKey.keys(), ...lastActiveByKey.keys()]);
+	for (const key of keys) {
+		const threads = threadsByKey.get(key) ?? [];
+		if (!seen.has(key) && (threads.length > 0 || key !== UNKNOWN_GROUP_KEY)) {
+			groups.push(buildBucketlessGroup(key, threads.length, lastActiveByKey.get(key) ?? 0));
+			seen.add(key);
+		}
+	}
+	return groups.sort((a, b) => b.lastActiveMs - a.lastActiveMs);
+};
+var buildDiscovery = async (userDir) => {
+	const buckets = await loadCursorBuckets(userDir);
+	const bucketGroups = groupCursorBuckets(buckets);
+	const fileHistoryActivity = await readCursorFileHistoryProjectActivity(userDir);
+	const globalDbPath = getCursorGlobalDbPath(userDir);
+	if (!await pathExists(globalDbPath)) return assembleDiscovery([], bucketGroups, fileHistoryActivity);
+	const bucketIdToGroupKey = /* @__PURE__ */ new Map();
+	const bucketIdToFolder = /* @__PURE__ */ new Map();
+	for (const group of bucketGroups) for (const bucket of group.buckets) {
+		bucketIdToGroupKey.set(bucket.bucketId, group.key);
+		bucketIdToFolder.set(bucket.bucketId, group.folders[0] ?? null);
+	}
+	const headerInfo = readHeaderInfo(globalDbPath);
+	const bucketComposerIds = collectBucketComposerIds(buckets);
+	const db = openCursorReadonlyDb(globalDbPath);
+	try {
+		const heads = readAllHeads(db);
+		const stats = readBubbleStats(db);
+		const universe = new Set([
+			...heads.keys(),
+			...headerInfo.keys(),
+			...bucketComposerIds.keys()
+		]);
+		const resolved = [];
+		for (const composerId of universe) resolved.push(resolveThreadFolder(composerId, heads.get(composerId), headerInfo.get(composerId), stats.get(composerId) ?? {
+			bytes: 0,
+			count: 0
+		}, bucketIdToGroupKey, bucketIdToFolder, bucketComposerIds, db));
+		return assembleDiscovery(resolved, bucketGroups, fileHistoryActivity);
+	} finally {
+		db.close();
+	}
+};
+var discoverCursorWorkspaces = async (userDir) => {
+	const now = Date.now();
+	if (discoveryCache && discoveryCache.userDir === userDir && now - discoveryCache.at < DISCOVERY_TTL_MS) return discoveryCache.value;
+	const value = await buildDiscovery(userDir);
+	discoveryCache = {
+		at: now,
+		userDir,
+		value
+	};
+	return value;
+};
+var readCursorThreadHead = (globalDbPath, composerId) => {
+	const db = openCursorReadonlyDb(globalDbPath);
+	try {
+		const head = readKvValue(db, `composerData:${composerId}`);
+		if (!head) return null;
+		const headerList = Array.isArray(head.fullConversationHeadersOnly) ? head.fullConversationHeadersOnly : [];
+		const orderedBubbleIds = headerList.map((item) => asString(asObject(item)?.bubbleId ?? null)).filter((value) => Boolean(value));
+		return {
+			composerId,
+			createdAtMs: asNumber(head.createdAt ?? null),
+			lastUpdatedAtMs: asNumber(head.lastUpdatedAt ?? null),
+			mode: asString(head.unifiedMode ?? null),
+			name: asString(head.name ?? null),
+			orderedBubbleIds,
+			totalBubbleHeaders: headerList.length
+		};
+	} finally {
+		db.close();
+	}
+};
+var toBubbleKind = (rawType) => {
+	if (rawType === 1) return "user";
+	if (rawType === 2) return "assistant";
+	return "unknown";
+};
+var parseToolCall = (raw) => {
+	const data = asObject(raw);
+	if (!data) return null;
+	const name = asString(data.name ?? null);
+	if (!name) return null;
+	return {
+		argumentsText: asString(data.rawArgs ?? null) ?? asString(data.params ?? null),
+		callId: asString(data.toolCallId ?? null),
+		name,
+		resultText: asString(data.result ?? null),
+		status: asString(data.status ?? null)
+	};
+};
+var parseCursorBubble = (bubbleId, raw) => {
+	const thinking = asObject(raw.thinking ?? null);
+	return {
+		bubbleId,
+		createdAtMs: asNumber(raw.createdAt ?? null),
+		kind: toBubbleKind(raw.type ?? null),
+		text: asString(raw.text ?? null) ?? "",
+		thinking: thinking ? asString(thinking.text ?? null) : null,
+		toolCall: parseToolCall(raw.toolFormerData ?? null)
+	};
+};
+var readBubble = (db, composerId, bubbleId) => {
+	const raw = readKvValue(db, `bubbleId:${composerId}:${bubbleId}`);
+	if (!raw) return null;
+	return parseCursorBubble(bubbleId, raw);
+};
+var isRenderableBubble = (bubble) => {
+	return Boolean(bubble.text.trim() || bubble.thinking?.trim() || bubble.toolCall);
+};
+var readCursorThreadTranscript = (globalDbPath, composerId) => {
+	const head = readCursorThreadHead(globalDbPath, composerId);
+	if (!head) return null;
+	const db = openCursorReadonlyDb(globalDbPath);
+	try {
+		const orderedIds = head.orderedBubbleIds.length > 0 ? head.orderedBubbleIds : readAllBubbleIds(db, composerId);
+		const bubbles = [];
+		for (const bubbleId of orderedIds) {
+			const bubble = readBubble(db, composerId, bubbleId);
+			if (bubble && isRenderableBubble(bubble)) bubbles.push(bubble);
+		}
+		const totalBubbleRows = countBubbles(db, composerId).count;
+		return {
+			bubbles,
+			head,
+			omittedBubbleCount: Math.max(totalBubbleRows - orderedIds.length, 0),
+			renderableBubbleCount: bubbles.length
+		};
+	} finally {
+		db.close();
+	}
+};
+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 };

package/apps/ui/dist/server/assets/cursor-exporter-types-CI3goo-c.js

@@ -0,0 +1,34 @@
+import os from "node:os";
+import path from "node:path";
+//#region ../../src/lib/cursor-exporter-types.ts
+var getDefaultCursorUserDir = (platform = process.platform, env = process.env, homeDir = os.homedir()) => {
+	if (platform === "win32") return path.win32.join(env.APPDATA || path.win32.join(homeDir, "AppData", "Roaming"), "Cursor", "User");
+	if (platform === "linux") return path.posix.join(env.XDG_DATA_HOME || path.posix.join(homeDir, ".local", "share"), "Cursor", "User");
+	return path.posix.join(homeDir, "Library", "Application Support", "Cursor", "User");
+};
+var DEFAULT_CURSOR_USER_DIR = getDefaultCursorUserDir();
+var resolveCursorUserDir = () => {
+	const configured = process.env.SPIRACHA_CURSOR_USER_DIR?.trim();
+	return configured ? configured : DEFAULT_CURSOR_USER_DIR;
+};
+var getCursorWorkspaceStorageDir = (userDir = resolveCursorUserDir()) => path.join(userDir, "workspaceStorage");
+var getCursorGlobalDbPath = (userDir = resolveCursorUserDir()) => path.join(userDir, "globalStorage", "state.vscdb");
+var inferHomeDirFromCursorUserDir = (userDir) => {
+	const normalized = userDir.replace(/\\/gu, "/");
+	for (const suffix of [
+		"/Library/Application Support/Cursor/User",
+		"/AppData/Roaming/Cursor/User",
+		"/.local/share/Cursor/User"
+	]) if (normalized.endsWith(suffix)) return userDir.slice(0, userDir.length - suffix.length);
+	return null;
+};
+var getCursorProjectsDir = (userDir = resolveCursorUserDir()) => {
+	const configured = process.env.SPIRACHA_CURSOR_PROJECTS_DIR?.trim();
+	if (configured) return configured;
+	const inferredHomeDir = inferHomeDirFromCursorUserDir(userDir);
+	return inferredHomeDir ? path.join(inferredHomeDir, ".cursor", "projects") : path.join(userDir, "projects");
+};
+var COMPOSER_DATA_KEY = "composer.composerData";
+var COMPOSER_HEADERS_KEY = "composer.composerHeaders";
+//#endregion
+export { COMPOSER_DATA_KEY, COMPOSER_HEADERS_KEY, getCursorGlobalDbPath, getCursorProjectsDir, getCursorWorkspaceStorageDir, resolveCursorUserDir };