spiracha 2.0.0 → 2.2.0

package/apps/ui/src/lib/cursor-server.ts

@@ -1,23 +1,18 @@
-import { randomUUID } from 'node:crypto';
-import { mkdtemp, rm } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import {
-    getExportMimeType,
-    resolveUniqueExportFileBaseName,
-    sanitizeExportFileName,
-    zipExportDirectory,
-} from '@spiracha/lib/ui-export-archive';
-import { buildUiExportDownloadUrl, ensureUiExportDir } from '@spiracha/lib/ui-export-files';
+import { isSafeCursorComposerId } from '@spiracha/lib/cursor-id';
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
+import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
 
 const workspaceSchema = z.object({
     workspaceKey: z.string().min(1),
 });
 
+const composerIdSchema = z.string().refine(isSafeCursorComposerId, {
+    message: 'Invalid Cursor composer id.',
+});
+
 const threadSchema = z.object({
-    composerId: z.string().min(1),
+    composerId: composerIdSchema,
 });
 
 const recoverSchema = z.object({
@@ -26,7 +21,7 @@ const recoverSchema = z.object({
 });
 
 const exportSchema = z.object({
-    composerId: z.string().min(1),
+    composerId: composerIdSchema,
     includeCommentary: z.boolean().default(true),
     includeMetadata: z.boolean().default(true),
     includeTools: z.boolean().default(true),
@@ -35,7 +30,7 @@ const exportSchema = z.object({
 });
 
 const exportThreadsSchema = z.object({
-    composerIds: z.array(z.string().min(1)).min(1),
+    composerIds: z.array(composerIdSchema).min(1),
     includeCommentary: z.boolean().default(true),
     includeMetadata: z.boolean().default(true),
     includeTools: z.boolean().default(true),
@@ -44,7 +39,7 @@ const exportThreadsSchema = z.object({
 });
 
 const deleteThreadsSchema = z.object({
-    composerIds: z.array(z.string().min(1)).min(1),
+    composerIds: z.array(composerIdSchema).min(1),
 });
 
 const ensureCursorClosedForWrite = async () => {
@@ -67,39 +62,29 @@ const findGroupByKey = async (workspaceKey: string) => {
     return group;
 };
 
-const toSafeExportName = (value: string) => {
-    return sanitizeExportFileName(value) || 'cursor-thread';
-};
-
 const renderCursorZipDownload = async (
-    rendered: Array<{ composerId: string; content: string }>,
+    rendered: Array<{
+        composerId: string;
+        content: string;
+        cwd: string | null;
+        fileBaseName: string;
+        updatedAtMs: number | null;
+    }>,
     outputFormat: 'md' | 'txt',
 ) => {
-    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 = new Map<string, number>();
-
-    try {
-        for (const entry of rendered) {
-            const baseName = toSafeExportName(entry.composerId);
-            const fileBaseName = resolveUniqueExportFileBaseName(baseName, 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' as const,
-    };
+    return renderSourceSessionsDownload({
+        entries: rendered.map((entry) => ({
+            content: entry.content,
+            cwd: entry.cwd,
+            fallbackBaseName: 'cursor-thread',
+            fileBaseName: entry.fileBaseName,
+            sessionId: entry.composerId,
+            updatedAtMs: entry.updatedAtMs,
+        })),
+        fallbackBaseName: 'cursor',
+        outputFormat,
+        zipArchive: true,
+    });
 };
 
 export const findCursorThreadByComposerId = async (composerId: string) => {
@@ -123,13 +108,23 @@ const renderCursorDownload = async (input: {
     outputFormat: 'md' | 'txt';
     zipArchive: boolean;
 }) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
     const { readCursorThreadTranscriptWithAgentFiles } = await import('@spiracha/lib/cursor-db');
     const { getCursorGlobalDbPath } = await import('@spiracha/lib/cursor-exporter-types');
     const { renderCursorTranscript } = await import('@spiracha/lib/cursor-transcript');
     const globalDbPath = getCursorGlobalDbPath();
+    const { listCursorWorkspaceGroups } = await import('@spiracha/lib/cursor-db');
+    const workspaceGroups = await listCursorWorkspaceGroups();
     const rendered = await Promise.all(
         input.composerIds.map(async (composerId) => {
-            const transcript = await readCursorThreadTranscriptWithAgentFiles(globalDbPath, composerId);
+            const transcript = await runWithTranscriptLoadLimit(
+                () => readCursorThreadTranscriptWithAgentFiles(globalDbPath, composerId),
+                {
+                    id: composerId,
+                    path: globalDbPath,
+                    source: 'cursor-ui-export',
+                },
+            );
             if (!transcript) {
                 throw new Error(`No transcript found for thread: ${composerId}`);
             }
@@ -145,9 +140,17 @@ const renderCursorDownload = async (input: {
                 throw new Error(`Thread has no exportable content: ${composerId}`);
             }
 
+            const workspace =
+                workspaceGroups.find((candidate) =>
+                    candidate.buckets.some((bucket) => bucket.threadComposerIds.includes(composerId)),
+                ) ?? null;
+
             return {
                 composerId,
                 content,
+                cwd: workspace?.folders[0] ?? null,
+                fileBaseName: transcript.head.name || composerId,
+                updatedAtMs: transcript.head.lastUpdatedAtMs,
             };
         }),
     );
@@ -157,12 +160,16 @@ const renderCursorDownload = async (input: {
     }
 
     if (rendered.length === 1) {
-        return {
-            content: rendered[0]!.content,
-            fileName: `${toSafeExportName(rendered[0]!.composerId)}.${input.outputFormat}`,
-            mimeType: getExportMimeType(input.outputFormat),
-            mode: 'download' as const,
-        };
+        const entry = rendered[0]!;
+        return renderSourceSessionDownload({
+            content: entry.content,
+            cwd: entry.cwd,
+            fallbackBaseName: 'cursor-thread',
+            outputFormat: input.outputFormat,
+            sessionId: entry.composerId,
+            updatedAtMs: entry.updatedAtMs,
+            zipArchive: false,
+        });
     }
 
     throw new Error('No Cursor threads selected for export');
@@ -184,6 +191,7 @@ export const listCursorThreadsFn = createServerFn({ method: 'GET' })
 export const getCursorThreadDetailFn = createServerFn({ method: 'GET' })
     .validator(threadSchema)
     .handler(async ({ data }) => {
+        const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
         const { readCursorThreadTranscriptWithAgentFiles } = await import('@spiracha/lib/cursor-db');
         const { getCursorGlobalDbPath } = await import('@spiracha/lib/cursor-exporter-types');
         const thread = await findCursorThreadByComposerId(data.composerId);
@@ -191,7 +199,14 @@ export const getCursorThreadDetailFn = createServerFn({ method: 'GET' })
             throw new Error(`Cursor thread not found: ${data.composerId}`);
         }
 
-        const transcript = await readCursorThreadTranscriptWithAgentFiles(getCursorGlobalDbPath(), data.composerId);
+        const transcript = await runWithTranscriptLoadLimit(
+            () => readCursorThreadTranscriptWithAgentFiles(getCursorGlobalDbPath(), data.composerId),
+            {
+                id: data.composerId,
+                path: getCursorGlobalDbPath(),
+                source: 'cursor-ui-detail',
+            },
+        );
         return {
             thread,
             transcript,

package/apps/ui/src/lib/cursor-transcript-events.ts

@@ -1,6 +1,8 @@
 import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
 import type { CursorBubble, CursorThreadTranscript, CursorToolCall } from '@spiracha/lib/cursor-exporter-types';
+import { getCursorTextBubblePhase, getFinalCursorAssistantTextBubbleIds } from '@spiracha/lib/cursor-transcript-phase';
 import type { JsonValue } from '@spiracha/lib/shared';
+import { getThreadTranscriptStats } from './thread-transcript-stats';
 
 const toTimestamp = (value: number | null): string | null => {
     if (value === null || !Number.isFinite(value)) {
@@ -110,36 +112,10 @@ const buildToolOutputEvent = (bubble: CursorBubble, sequence: number, toolCall:
     };
 };
 
-const getAssistantFinalTextIndexes = (bubbles: CursorBubble[]) => {
-    const finalTextIndexes = new Set<number>();
-    let currentAssistantTextIndex: number | null = null;
-
-    const flushAssistantRun = () => {
-        if (currentAssistantTextIndex !== null) {
-            finalTextIndexes.add(currentAssistantTextIndex);
-            currentAssistantTextIndex = null;
-        }
-    };
-
-    bubbles.forEach((bubble, index) => {
-        if (bubble.kind !== 'assistant') {
-            flushAssistantRun();
-            return;
-        }
-
-        if (bubble.text.trim()) {
-            currentAssistantTextIndex = index;
-        }
-    });
-
-    flushAssistantRun();
-    return finalTextIndexes;
-};
-
 const cursorBubbleToThreadEvents = (
     bubble: CursorBubble,
     bubbleIndex: number,
-    finalTextIndexes: Set<number>,
+    finalAssistantTextBubbleIds: Set<string>,
 ): ThreadEvent[] => {
     if (bubble.kind !== 'assistant' && bubble.kind !== 'user') {
         return [];
@@ -152,9 +128,8 @@ const cursorBubbleToThreadEvents = (
     }
 
     if (bubble.text.trim()) {
-        const phase =
-            bubble.kind === 'assistant' ? (finalTextIndexes.has(bubbleIndex) ? 'final_answer' : 'commentary') : null;
-        events.push(buildMessageEvent(bubble, baseSequence + 1, bubble.kind, bubble.text, phase));
+        const phase = getCursorTextBubblePhase(bubble, finalAssistantTextBubbleIds);
+        events.push(buildMessageEvent(bubble, baseSequence + 1, bubble.kind, bubble.text.trim(), phase));
     }
 
     if (bubble.kind === 'assistant' && bubble.toolCall) {
@@ -169,61 +144,11 @@ const cursorBubbleToThreadEvents = (
 };
 
 export const cursorTranscriptToThreadEvents = (transcript: CursorThreadTranscript): ThreadEvent[] => {
-    const finalTextIndexes = getAssistantFinalTextIndexes(transcript.bubbles);
-    return transcript.bubbles.flatMap((bubble, index) => cursorBubbleToThreadEvents(bubble, index, finalTextIndexes));
-};
-
-const updateMessageStats = (stats: ThreadTranscriptStats, event: Extract<ThreadEvent, { kind: 'message' }>) => {
-    stats.messageCount += 1;
-    if (event.role === 'assistant') {
-        stats.assistantMessageCount += 1;
-    }
-    if (event.role === 'user') {
-        stats.userMessageCount += 1;
-    }
-    if (event.phase === 'commentary') {
-        stats.commentaryCount += 1;
-    }
-    if (event.phase === 'final_answer') {
-        stats.finalAnswerCount += 1;
-    }
-};
-
-const updateCursorStats = (stats: ThreadTranscriptStats, event: ThreadEvent) => {
-    switch (event.kind) {
-        case 'message':
-            updateMessageStats(stats, event);
-            break;
-        case 'tool_call':
-            stats.toolCallCount += 1;
-            break;
-        case 'tool_output':
-            stats.toolOutputCount += 1;
-            break;
-        case 'web_search':
-            stats.webSearchEventCount += 1;
-            break;
-        default:
-            break;
-    }
+    const finalAssistantTextBubbleIds = getFinalCursorAssistantTextBubbleIds(transcript.bubbles);
+    return transcript.bubbles.flatMap((bubble, index) =>
+        cursorBubbleToThreadEvents(bubble, index, finalAssistantTextBubbleIds),
+    );
 };
 
-export const getCursorThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats => {
-    const stats: ThreadTranscriptStats = {
-        assistantMessageCount: 0,
-        commentaryCount: 0,
-        execCommandCount: 0,
-        finalAnswerCount: 0,
-        messageCount: 0,
-        toolCallCount: 0,
-        toolOutputCount: 0,
-        userMessageCount: 0,
-        webSearchEventCount: 0,
-    };
-
-    for (const event of events) {
-        updateCursorStats(stats, event);
-    }
-
-    return stats;
-};
+export const getCursorThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats =>
+    getThreadTranscriptStats(events);

package/apps/ui/src/lib/delete-batch.ts

@@ -0,0 +1,52 @@
+export class DeleteBatchError<TId, TResult> extends AggregateError {
+    readonly failedIds: TId[];
+    readonly successfulIds: TId[];
+    readonly successfulResults: TResult[];
+
+    constructor(
+        failures: Array<{ id: TId; reason: unknown }>,
+        successes: Array<{ id: TId; result: TResult }>,
+        totalCount: number,
+    ) {
+        const visibleFailedIds = failures.slice(0, 5).map((failure) => String(failure.id));
+        const omittedFailedIdCount = failures.length - visibleFailedIds.length;
+        const failedIdSummary = `${visibleFailedIds.join(', ')}${omittedFailedIdCount > 0 ? ` (+${omittedFailedIdCount} more)` : ''}`;
+        super(
+            failures.map((failure) => failure.reason),
+            `${failures.length} of ${totalCount} deletions failed: ${failedIdSummary}`,
+        );
+        this.name = 'DeleteBatchError';
+        this.failedIds = failures.map((failure) => failure.id);
+        this.successfulIds = successes.map((success) => success.id);
+        this.successfulResults = successes.map((success) => success.result);
+    }
+}
+
+export const runDeleteBatch = async <TId, TResult>(
+    ids: TId[],
+    deleteOne: (id: TId) => Promise<TResult>,
+): Promise<TResult[]> => {
+    const settled = await Promise.allSettled(ids.map((id) => deleteOne(id)));
+    const failures: Array<{ id: TId; reason: unknown }> = [];
+    const successes: Array<{ id: TId; result: TResult }> = [];
+    for (const [index, result] of settled.entries()) {
+        const id = ids[index]!;
+        if (result.status === 'rejected') {
+            failures.push({ id, reason: result.reason });
+        } else {
+            successes.push({ id, result: result.value });
+        }
+    }
+    if (failures.length > 0) {
+        throw new DeleteBatchError(failures, successes, ids.length);
+    }
+
+    return successes.map((success) => success.result);
+};
+
+export const requireDeletedItems = <T>(deletedIds: T[], label: string, id: string): T[] => {
+    if (deletedIds.length === 0) {
+        throw new Error(`${label} not found: ${id}`);
+    }
+    return deletedIds;
+};

package/apps/ui/src/lib/error-presentation.ts

@@ -0,0 +1,43 @@
+import { isSqliteDatabaseError } from '@spiracha/lib/sqlite-error';
+
+export type ErrorPresentation = {
+    description: string;
+    isDatabaseError: boolean;
+    title: string;
+};
+
+type ErrorPresentationOptions = {
+    fallbackTitle: string;
+};
+
+const DATABASE_ERROR_DESCRIPTION =
+    'Spiracha could not open a local conversation database. The source application may have an exclusive lock on the file, or the database may not exist yet. Close the relevant application or wait a moment, then reload.';
+
+const redactLocalPaths = (message: string): string => {
+    return message
+        .split(/(https?:\/\/[^\s]+)/gu)
+        .map((part, index) =>
+            index % 2 === 1
+                ? part
+                : part
+                      .replace(/\/(?:[^/\s]+\/)+[^/\s]+/gu, '[local path]')
+                      .replace(/[A-Z]:\\(?:[^\\\s]+\\)+[^\\\s]+/gu, '[local path]'),
+        )
+        .join('');
+};
+
+export const getErrorPresentation = (error: Error, options: ErrorPresentationOptions): ErrorPresentation => {
+    if (isSqliteDatabaseError(error)) {
+        return {
+            description: DATABASE_ERROR_DESCRIPTION,
+            isDatabaseError: true,
+            title: 'Database unavailable',
+        };
+    }
+
+    return {
+        description: redactLocalPaths(error.message),
+        isDatabaseError: false,
+        title: options.fallbackTitle,
+    };
+};

package/apps/ui/src/lib/export-mutation.ts

@@ -0,0 +1,20 @@
+import type { ExportDialogOptions } from '#/lib/export-options';
+
+export type ExportSelectionMutationInput = Readonly<{
+    ids: readonly string[];
+    options: Readonly<ExportDialogOptions>;
+}>;
+
+export const createExportSelectionMutationInput = (
+    ids: readonly string[],
+    options: ExportDialogOptions,
+): ExportSelectionMutationInput => {
+    if (ids.length === 0) {
+        throw new Error('No conversations selected for export');
+    }
+
+    return {
+        ids: [...ids],
+        options: { ...options },
+    };
+};

package/apps/ui/src/lib/export-options.ts

@@ -0,0 +1,15 @@
+export type ExportDialogOptions = {
+    includeCommentary: boolean;
+    includeMetadata: boolean;
+    includeTools: boolean;
+    outputFormat: 'md' | 'txt';
+    zipArchive: boolean;
+};
+
+export const DEFAULT_EXPORT_DIALOG_OPTIONS: ExportDialogOptions = {
+    includeCommentary: false,
+    includeMetadata: true,
+    includeTools: true,
+    outputFormat: 'md',
+    zipArchive: false,
+};

package/apps/ui/src/lib/formatters.ts

@@ -11,11 +11,9 @@ type DateTimeFormatterSet = {
 };
 
 const DATE_TIME_FORMATTERS = new Map<string, DateTimeFormatterSet>();
-const DEFAULT_TIME_ZONE = 'UTC';
 
 const getDateTimeFormatters = (timeZone?: string): DateTimeFormatterSet => {
-    const resolvedTimeZone = timeZone ?? DEFAULT_TIME_ZONE;
-    const cacheKey = resolvedTimeZone;
+    const cacheKey = timeZone ?? 'local';
     const cached = DATE_TIME_FORMATTERS.get(cacheKey);
     if (cached) {
         return cached;
@@ -25,7 +23,7 @@ const getDateTimeFormatters = (timeZone?: string): DateTimeFormatterSet => {
         dayKeyFormatter: new Intl.DateTimeFormat('en-CA', {
             day: '2-digit',
             month: '2-digit',
-            timeZone: resolvedTimeZone,
+            timeZone,
             year: 'numeric',
         }),
         timePartsFormatter: new Intl.DateTimeFormat('en-US', {
@@ -34,7 +32,7 @@ const getDateTimeFormatters = (timeZone?: string): DateTimeFormatterSet => {
             hour12: true,
             minute: '2-digit',
             month: 'short',
-            timeZone: resolvedTimeZone,
+            timeZone,
             year: 'numeric',
         }),
     };

package/apps/ui/src/lib/grok-queries.ts

@@ -0,0 +1,22 @@
+import { queryOptions } from '@tanstack/react-query';
+import { getGrokSessionDetailFn, listGrokSessionsFn, listGrokWorkspacesFn } from './grok-server';
+
+export const grokWorkspacesQueryOptions = () =>
+    queryOptions({
+        queryFn: () => listGrokWorkspacesFn(),
+        queryKey: ['grok-workspaces'],
+    });
+
+export const grokSessionsQueryOptions = (workspaceKey: string | null) =>
+    queryOptions({
+        enabled: workspaceKey !== null,
+        queryFn: () => listGrokSessionsFn({ data: { workspaceKey: workspaceKey ?? '' } }),
+        queryKey: ['grok-sessions', workspaceKey ?? 'none'],
+    });
+
+export const grokSessionDetailQueryOptions = (sessionId: string | null) =>
+    queryOptions({
+        enabled: sessionId !== null,
+        queryFn: () => getGrokSessionDetailFn({ data: { sessionId: sessionId ?? '' } }),
+        queryKey: ['grok-session', sessionId ?? 'none'],
+    });