spiracha 2.0.0 → 2.1.0

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'],
+    });

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

@@ -0,0 +1,169 @@
+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 sessionSchema = z.object({
+    sessionId: z.string().min(1),
+});
+
+const exportSessionSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionId: z.string().min(1),
+    zipArchive: z.boolean().default(false),
+});
+
+const exportSessionsSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
+const deleteSessionsSchema = z.object({
+    sessionIds: z.array(z.string().min(1)).min(1),
+});
+
+export const listGrokWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
+    const { listGrokWorkspaceGroups } = await import('@spiracha/lib/grok-db');
+    return listGrokWorkspaceGroups();
+});
+
+export const listGrokSessionsFn = createServerFn({ method: 'GET' })
+    .validator(workspaceSchema)
+    .handler(async ({ data }) => {
+        const { listGrokSessionsForGroup } = await import('@spiracha/lib/grok-db');
+        return listGrokSessionsForGroup(data.workspaceKey);
+    });
+
+const loadGrokSessionTranscript = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
+    const { readGrokSessionTranscript, resolveGrokSessionsDir } = await import('@spiracha/lib/grok-db');
+    const sessionsDir = resolveGrokSessionsDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readGrokSessionTranscript(sessionsDir, sessionId, {
+                includeRawPayloads: false,
+            });
+            if (!transcript) {
+                throw new Error(`Grok session not found: ${sessionId}`);
+            }
+
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: sessionsDir,
+            source: 'grok-ui',
+        },
+    );
+};
+
+export const getGrokSessionDetailFn = createServerFn({ method: 'GET' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        return loadGrokSessionTranscript(data.sessionId);
+    });
+
+export const exportGrokSessionFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionSchema)
+    .handler(async ({ data }) => {
+        const { renderGrokTranscript } = await import('@spiracha/lib/grok-transcript');
+        const transcript = await loadGrokSessionTranscript(data.sessionId);
+        const content = renderGrokTranscript(transcript, {
+            includeCommentary: data.includeCommentary,
+            includeMetadata: data.includeMetadata,
+            includeTools: data.includeTools,
+            outputFormat: data.outputFormat,
+        });
+
+        if (!content) {
+            throw new Error(`Grok session has no exportable content: ${data.sessionId}`);
+        }
+
+        return renderSourceSessionDownload({
+            content,
+            cwd: transcript.session.cwd ?? transcript.session.worktree,
+            fallbackBaseName: 'grok-session',
+            outputFormat: data.outputFormat,
+            sessionId: transcript.session.sessionId,
+            updatedAtMs: transcript.session.lastActiveAtMs,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const exportGrokSessionsFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionsSchema)
+    .handler(async ({ data }) => {
+        const { renderGrokTranscript } = await import('@spiracha/lib/grok-transcript');
+        const entries = await Promise.all(
+            data.sessionIds.map(async (sessionId) => {
+                const transcript = await loadGrokSessionTranscript(sessionId);
+                const content = renderGrokTranscript(transcript, {
+                    includeCommentary: data.includeCommentary,
+                    includeMetadata: data.includeMetadata,
+                    includeTools: data.includeTools,
+                    outputFormat: data.outputFormat,
+                });
+
+                if (!content) {
+                    throw new Error(`Grok session has no exportable content: ${sessionId}`);
+                }
+
+                return {
+                    content,
+                    cwd: transcript.session.cwd ?? transcript.session.worktree,
+                    fallbackBaseName: 'grok-session',
+                    fileBaseName: transcript.session.title || transcript.session.sessionId,
+                    sessionId: transcript.session.sessionId,
+                    updatedAtMs: transcript.session.lastActiveAtMs,
+                };
+            }),
+        );
+
+        return renderSourceSessionsDownload({
+            entries,
+            fallbackBaseName: 'grok-sessions',
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const deleteGrokSessionFn = createServerFn({ method: 'POST' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        const { deleteGrokSession, resolveGrokSessionsDir } = await import('@spiracha/lib/grok-db');
+        const result = await deleteGrokSession(resolveGrokSessionsDir(), data.sessionId);
+        if (result.deletedSessionIds.length === 0) {
+            throw new Error(`Grok session not found: ${data.sessionId}`);
+        }
+
+        return result;
+    });
+
+export const deleteGrokSessionsFn = createServerFn({ method: 'POST' })
+    .validator(deleteSessionsSchema)
+    .handler(async ({ data }) => {
+        const { deleteGrokSession, resolveGrokSessionsDir } = await import('@spiracha/lib/grok-db');
+        const sessionsDir = resolveGrokSessionsDir();
+        const results = await Promise.all(
+            data.sessionIds.map((sessionId) => deleteGrokSession(sessionsDir, sessionId)),
+        );
+        const deletedSessionIds = results.flatMap((result) => result.deletedSessionIds);
+        if (deletedSessionIds.length === 0) {
+            throw new Error('No Grok sessions were deleted');
+        }
+
+        return {
+            deletedFiles: results.flatMap((result) => result.deletedFiles),
+            deletedSessionIds,
+        };
+    });

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

@@ -0,0 +1,149 @@
+import type { ThreadEvent, ThreadTranscriptStats } from '@spiracha/lib/codex-browser-types';
+import type { GrokSessionTranscript, GrokTranscriptEntry, GrokTranscriptPart } from '@spiracha/lib/grok-exporter-types';
+import { getFinalGrokAssistantTextPartIds, getGrokTextPartPhase } from '@spiracha/lib/grok-transcript-phase';
+import type { JsonValue } from '@spiracha/lib/shared';
+import { getThreadTranscriptStats } from './thread-transcript-stats';
+
+const buildRaw = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    eventType: string,
+): Record<string, JsonValue> => ({
+    entryId: entry.entryId,
+    eventType,
+    role: entry.role,
+    source: 'grok_local_session',
+    type: part.type,
+    ...part.raw,
+});
+
+const buildMessageEvent = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    sequence: number,
+    text: string,
+    finalTextPartIds: Set<string>,
+): ThreadEvent => ({
+    isHiddenByDefault: entry.role !== 'assistant' && entry.role !== 'user',
+    kind: 'message',
+    memoryCitation: null,
+    model: entry.modelId ?? null,
+    phase: getGrokTextPartPhase(entry, part, finalTextPartIds),
+    raw: buildRaw(entry, part, 'message'),
+    role: entry.role,
+    sequence,
+    text,
+    timestamp: entry.timestamp,
+    variant: entry.role === 'user' ? 'user_message' : entry.role === 'assistant' ? 'agent_message' : 'message',
+});
+
+const buildReasoningEvent = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    sequence: number,
+): ThreadEvent | null => {
+    const text = part.text?.trim();
+    if (!text) {
+        return null;
+    }
+
+    return {
+        content: text,
+        hasEncryptedContent: false,
+        kind: 'reasoning',
+        raw: buildRaw(entry, part, 'reasoning'),
+        sequence,
+        summary: [text],
+        timestamp: entry.timestamp,
+    };
+};
+
+const buildToolCallCommand = (part: GrokTranscriptPart): string => {
+    const toolName = part.toolName ?? 'unknown';
+    if (!part.argumentsText?.trim()) {
+        return toolName;
+    }
+
+    return `${toolName}\n${part.argumentsText}`;
+};
+
+const buildToolCallEvent = (entry: GrokTranscriptEntry, part: GrokTranscriptPart, sequence: number): ThreadEvent => ({
+    argumentsParseFailed: false,
+    argumentsText: part.argumentsText ?? null,
+    callId: part.toolCallId ?? null,
+    command: buildToolCallCommand(part),
+    kind: 'tool_call',
+    name: part.toolName ?? 'unknown',
+    raw: buildRaw(entry, part, 'tool_call'),
+    sequence,
+    timestamp: entry.timestamp,
+    workdir: null,
+});
+
+const buildToolOutputEvent = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    sequence: number,
+): ThreadEvent | null => {
+    const outputText = part.outputText?.trim();
+    if (!outputText) {
+        return null;
+    }
+
+    return {
+        callId: part.toolCallId ?? null,
+        exitCode: null,
+        kind: 'tool_output',
+        outputText,
+        raw: buildRaw(entry, part, 'tool_output'),
+        sequence,
+        summary: outputText,
+        timestamp: entry.timestamp,
+        wallTime: null,
+    };
+};
+
+const partToEvents = (
+    entry: GrokTranscriptEntry,
+    part: GrokTranscriptPart,
+    sequence: number,
+    finalTextPartIds: Set<string>,
+): ThreadEvent[] => {
+    if (part.type === 'text') {
+        const text = part.text?.trim();
+        return text ? [buildMessageEvent(entry, part, sequence, text, finalTextPartIds)] : [];
+    }
+
+    if (part.type === 'reasoning') {
+        const event = buildReasoningEvent(entry, part, sequence);
+        return event ? [event] : [];
+    }
+
+    if (part.type === 'tool_call') {
+        return [buildToolCallEvent(entry, part, sequence)];
+    }
+
+    if (part.type === 'tool_result') {
+        const event = buildToolOutputEvent(entry, part, sequence);
+        return event ? [event] : [];
+    }
+
+    return [];
+};
+
+export const grokTranscriptToThreadEvents = (transcript: GrokSessionTranscript): ThreadEvent[] => {
+    const finalTextPartIds = getFinalGrokAssistantTextPartIds(transcript.entries);
+    const events: ThreadEvent[] = [];
+    let sequence = 0;
+    for (const entry of transcript.entries) {
+        for (const part of entry.parts) {
+            events.push(...partToEvents(entry, part, sequence, finalTextPartIds));
+            sequence += 1;
+        }
+    }
+    return events;
+};
+
+export const getGrokThreadTranscriptStats = (events: ThreadEvent[]): ThreadTranscriptStats => {
+    return getThreadTranscriptStats(events);
+};

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

@@ -1,6 +1,6 @@
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
-import { renderSourceSessionDownload } from './source-session-export-server';
+import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
 
 const workspaceSchema = z.object({
     workspaceKey: z.string().min(1),
@@ -19,6 +19,19 @@ const exportSessionSchema = z.object({
     zipArchive: z.boolean().default(false),
 });
 
+const exportSessionsSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
+const deleteSessionsSchema = z.object({
+    sessionIds: z.array(z.string().min(1)).min(1),
+});
+
 export const listKiroWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
     const { listKiroWorkspaceGroups } = await import('@spiracha/lib/kiro-db');
     return listKiroWorkspaceGroups();
@@ -32,13 +45,24 @@ export const listKiroSessionsFn = createServerFn({ method: 'GET' })
     });
 
 const loadKiroSessionTranscript = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
     const { readKiroSessionTranscript, resolveKiroWorkspaceSessionsDir } = await import('@spiracha/lib/kiro-db');
-    const transcript = await readKiroSessionTranscript(resolveKiroWorkspaceSessionsDir(), sessionId);
-    if (!transcript) {
-        throw new Error(`Kiro session not found: ${sessionId}`);
-    }
+    const sessionsDir = resolveKiroWorkspaceSessionsDir();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readKiroSessionTranscript(sessionsDir, sessionId);
+            if (!transcript) {
+                throw new Error(`Kiro session not found: ${sessionId}`);
+            }
 
-    return transcript;
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: sessionsDir,
+            source: 'kiro-ui',
+        },
+    );
 };
 
 export const getKiroSessionDetailFn = createServerFn({ method: 'GET' })
@@ -65,9 +89,63 @@ export const exportKiroSessionFn = createServerFn({ method: 'POST' })
 
         return renderSourceSessionDownload({
             content,
+            cwd: transcript.session.workspacePath ?? transcript.session.worktree,
             fallbackBaseName: 'kiro-session',
-            fileBaseName: transcript.session.title || transcript.session.sessionId,
             outputFormat: data.outputFormat,
+            sessionId: transcript.session.sessionId,
+            updatedAtMs: transcript.session.lastActiveAtMs,
             zipArchive: data.zipArchive,
         });
     });
+
+export const exportKiroSessionsFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionsSchema)
+    .handler(async ({ data }) => {
+        const { renderKiroTranscript } = await import('@spiracha/lib/kiro-transcript');
+        const entries = await Promise.all(
+            data.sessionIds.map(async (sessionId) => {
+                const transcript = await loadKiroSessionTranscript(sessionId);
+                const content = renderKiroTranscript(transcript, {
+                    includeCommentary: data.includeCommentary,
+                    includeMetadata: data.includeMetadata,
+                    includeTools: data.includeTools,
+                    outputFormat: data.outputFormat,
+                });
+
+                if (!content) {
+                    throw new Error(`Kiro session has no exportable content: ${sessionId}`);
+                }
+
+                return {
+                    content,
+                    cwd: transcript.session.workspacePath ?? transcript.session.worktree,
+                    fallbackBaseName: 'kiro-session',
+                    fileBaseName: transcript.session.title || transcript.session.sessionId,
+                    sessionId: transcript.session.sessionId,
+                    updatedAtMs: transcript.session.lastActiveAtMs,
+                };
+            }),
+        );
+
+        return renderSourceSessionsDownload({
+            entries,
+            fallbackBaseName: 'kiro-sessions',
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const deleteKiroSessionFn = createServerFn({ method: 'POST' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        const { deleteKiroSession, resolveKiroWorkspaceSessionsDir } = await import('@spiracha/lib/kiro-db');
+        return deleteKiroSession(resolveKiroWorkspaceSessionsDir(), data.sessionId);
+    });
+
+export const deleteKiroSessionsFn = createServerFn({ method: 'POST' })
+    .validator(deleteSessionsSchema)
+    .handler(async ({ data }) => {
+        const { deleteKiroSession, resolveKiroWorkspaceSessionsDir } = await import('@spiracha/lib/kiro-db');
+        const sessionsDir = resolveKiroWorkspaceSessionsDir();
+        return Promise.all(data.sessionIds.map((sessionId) => deleteKiroSession(sessionsDir, sessionId)));
+    });

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

@@ -1,6 +1,6 @@
 import { createServerFn } from '@tanstack/react-start';
 import { z } from 'zod';
-import { renderSourceSessionDownload } from './source-session-export-server';
+import { renderSourceSessionDownload, renderSourceSessionsDownload } from './source-session-export-server';
 
 const workspaceSchema = z.object({
     workspaceKey: z.string().min(1),
@@ -19,6 +19,19 @@ const exportSessionSchema = z.object({
     zipArchive: z.boolean().default(false),
 });
 
+const exportSessionsSchema = z.object({
+    includeCommentary: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    includeTools: z.boolean().default(true),
+    outputFormat: z.enum(['md', 'txt']).default('md'),
+    sessionIds: z.array(z.string().min(1)).min(1),
+    zipArchive: z.boolean().default(true),
+});
+
+const deleteSessionsSchema = z.object({
+    sessionIds: z.array(z.string().min(1)).min(1),
+});
+
 export const listOpenCodeWorkspacesFn = createServerFn({ method: 'GET' }).handler(async () => {
     const { listOpenCodeWorkspaceGroups } = await import('@spiracha/lib/opencode-db');
     return listOpenCodeWorkspaceGroups();
@@ -32,13 +45,24 @@ export const listOpenCodeSessionsFn = createServerFn({ method: 'GET' })
     });
 
 const loadOpenCodeSessionTranscript = async (sessionId: string) => {
+    const { runWithTranscriptLoadLimit } = await import('@spiracha/lib/transcript-load-limiter');
     const { readOpenCodeSessionTranscript, resolveOpenCodeDbPath } = await import('@spiracha/lib/opencode-db');
-    const transcript = await readOpenCodeSessionTranscript(resolveOpenCodeDbPath(), sessionId);
-    if (!transcript) {
-        throw new Error(`OpenCode session not found: ${sessionId}`);
-    }
+    const dbPath = resolveOpenCodeDbPath();
+    return runWithTranscriptLoadLimit(
+        async () => {
+            const transcript = await readOpenCodeSessionTranscript(dbPath, sessionId);
+            if (!transcript) {
+                throw new Error(`OpenCode session not found: ${sessionId}`);
+            }
 
-    return transcript;
+            return transcript;
+        },
+        {
+            id: sessionId,
+            path: dbPath,
+            source: 'opencode-ui',
+        },
+    );
 };
 
 export const getOpenCodeSessionDetailFn = createServerFn({ method: 'GET' })
@@ -65,9 +89,63 @@ export const exportOpenCodeSessionFn = createServerFn({ method: 'POST' })
 
         return renderSourceSessionDownload({
             content,
+            cwd: transcript.session.worktree,
             fallbackBaseName: 'opencode-session',
-            fileBaseName: transcript.session.title || transcript.session.slug || transcript.session.sessionId,
             outputFormat: data.outputFormat,
+            sessionId: transcript.session.sessionId,
+            updatedAtMs: transcript.session.lastUpdatedAtMs,
             zipArchive: data.zipArchive,
         });
     });
+
+export const exportOpenCodeSessionsFn = createServerFn({ method: 'POST' })
+    .validator(exportSessionsSchema)
+    .handler(async ({ data }) => {
+        const { renderOpenCodeTranscript } = await import('@spiracha/lib/opencode-transcript');
+        const entries = await Promise.all(
+            data.sessionIds.map(async (sessionId) => {
+                const transcript = await loadOpenCodeSessionTranscript(sessionId);
+                const content = renderOpenCodeTranscript(transcript, {
+                    includeCommentary: data.includeCommentary,
+                    includeMetadata: data.includeMetadata,
+                    includeTools: data.includeTools,
+                    outputFormat: data.outputFormat,
+                });
+
+                if (!content) {
+                    throw new Error(`OpenCode session has no exportable content: ${sessionId}`);
+                }
+
+                return {
+                    content,
+                    cwd: transcript.session.worktree,
+                    fallbackBaseName: 'opencode-session',
+                    fileBaseName: transcript.session.title || transcript.session.slug || transcript.session.sessionId,
+                    sessionId: transcript.session.sessionId,
+                    updatedAtMs: transcript.session.lastUpdatedAtMs,
+                };
+            }),
+        );
+
+        return renderSourceSessionsDownload({
+            entries,
+            fallbackBaseName: 'opencode-sessions',
+            outputFormat: data.outputFormat,
+            zipArchive: data.zipArchive,
+        });
+    });
+
+export const deleteOpenCodeSessionFn = createServerFn({ method: 'POST' })
+    .validator(sessionSchema)
+    .handler(async ({ data }) => {
+        const { deleteOpenCodeSession, resolveOpenCodeDbPath } = await import('@spiracha/lib/opencode-db');
+        return deleteOpenCodeSession(resolveOpenCodeDbPath(), data.sessionId);
+    });
+
+export const deleteOpenCodeSessionsFn = createServerFn({ method: 'POST' })
+    .validator(deleteSessionsSchema)
+    .handler(async ({ data }) => {
+        const { deleteOpenCodeSession, resolveOpenCodeDbPath } = await import('@spiracha/lib/opencode-db');
+        const dbPath = resolveOpenCodeDbPath();
+        return Promise.all(data.sessionIds.map((sessionId) => deleteOpenCodeSession(dbPath, sessionId)));
+    });