spiracha 1.1.2 → 1.3.0

package/src/lib/codex-exporter-transcript.ts

@@ -40,16 +40,16 @@ export const convertSessionFile = async (target: ExportTarget, options: CodexCli
         return null;
     }
 
-    if (options.optimized) {
-        return transcriptState.sections.join('\n\n').trimEnd() + '\n';
-    }
-
     const title = getTitle(target, transcriptState.sessionMeta);
-    const metadata = buildMetadataEntries(target, transcriptState.sessionMeta, options);
     const parts = [
         renderDocumentTitle(title, options.outputFormat),
         '',
-        renderMetadataBlock(metadata, options.outputFormat),
+        options.includeMetadata
+            ? renderMetadataBlock(
+                  buildMetadataEntries(target, transcriptState.sessionMeta, options),
+                  options.outputFormat,
+              )
+            : '',
         ...transcriptState.sections,
     ].filter(Boolean);
     return parts.join('\n').trimEnd() + '\n';
@@ -69,7 +69,6 @@ export const writeSessionFileExport = async (
         assistantModel: target.thread?.model ?? null,
         sections: [],
         sessionMeta: {},
-        startedTranscript: false,
     };
     let wroteSection = false;
 
@@ -82,7 +81,7 @@ export const writeSessionFileExport = async (
                 continue;
             }
 
-            transcriptStream.write(transform(wroteSection ? `${getSectionSeparator(options)}${block}` : block));
+            transcriptStream.write(transform(wroteSection ? `${getSectionSeparator()}${block}` : block));
             wroteSection = true;
         }
         await finalizeExportWriteStream(transcriptStream);
@@ -124,7 +123,6 @@ type CodexTranscriptState = {
     assistantModel: string | null;
     sessionMeta: SessionMeta;
     sections: string[];
-    startedTranscript: boolean;
 };
 
 const collectCodexTranscript = async (
@@ -136,7 +134,6 @@ const collectCodexTranscript = async (
         assistantModel,
         sections: [],
         sessionMeta: {},
-        startedTranscript: false,
     };
 
     for await (const parsed of readJsonlObjects(sessionFile)) {
@@ -146,9 +143,7 @@ const collectCodexTranscript = async (
     return state;
 };
 
-const getSectionSeparator = (options: CodexCliOptions) => {
-    return options.optimized ? '\n\n' : '\n';
-};
+const getSectionSeparator = () => '\n';
 
 const processCodexTranscriptRecord = (
     parsed: Record<string, JsonValue>,
@@ -181,58 +176,23 @@ const renderCodexTranscriptRecord = (
         return '';
     }
 
-    return options.optimized
-        ? renderCompactToolBlock(tool, options.outputFormat)
-        : renderToolBlock(tool, options.outputFormat);
+    return renderToolBlock(tool, options.outputFormat);
 };
 
 const processCodexMessageRecord = (message: MessageRecord, options: CodexCliOptions, state: CodexTranscriptState) => {
-    if (options.optimized) {
-        return processOptimizedCodexMessageRecord(message, options, state);
-    }
-
     return renderMessageBlock(message, options.outputFormat, state.assistantModel, options.includeCommentary);
 };
 
-const processOptimizedCodexMessageRecord = (
-    message: MessageRecord,
-    options: CodexCliOptions,
-    state: CodexTranscriptState,
-) => {
-    if (message.role !== 'user' && message.role !== 'assistant') {
-        return '';
-    }
-
-    if (message.role === 'assistant' && message.phase === 'commentary' && !options.includeCommentary) {
-        return '';
-    }
-
-    const compact = compactMessageText(message, true);
-    if (!compact) {
-        return '';
-    }
-
-    if (!state.startedTranscript) {
-        if (shouldSkipOptimizedPrelude(message.role, compact)) {
-            return '';
-        }
-        state.startedTranscript = true;
-    }
-
-    return renderCompactBlock(message, compact, options.outputFormat, state.assistantModel);
-};
-
 const buildStreamExportPrefix = (target: ExportTarget, sessionMeta: SessionMeta, options: CodexCliOptions) => {
-    if (options.optimized) {
+    if (!options.includeMetadata) {
         return '';
     }
 
     const title = getTitle(target, sessionMeta);
-    const metadata = buildMetadataEntries(target, sessionMeta, options);
     const parts = [
         renderDocumentTitle(title, options.outputFormat),
         '',
-        renderMetadataBlock(metadata, options.outputFormat),
+        renderMetadataBlock(buildMetadataEntries(target, sessionMeta, options), options.outputFormat),
     ]
         .filter(Boolean)
         .join('\n');
@@ -240,13 +200,6 @@ const buildStreamExportPrefix = (target: ExportTarget, sessionMeta: SessionMeta,
     return `${parts}\n`;
 };
 
-export const compactMessageText = (message: MessageRecord, optimized: boolean): string => {
-    const rawText = extractText(message.content);
-    const cleaned = stripPreviewBlock(rawText);
-
-    return optimized ? optimizePlainText(optimizeRenderedText(cleaned)) : cleaned.trim();
-};
-
 export const formatToolOutputSummary = (outputText: string, outputFormat: ExportFormat): string => {
     if (!outputText) {
         return '';
@@ -308,27 +261,6 @@ const getTitle = (target: ExportTarget, sessionMeta: SessionMeta): string => {
     return sessionMeta.id ?? path.basename(target.sessionFile, '.jsonl');
 };
 
-const shouldSkipOptimizedPrelude = (role: string, text: string): boolean => {
-    if (role !== 'user') {
-        return true;
-    }
-
-    return (
-        text.startsWith('AGENTS.md instructions for ') ||
-        text.startsWith('# AGENTS.md instructions for ') ||
-        text.startsWith('<permissions instructions>') ||
-        text.startsWith('<environment_context>') ||
-        text.startsWith('<app-context>') ||
-        text.startsWith('<collaboration_mode>') ||
-        text.startsWith('<skills_instructions>') ||
-        text.startsWith('You are Codex, a coding agent based on GPT-5.') ||
-        text.startsWith('Read this before making changes.') ||
-        text.includes('Filesystem sandboxing defines which files can be read or written.') ||
-        text.includes('approval_policy') ||
-        text.includes('base_instructions')
-    );
-};
-
 const buildMetadataEntries = (
     target: ExportTarget,
     sessionMeta: SessionMeta,
@@ -585,7 +517,7 @@ const renderMessageBlock = (
         return '';
     }
 
-    const text = cleanExtractedText(extractText(message.content)).trim();
+    const text = cleanExtractedText(stripPreviewBlock(extractText(message.content))).trim();
     if (!text || shouldSkipMessage(message.role, text)) {
         return '';
     }
@@ -606,36 +538,6 @@ const renderToolBlock = (tool: ToolRecord, outputFormat: ExportFormat): string =
     return summary ? renderSection('Tool Output', summary, outputFormat) : '';
 };
 
-const renderCompactBlock = (
-    message: MessageRecord,
-    text: string,
-    outputFormat: ExportFormat,
-    assistantModel: string | null,
-): string => {
-    const prefix = message.role === 'user' ? 'U:' : `${formatModelLabel(message.model ?? assistantModel)}:`;
-    const lines = text.split('\n');
-    const [firstLine, ...rest] = lines;
-
-    if (rest.length === 0) {
-        return `${prefix} ${normalizeCompactLiteral(firstLine, outputFormat)}`;
-    }
-
-    return [
-        `${prefix} ${normalizeCompactLiteral(firstLine, outputFormat)}`,
-        ...rest.map((line) => normalizeCompactLiteral(line, outputFormat)),
-    ].join('\n');
-};
-
-const renderCompactToolBlock = (tool: ToolRecord, outputFormat: ExportFormat): string => {
-    if (tool.kind === 'call') {
-        const details = formatCompactToolCall(tool, outputFormat);
-        return details ? `T: ${details}` : '';
-    }
-
-    const summary = formatCompactToolOutput(tool.outputText ?? '');
-    return summary ? `R: ${summary}` : '';
-};
-
 const stripPreviewBlock = (text: string): string => {
     const parts = text
         .split(/\n{2,}/)
@@ -662,49 +564,15 @@ const stripPreviewBlock = (text: string): string => {
     return parts.slice(1).join('\n\n');
 };
 
-const optimizeRenderedText = (text: string): string => {
-    return text
-        .replace(/^\*Phase:\s+`[^`]+`\*\s*\n*/gm, '')
-        .replace(/^\s*<image\b[^>]*>\s*$/gim, '')
-        .replace(/^\s*<\/image>\s*$/gim, '')
-        .replace(/^\s*\[Image attached\]\s*$/gim, '')
-        .replace(/^#{1,6}\s+/gm, '')
-        .replace(/^```[^\n]*\n?/gm, '')
-        .replace(/\n```$/gm, '')
-        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
-        .replace(/^##\s+User\s*$/gm, 'User:')
-        .replace(/^##\s+Assistant\s*$/gm, 'Assistant:')
-        .replace(/`([^`]+)`/g, '$1')
-        .replace(/\*\*([^*]+)\*\*/g, '$1')
-        .replace(/\*([^*\n]+)\*/g, '$1')
-        .replace(/\n{3,}/g, '\n\n')
-        .trim();
-};
-
-const optimizePlainText = (text: string): string => {
-    const normalized = text
-        .replace(/\r/g, '')
-        .replace(/^\s*<image\b[^>]*>\s*$/gim, '')
-        .replace(/^\s*<\/image>\s*$/gim, '')
-        .replace(/^\s*\[Image attached\]\s*$/gim, '')
-        .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
-        .replace(/`([^`]+)`/g, '$1')
-        .replace(/\*\*([^*]+)\*\*/g, '$1')
-        .replace(/\*([^*\n]+)\*/g, '$1');
-
-    return normalized
-        .split('\n')
-        .map((line) => line.replace(/[ \t]+$/g, ''))
-        .join('\n')
-        .replace(/\n{3,}/g, '\n\n')
-        .trim();
-};
-
 const shouldSkipMessage = (role: string, text: string): boolean => {
     if (text.startsWith('<environment_context>')) {
         return true;
     }
 
+    if (text.startsWith('AGENTS.md instructions for ')) {
+        return true;
+    }
+
     if (text.startsWith('# AGENTS.md instructions for ')) {
         return true;
     }
@@ -725,44 +593,6 @@ const formatToolCallDetails = (tool: ToolRecord, outputFormat: ExportFormat): st
     return details.cmd ? `Command: ${formatInlineLiteral(details.cmd, outputFormat)}` : '';
 };
 
-const formatCompactToolCall = (tool: ToolRecord, outputFormat: ExportFormat): string => {
-    if (tool.name === 'exec_command') {
-        const details = parseExecCommandArguments(tool.argumentsText);
-        if (!details.cmd) {
-            return 'exec_command';
-        }
-
-        const command = formatInlineLiteral(details.cmd, outputFormat);
-        return details.workdir ? `exec_command ${command} @ ${details.workdir}` : `exec_command ${command}`;
-    }
-
-    return tool.callId ? `${tool.name} (${tool.callId})` : tool.name;
-};
-
-const formatCompactToolOutput = (outputText: string): string => {
-    if (!outputText) {
-        return '';
-    }
-
-    const lines = outputText
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean);
-
-    const exit = lines.find((line) => line.startsWith('Process exited with code '));
-    const wall = lines.find((line) => line.startsWith('Wall time: '));
-
-    if (exit && wall) {
-        return `${exit.replace('Process ', '')}; ${wall.toLowerCase()}`;
-    }
-
-    if (exit) {
-        return exit.replace('Process ', '');
-    }
-
-    return '';
-};
-
 const extractText = (content: JsonValue): string => {
     if (typeof content === 'string') {
         return content;
@@ -802,7 +632,3 @@ const extractContentPart = (value: JsonValue): string => {
 
     return text ?? '';
 };
-
-const normalizeCompactLiteral = (value: string, outputFormat: ExportFormat): string => {
-    return outputFormat === 'md' ? value : value.replace(/`([^`]+)`/g, '$1');
-};

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

@@ -9,7 +9,7 @@ export type CodexCliOptions = {
     cwdFilter: string | null;
     projectFilter: string | null;
     threadIds: string[];
-    optimized: boolean;
+    includeMetadata: boolean;
     includeCommentary: boolean;
     includeTools: boolean;
     outputFormat: ExportFormat;

package/src/lib/codex-exporter.ts

@@ -27,7 +27,6 @@ export {
     toOutputRelativePath,
 } from './codex-exporter-db';
 export {
-    compactMessageText,
     convertSessionFile,
     formatToolOutputSummary,
     parseExecCommandArguments,

package/src/lib/codex-thread-recovery.ts

@@ -0,0 +1,202 @@
+import { Database } from 'bun:sqlite';
+import { copyFile, utimes } from 'node:fs/promises';
+import path from 'node:path';
+import type { RecoverProjectThreadsResult } from './codex-browser-types';
+import { getPortablePathBasename } from './shared';
+import { runWithSqliteRetry } from './sqlite-retry';
+
+type RecoveryThreadRow = {
+    cwd: string;
+    id: string;
+    rollout_path: string;
+    thread_source: string | null;
+};
+
+type GlobalState = {
+    'active-workspace-roots'?: string[];
+    'electron-saved-workspace-roots'?: string[];
+    'project-order'?: string[];
+};
+
+const backupFile = async (filePath: string, label: string) => {
+    const stamp = new Date()
+        .toISOString()
+        .replaceAll(':', '')
+        .replace(/\.\d{3}Z$/, 'Z')
+        .replace('T', '-');
+    const backupPath = `${filePath}.bak-${label}-${stamp}`;
+    await copyFile(filePath, backupPath);
+    return backupPath;
+};
+
+const resolveCodexDirFromDbPath = (dbPath: string) => {
+    const dbDir = path.dirname(dbPath);
+    return path.basename(dbDir) === 'sqlite' ? path.dirname(dbDir) : dbDir;
+};
+
+const assertRequiredStatePath = async (filePath: string) => {
+    if (!(await Bun.file(filePath).exists())) {
+        throw new Error(`Required Codex state file not found: ${filePath}`);
+    }
+};
+
+const readGlobalState = async (globalStatePath: string) => {
+    return (await Bun.file(globalStatePath).json()) as GlobalState;
+};
+
+const writeGlobalState = async (globalStatePath: string, state: GlobalState) => {
+    await Bun.write(globalStatePath, JSON.stringify(state));
+};
+
+const updateGlobalRoots = (state: GlobalState, projectCwds: string[]) => {
+    const savedRoots = state['electron-saved-workspace-roots'] ?? [];
+    const projectOrder = state['project-order'] ?? [];
+    const missingSaved = projectCwds.filter((cwd) => !savedRoots.includes(cwd));
+    const missingProjectOrder = projectCwds.filter((cwd) => !projectOrder.includes(cwd));
+
+    if (missingSaved.length === 0 && missingProjectOrder.length === 0) {
+        return {
+            projectRootsAdded: 0,
+            savedRootsAdded: 0,
+            state,
+        };
+    }
+
+    state['electron-saved-workspace-roots'] = [...savedRoots, ...missingSaved];
+    state['project-order'] = [...projectOrder, ...missingProjectOrder];
+
+    return {
+        projectRootsAdded: missingProjectOrder.length,
+        savedRootsAdded: missingSaved.length,
+        state,
+    };
+};
+
+const getProjectTopLevelThreads = (db: Database, projectName: string): RecoveryThreadRow[] => {
+    const threads = db
+        .query('SELECT id, cwd, rollout_path, thread_source FROM threads WHERE archived = 0')
+        .all() as RecoveryThreadRow[];
+    return threads.filter((thread) => {
+        return getPortablePathBasename(thread.cwd) === projectName && thread.thread_source !== 'subagent';
+    });
+};
+
+const refreshThreadRows = (db: Database, threadIds: string[]) => {
+    if (threadIds.length === 0) {
+        return 0;
+    }
+
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    const nowMs = Date.now();
+    const placeholders = threadIds.map(() => '?').join(', ');
+    const statement = db.prepare(`
+        UPDATE threads
+        SET updated_at = ?1,
+            updated_at_ms = ?2,
+            has_user_event = 1
+        WHERE id IN (${placeholders})
+    `);
+    const result = statement.run(nowSeconds, nowMs, ...threadIds);
+    return Number(result.changes);
+};
+
+const refreshSessionIndex = async (sessionIndexPath: string, threadIds: string[]) => {
+    if (threadIds.length === 0) {
+        return 0;
+    }
+
+    const now = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+    const threadIdSet = new Set(threadIds);
+    const lines = (await Bun.file(sessionIndexPath).text()).split('\n');
+    let updated = 0;
+    const rewrittenLines: string[] = [];
+
+    for (const line of lines) {
+        if (!line.trim()) {
+            continue;
+        }
+
+        const parsed = JSON.parse(line) as { id?: string; updated_at?: string };
+        if (parsed.id && threadIdSet.has(parsed.id)) {
+            parsed.updated_at = now;
+            updated += 1;
+        }
+
+        rewrittenLines.push(JSON.stringify(parsed));
+    }
+
+    await Bun.write(sessionIndexPath, `${rewrittenLines.join('\n')}\n`);
+    return updated;
+};
+
+const touchRolloutFiles = async (codexDir: string, rolloutPaths: string[]) => {
+    const now = new Date();
+    let touched = 0;
+
+    for (const rolloutPath of rolloutPaths) {
+        const absolutePath = path.isAbsolute(rolloutPath) ? rolloutPath : path.join(codexDir, rolloutPath);
+        if (!(await Bun.file(absolutePath).exists())) {
+            continue;
+        }
+
+        await utimes(absolutePath, now, now);
+        touched += 1;
+    }
+
+    return touched;
+};
+
+export const recoverCodexProjectThreads = async (
+    dbPath: string,
+    projectName: string,
+): Promise<RecoverProjectThreadsResult> => {
+    const codexDir = resolveCodexDirFromDbPath(dbPath);
+    const globalStatePath = path.join(codexDir, '.codex-global-state.json');
+    const sessionIndexPath = path.join(codexDir, 'session_index.jsonl');
+
+    await assertRequiredStatePath(dbPath);
+    await assertRequiredStatePath(globalStatePath);
+    await assertRequiredStatePath(sessionIndexPath);
+
+    const backups = {
+        globalState: await backupFile(globalStatePath, 'recover-project-roots'),
+        sessionIndex: await backupFile(sessionIndexPath, 'recover-project-session-index'),
+        stateDb: await backupFile(dbPath, 'recover-project-threads'),
+    };
+
+    const globalState = await readGlobalState(globalStatePath);
+    const db = runWithSqliteRetry({
+        action: () => {
+            const opened = new Database(dbPath);
+            opened.exec('PRAGMA busy_timeout = 5000');
+            return opened;
+        },
+    });
+
+    try {
+        const topLevelThreads = getProjectTopLevelThreads(db, projectName);
+        const projectCwds = [...new Set(topLevelThreads.map((thread) => thread.cwd))];
+        const rootUpdateResult = updateGlobalRoots(globalState, projectCwds);
+        await writeGlobalState(globalStatePath, rootUpdateResult.state);
+
+        const threadIds = topLevelThreads.map((thread) => thread.id);
+        const rolloutPaths = topLevelThreads.map((thread) => thread.rollout_path);
+        const threadDbRowsUpdated = refreshThreadRows(db, threadIds);
+        const sessionIndexRowsUpdated = await refreshSessionIndex(sessionIndexPath, threadIds);
+        const rolloutFilesTouched = await touchRolloutFiles(codexDir, rolloutPaths);
+
+        return {
+            backups,
+            projectName,
+            projectRootsAdded: rootUpdateResult.projectRootsAdded,
+            resolvedCwds: projectCwds,
+            rolloutFilesTouched,
+            savedRootsAdded: rootUpdateResult.savedRootsAdded,
+            sessionIndexRowsUpdated,
+            threadDbRowsUpdated,
+            topLevelThreadsFound: threadIds.length,
+        };
+    } finally {
+        db.close();
+    }
+};