spiracha 1.5.0 → 2.1.0

package/src/lib/conversation-zip-export.ts

@@ -0,0 +1,57 @@
+import { randomUUID } from 'node:crypto';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { resolveUniqueExportFileBaseName, sanitizeExportFileName, zipExportDirectory } from './ui-export-archive';
+
+type ConversationMarkdownZipEntry = {
+    fallbackBaseName: string;
+    markdown: string;
+    title: string | null;
+};
+
+type ConversationMarkdownZipOptions = {
+    entries: ConversationMarkdownZipEntry[];
+    fileBaseName: string;
+};
+
+export type ConversationMarkdownZip = {
+    blob: Blob;
+    fileName: string;
+    mimeType: 'application/zip';
+};
+
+const toSafeFileBaseName = (value: string | null, fallback: string) => {
+    return sanitizeExportFileName(value?.trim() || '') || sanitizeExportFileName(fallback) || 'conversation';
+};
+
+export const createConversationMarkdownZip = async ({
+    entries,
+    fileBaseName,
+}: ConversationMarkdownZipOptions): Promise<ConversationMarkdownZip> => {
+    if (entries.length === 0) {
+        throw new Error('No conversations selected for export');
+    }
+
+    const safeBaseName = toSafeFileBaseName(fileBaseName, 'conversations');
+    const workspaceDir = await mkdtemp(path.join(os.tmpdir(), `${safeBaseName}-`));
+    const zipPath = path.join(os.tmpdir(), `${safeBaseName}-${randomUUID()}.zip`);
+    const usedBaseNames = new Map<string, number>();
+
+    try {
+        for (const entry of entries) {
+            const entryBaseName = toSafeFileBaseName(entry.title, entry.fallbackBaseName);
+            const fileBaseNameForEntry = resolveUniqueExportFileBaseName(entryBaseName, usedBaseNames);
+            await Bun.write(path.join(workspaceDir, `${fileBaseNameForEntry}.md`), entry.markdown);
+        }
+
+        await zipExportDirectory(workspaceDir, zipPath);
+        return {
+            blob: new Blob([await Bun.file(zipPath).arrayBuffer()], { type: 'application/zip' }),
+            fileName: `${safeBaseName}.zip`,
+            mimeType: 'application/zip',
+        };
+    } finally {
+        await Promise.all([rm(workspaceDir, { force: true, recursive: true }), rm(zipPath, { force: true })]);
+    }
+};

package/src/lib/cursor-db.ts

@@ -126,6 +126,11 @@ const parseCodeWorkspaceJson = (text: string): { folders?: Array<{ path?: string
     }
 };
 
+const isMissingCodeWorkspaceFileError = (error: unknown): boolean => {
+    const code = (error as { code?: unknown }).code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+};
+
 const parseCodeWorkspaceFolders = async (workspaceFilePath: string): Promise<string[]> => {
     if (!workspaceFilePath.endsWith('.code-workspace')) {
         return [];
@@ -149,6 +154,10 @@ const parseCodeWorkspaceFolders = async (workspaceFilePath: string): Promise<str
 
         return folders;
     } catch (error) {
+        if (isMissingCodeWorkspaceFileError(error)) {
+            return [];
+        }
+
         warnCursorDataIssue('invalid_code_workspace_json', {
             error: error instanceof Error ? error.message : String(error),
             workspaceFilePath,
@@ -360,8 +369,11 @@ export const groupCursorBuckets = (buckets: CursorWorkspaceBucket[]): CursorWork
     return groups.sort((a, b) => b.lastActiveMs - a.lastActiveMs);
 };
 
-export const listCursorWorkspaceGroups = async (userDir = resolveCursorUserDir()): Promise<CursorWorkspaceGroup[]> => {
-    return (await discoverCursorWorkspaces(userDir)).groups;
+export const listCursorWorkspaceGroups = async (
+    userDir = resolveCursorUserDir(),
+    options: CursorDiscoveryOptions = {},
+): Promise<CursorWorkspaceGroup[]> => {
+    return (await discoverCursorWorkspaces(userDir, options)).groups;
 };
 
 export const cursorBucketMatchesQuery = (bucket: CursorWorkspaceBucket, query: string): boolean => {
@@ -462,6 +474,7 @@ export const findCursorTranscriptDirs = async (
 
 export type ListCursorThreadsOptions = {
     includeTranscriptDirs?: boolean;
+    updatedAfterMs?: number;
 };
 
 export const listCursorThreadsForGroup = async (
@@ -469,7 +482,7 @@ export const listCursorThreadsForGroup = async (
     userDir = resolveCursorUserDir(),
     options: ListCursorThreadsOptions = {},
 ): Promise<CursorThreadSummary[]> => {
-    const discovery = await discoverCursorWorkspaces(userDir);
+    const discovery = await discoverCursorWorkspaces(userDir, options);
     const threads = discovery.threadsByKey.get(group.key) ?? [];
 
     if (options.includeTranscriptDirs === false) {
@@ -505,6 +518,10 @@ type CursorDiscovery = {
     threadsByKey: Map<string, CursorThreadSummary[]>;
 };
 
+type CursorDiscoveryOptions = {
+    updatedAfterMs?: number;
+};
+
 // Discovery does a full scan of the (potentially multi-GB) global DB, so cache it briefly. Writes
 // (recover/prune/delete) call invalidateCursorDiscoveryCache() so the UI never shows stale results.
 const DISCOVERY_TTL_MS = 60_000;
@@ -662,18 +679,41 @@ const inferFolderFromBubbles = (db: Database, composerId: string): string | null
     return inferFolderFromPaths(paths);
 };
 
-const readAllHeads = (db: Database): Map<string, GlobalHead> => {
+const readAllHeads = (db: Database, options: CursorDiscoveryOptions = {}): Map<string, GlobalHead> => {
+    if (options.updatedAfterMs !== undefined) {
+        const rows = db
+            .query(
+                `SELECT substr(key, 14) AS id, value
+                 FROM cursorDiskKV
+                 WHERE key LIKE 'composerData:%'
+                    AND COALESCE(json_extract(value, '$.lastUpdatedAt'), 0) >= ?`,
+            )
+            .all(options.updatedAfterMs) as Array<{ id: string; value: string | null }>;
+
+        return new Map(rows.map((row) => [row.id, parseGlobalHead(row.value)]));
+    }
+
     const rows = db
         .query(`SELECT substr(key, 14) AS id, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'`)
-        .all() as Array<{ id: string; value: string }>;
+        .all() as Array<{ id: string; value: string | null }>;
 
     return new Map(rows.map((row) => [row.id, parseGlobalHead(row.value)]));
 };
 
-const parseGlobalHead = (value: string): GlobalHead => {
-    let parsed: Record<string, JsonValue> = {};
+const parseGlobalHead = (value: string | null): GlobalHead => {
+    let parsed: Record<string, JsonValue> | null = {};
+    if (value === null) {
+        return {
+            createdAtMs: null,
+            lastUpdatedAtMs: null,
+            mode: null,
+            name: null,
+            pathHint: null,
+        };
+    }
+
     try {
-        parsed = JSON.parse(value) as Record<string, JsonValue>;
+        parsed = asObject(JSON.parse(value) as JsonValue);
     } catch {
         return {
             createdAtMs: null,
@@ -684,6 +724,16 @@ const parseGlobalHead = (value: string): GlobalHead => {
         };
     }
 
+    if (!parsed) {
+        return {
+            createdAtMs: null,
+            lastUpdatedAtMs: null,
+            mode: null,
+            name: null,
+            pathHint: inferFolderFromBlob(value),
+        };
+    }
+
     return {
         createdAtMs: asNumber(parsed.createdAt ?? null),
         lastUpdatedAtMs: asNumber(parsed.lastUpdatedAt ?? null),
@@ -693,17 +743,28 @@ const parseGlobalHead = (value: string): GlobalHead => {
     };
 };
 
-const readBubbleStats = (db: Database): Map<string, BubbleStat> => {
+const readBubbleStats = (db: Database, composerIds?: Iterable<string>): Map<string, BubbleStat> => {
+    const ids = composerIds ? [...composerIds] : null;
+    if (ids?.length === 0) {
+        return new Map();
+    }
+
     // Keys are `bubbleId:<composerId>:<bubbleId>`; composer ids contain no colon, so slice up to the
     // next ':' rather than assuming a fixed UUID length (keeps tests and any id format working).
-    const rows = db
-        .query(
-            `SELECT substr(key, 10, instr(substr(key, 10), ':') - 1) AS id,
+    const query =
+        ids === null
+            ? `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() as Array<{ id: string; count: number; bytes: number }>;
+             FROM cursorDiskKV WHERE key GLOB 'bubbleId:*:*' GROUP BY id`
+            : `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:*:*'
+                AND substr(key, 10, instr(substr(key, 10), ':') - 1) IN (${ids.map(() => '?').join(',')})
+             GROUP BY id`;
+    const rows = db.query(query).all(...(ids ?? [])) as Array<{ id: string; count: number; bytes: number }>;
 
     return new Map(rows.map((row) => [row.id, { bytes: row.bytes, count: row.count }]));
 };
@@ -936,14 +997,13 @@ const buildDiscoveryGroups = (
     return groups.sort((a, b) => b.lastActiveMs - a.lastActiveMs);
 };
 
-const buildDiscovery = async (userDir: string): Promise<CursorDiscovery> => {
+const buildDiscovery = async (userDir: string, options: CursorDiscoveryOptions = {}): Promise<CursorDiscovery> => {
     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);
+        return assembleDiscovery([], bucketGroups, new Map());
     }
 
     const bucketIdToGroupKey = new Map<string, string>();
@@ -955,14 +1015,20 @@ const buildDiscovery = async (userDir: string): Promise<CursorDiscovery> => {
         }
     }
 
-    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<string>([...heads.keys(), ...headerInfo.keys(), ...bucketComposerIds.keys()]);
+        const heads = readAllHeads(db, options);
+        if (options.updatedAfterMs !== undefined && heads.size === 0) {
+            return assembleDiscovery([], bucketGroups, new Map());
+        }
+
+        const headerInfo = readHeaderInfo(globalDbPath);
+        const bucketComposerIds = options.updatedAfterMs === undefined ? collectBucketComposerIds(buckets) : new Map();
+        const stats = readBubbleStats(db, options.updatedAfterMs === undefined ? undefined : heads.keys());
+        const universe =
+            options.updatedAfterMs === undefined
+                ? new Set<string>([...heads.keys(), ...headerInfo.keys(), ...bucketComposerIds.keys()])
+                : new Set<string>(heads.keys());
         const resolved: ResolvedThread[] = [];
 
         for (const composerId of universe) {
@@ -980,13 +1046,22 @@ const buildDiscovery = async (userDir: string): Promise<CursorDiscovery> => {
             );
         }
 
+        const fileHistoryActivity =
+            options.updatedAfterMs === undefined ? await readCursorFileHistoryProjectActivity(userDir) : new Map();
         return assembleDiscovery(resolved, bucketGroups, fileHistoryActivity);
     } finally {
         db.close();
     }
 };
 
-const discoverCursorWorkspaces = async (userDir: string): Promise<CursorDiscovery> => {
+const discoverCursorWorkspaces = async (
+    userDir: string,
+    options: CursorDiscoveryOptions = {},
+): Promise<CursorDiscovery> => {
+    if (options.updatedAfterMs !== undefined) {
+        return await buildDiscovery(userDir, options);
+    }
+
     const now = Date.now();
     if (discoveryCache && discoveryCache.userDir === userDir && now - discoveryCache.at < DISCOVERY_TTL_MS) {
         return discoveryCache.value;

package/src/lib/cursor-exporter-types.ts

@@ -152,25 +152,6 @@ export type CursorExportOptions = {
     outputFormat: ExportFormat;
 };
 
-export type CursorCliOptions = CursorExportOptions & {
-    userDir: string;
-    workspaceQuery: string | null;
-    threadIds: string[];
-    outputDir: string | null;
-};
-
-export type CursorExportedFile = {
-    composerId: string;
-    outputPath: string;
-};
-
-export type CursorExportRunResult = {
-    outputDir: string;
-    exportedCount: number;
-    files: CursorExportedFile[];
-    missingThreadIds: string[];
-};
-
 export type CursorRecoverResult = {
     workspaceKey: string;
     activeBucketId: string;