spiracha 1.4.0 → 2.0.0

package/src/lib/native-open.ts

@@ -1,54 +0,0 @@
-type NativeOpenTarget = {
-    kind: 'path' | 'url';
-    value: string;
-};
-
-const resolveNativeOpenCommand = () => {
-    if (process.platform === 'darwin') {
-        return {
-            argv: (target: NativeOpenTarget) => ['open', target.value],
-            label: 'open',
-        };
-    }
-
-    if (process.platform === 'win32') {
-        return {
-            argv: (target: NativeOpenTarget) => ['cmd', '/c', 'start', '', target.value],
-            label: 'start',
-        };
-    }
-
-    return {
-        argv: (target: NativeOpenTarget) => ['xdg-open', target.value],
-        label: 'xdg-open',
-    };
-};
-
-const openNatively = async (target: NativeOpenTarget) => {
-    const command = resolveNativeOpenCommand();
-    const proc = Bun.spawn(command.argv(target), {
-        stderr: 'pipe',
-        stdout: 'ignore',
-    });
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-        const errorText = await new Response(proc.stderr).text();
-        throw new Error(
-            `Failed to open ${target.value} with ${command.label}: ${errorText.trim() || `exit code ${exitCode}`}`,
-        );
-    }
-};
-
-export const openPathNatively = async (targetPath: string) => {
-    await openNatively({
-        kind: 'path',
-        value: targetPath,
-    });
-};
-
-export const openUrlNatively = async (url: string) => {
-    await openNatively({
-        kind: 'url',
-        value: url,
-    });
-};

package/src/mcp-server.ts

@@ -1,137 +0,0 @@
-#!/usr/bin/env bun
-
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import type { AnySchema } from '@modelcontextprotocol/sdk/server/zod-compat.js';
-import { z } from 'zod';
-import { runClaudeExport } from './lib/claude-exporter';
-import {
-    DEFAULT_DB_PATH,
-    DEFAULT_INPUT_DIR,
-    parseThreadSelectionArg,
-    resolveDefaultOutputDir,
-    runCodexExport,
-} from './lib/codex-exporter';
-import { expandHome } from './lib/shared';
-
-const server = new McpServer({
-    name: 'codex-chats-export',
-    version: '0.1.0',
-});
-
-const exportCodexChatsInputSchema = {
-    cwd: z.string().optional().describe('Optional exact cwd filter'),
-    dbPath: z.string().optional().describe('Optional override for the Codex SQLite database'),
-    deeplinks: z.array(z.string()).optional().describe('Optional Codex deeplinks like codex://threads/<thread-id>'),
-    flat: z.boolean().optional().describe('Write output into a single flat folder'),
-    includeMetadata: z.boolean().optional().describe('Include the chat metadata section at the top of each export'),
-    includeTools: z.boolean().optional().describe('Include exec_command tool logs'),
-    inputDir: z.string().optional().describe('Optional override for the Codex sessions directory'),
-    outputDir: z.string().optional().describe('Optional output directory'),
-    outputFormat: z.enum(['md', 'txt']).optional().describe('Output format'),
-    project: z.string().optional().describe('Optional project name matched against path basename'),
-} as unknown as Record<string, AnySchema>;
-
-const exportClaudeTranscriptInputSchema = {
-    includeTools: z.boolean().optional().describe('Include Bash tool calls and outputs'),
-    inputPath: z.string().describe('Path to a Claude transcript .jsonl file or export directory'),
-    outputFormat: z.enum(['md', 'txt']).optional().describe('Output format'),
-    outputPath: z.string().optional().describe('Optional output file path or directory'),
-} as unknown as Record<string, AnySchema>;
-
-server.registerTool(
-    'export_codex_chats',
-    {
-        description: 'Export Codex chats by deeplink, project name, or cwd to markdown or plain text.',
-        inputSchema: exportCodexChatsInputSchema,
-    },
-    async (args: any) => {
-        const threadIds = parseThreadSelections(args.deeplinks ?? []);
-        const cwdFilter = args.cwd ? expandHome(args.cwd) : null;
-
-        if (threadIds.length === 0 && !args.project && !cwdFilter) {
-            throw new Error(
-                'Provide at least one deeplink, project, or cwd filter to avoid exporting the entire Codex history by accident.',
-            );
-        }
-
-        const result = await runCodexExport({
-            cwdFilter,
-            dbPath: expandHome(args.dbPath ?? DEFAULT_DB_PATH),
-            flat: args.flat ?? false,
-            includeCommentary: true,
-            includeMetadata: args.includeMetadata ?? true,
-            includeTools: args.includeTools ?? false,
-            inputDir: expandHome(args.inputDir ?? DEFAULT_INPUT_DIR),
-            outputDir: args.outputDir ? expandHome(args.outputDir) : resolveDefaultOutputDir(cwdFilter),
-            outputFormat: args.outputFormat ?? 'md',
-            projectFilter: args.project ?? null,
-            threadIds,
-        });
-
-        return {
-            content: [
-                {
-                    text: JSON.stringify(
-                        {
-                            exportedCount: result.exportedCount,
-                            files: result.files,
-                            missingThreadIds: result.missingThreadIds,
-                            outputDir: result.outputDir,
-                        },
-                        null,
-                        2,
-                    ),
-                    type: 'text',
-                },
-            ],
-        };
-    },
-);
-
-server.registerTool(
-    'export_claude_transcript',
-    {
-        description: 'Export a Claude Code transcript JSONL or export directory to markdown or plain text.',
-        inputSchema: exportClaudeTranscriptInputSchema,
-    },
-    async (args: any) => {
-        const result = await runClaudeExport({
-            includeTools: args.includeTools ?? false,
-            inputPath: expandHome(args.inputPath),
-            outputFormat: args.outputFormat ?? 'md',
-            outputPath: args.outputPath ? expandHome(args.outputPath) : null,
-        });
-
-        return {
-            content: [
-                {
-                    text: JSON.stringify(result, null, 2),
-                    type: 'text',
-                },
-            ],
-        };
-    },
-);
-
-const main = async () => {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-};
-
-const parseThreadSelections = (deeplinks: string[]): string[] => {
-    return deeplinks.map((deeplink) => {
-        const threadId = parseThreadSelectionArg(deeplink);
-        if (!threadId) {
-            throw new Error(`Invalid Codex deeplink: ${deeplink}. Expected codex://threads/<thread-id>`);
-        }
-
-        return threadId;
-    });
-};
-
-main().catch((error) => {
-    const message = error instanceof Error ? error.message : String(error);
-    console.error(message);
-    process.exit(1);
-});

package/src/spiracha.ts

@@ -1,116 +0,0 @@
-#!/usr/bin/env bun
-
-type SpirachaCommandKind = 'codex' | 'claude' | 'cursor' | 'help' | 'ui' | 'version';
-
-type SpirachaInvocation = {
-    kind: SpirachaCommandKind;
-    argv: string[];
-};
-
-export const resolveSpirachaInvocation = (argv: string[]): SpirachaInvocation => {
-    const [firstArg, ...rest] = argv;
-
-    if (firstArg === 'claude') {
-        return { argv: rest, kind: 'claude' };
-    }
-
-    if (firstArg === 'codex') {
-        return { argv: rest, kind: 'codex' };
-    }
-
-    if (firstArg === 'cursor') {
-        return { argv: rest, kind: 'cursor' };
-    }
-
-    if (firstArg === 'ui') {
-        return { argv: rest, kind: 'ui' };
-    }
-
-    if (firstArg === '--help' || firstArg === '-h' || firstArg === 'help') {
-        return { argv: [], kind: 'help' };
-    }
-
-    if (firstArg === '--version' || firstArg === '-v' || firstArg === 'version') {
-        return { argv: [], kind: 'version' };
-    }
-
-    return { argv, kind: 'codex' };
-};
-
-export const readSpirachaPackageVersion = async (): Promise<string> => {
-    const manifest = (await Bun.file(new URL('../package.json', import.meta.url)).json()) as { version?: unknown };
-    if (typeof manifest.version !== 'string' || !manifest.version) {
-        throw new Error('Unable to read Spiracha version from package.json.');
-    }
-
-    return manifest.version;
-};
-
-export const getSpirachaHelpText = (): string => {
-    return [
-        'spiracha - export local assistant transcripts and browse local history',
-        '',
-        'Usage:',
-        '  spiracha',
-        '  spiracha codex [Codex options]',
-        '  spiracha claude [Claude options]',
-        '  spiracha cursor [Cursor options]',
-        '  spiracha ui [UI options]',
-        '',
-        'Commands:',
-        '  codex   Export Codex chats (default when no subcommand is provided)',
-        '  claude  Export a Claude transcript file or export directory',
-        '  cursor  Export, recover, and prune local Cursor Agent/Composer threads',
-        '  ui      Launch the local browser UI for Codex, Cursor, and Antigravity history',
-        '',
-        'Aliases:',
-        '  codex-chats',
-        '  codex-chats-claude',
-        '',
-        'For command-specific help:',
-        '  spiracha codex --help',
-        '  spiracha claude --help',
-        '  spiracha cursor --help',
-        '  spiracha ui --help',
-        '  spiracha --version',
-    ].join('\n');
-};
-
-export const runSpirachaCli = async (argv = process.argv.slice(2)): Promise<void> => {
-    const invocation = resolveSpirachaInvocation(argv);
-
-    if (invocation.kind === 'help') {
-        console.log(getSpirachaHelpText());
-        return;
-    }
-
-    if (invocation.kind === 'version') {
-        console.log(await readSpirachaPackageVersion());
-        return;
-    }
-
-    if (invocation.kind === 'claude') {
-        const { runExportClaudeCli } = await import('./export-claude');
-        await runExportClaudeCli(invocation.argv);
-        return;
-    }
-
-    if (invocation.kind === 'cursor') {
-        const { runExportCursorCli } = await import('./export-cursor');
-        await runExportCursorCli(invocation.argv);
-        return;
-    }
-
-    if (invocation.kind === 'ui') {
-        const { runUiCli } = await import('./ui-cli');
-        await runUiCli(invocation.argv);
-        return;
-    }
-
-    const { runExportChatsCli } = await import('./export-chats');
-    await runExportChatsCli(invocation.argv);
-};
-
-if (import.meta.main) {
-    await runSpirachaCli();
-}

package/src/ui-cli.ts

@@ -1,310 +0,0 @@
-#!/usr/bin/env bun
-
-import { access, constants } from 'node:fs/promises';
-import path from 'node:path';
-import { openUrlNatively } from './lib/native-open';
-import { CliUsageError } from './lib/shared';
-import {
-    buildUiExportContentDisposition,
-    ensureUiExportDir,
-    resolveUiExportFilePathFromRequestPath,
-} from './lib/ui-export-files';
-
-type UiCliOptions = {
-    dbPath: string | null;
-    host: string;
-    openBrowser: boolean;
-    port: number;
-};
-
-const DEFAULT_UI_HOST = '127.0.0.1';
-const DEFAULT_UI_PORT = 3000;
-const MAX_PORT_ATTEMPTS = 10;
-
-const resolveUiDistPaths = () => {
-    const distRoot = path.resolve(import.meta.dir, '..', 'apps', 'ui', 'dist');
-    return {
-        clientDir: path.join(distRoot, 'client'),
-        serverEntryPath: path.join(distRoot, 'server', 'server.js'),
-    };
-};
-
-const ensureUiBuildExists = async () => {
-    const { clientDir, serverEntryPath } = resolveUiDistPaths();
-    const serverEntry = Bun.file(serverEntryPath);
-    const clientAssetExists = await Bun.file(path.join(clientDir, 'icon.svg')).exists();
-    const serverEntryExists = await serverEntry.exists();
-
-    if (!clientAssetExists || !serverEntryExists) {
-        throw new Error('UI build artifacts are missing. Run `bun run build` before launching `spiracha ui`.');
-    }
-
-    await ensureUiExportDir();
-};
-
-const parsePort = (value: string) => {
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 65535) {
-        throw new CliUsageError(`Invalid port: ${value}`);
-    }
-
-    return parsed;
-};
-
-const requireUiArgValue = (value: string | undefined, flag: string) => {
-    if (!value) {
-        throw new CliUsageError(`Missing value for ${flag}`);
-    }
-
-    return value;
-};
-
-const applyUiCliArg = (
-    argv: string[],
-    index: number,
-    state: UiCliOptions,
-): {
-    index: number;
-    state: UiCliOptions;
-} => {
-    const arg = argv[index];
-
-    if (arg === '--no-open') {
-        return {
-            index,
-            state: {
-                ...state,
-                openBrowser: false,
-            },
-        };
-    }
-
-    if (arg === '--port') {
-        return {
-            index: index + 1,
-            state: {
-                ...state,
-                port: parsePort(requireUiArgValue(argv[index + 1], '--port')),
-            },
-        };
-    }
-
-    if (arg === '--host') {
-        return {
-            index: index + 1,
-            state: {
-                ...state,
-                host: requireUiArgValue(argv[index + 1], '--host'),
-            },
-        };
-    }
-
-    if (arg === '--db') {
-        return {
-            index: index + 1,
-            state: {
-                ...state,
-                dbPath: requireUiArgValue(argv[index + 1], '--db'),
-            },
-        };
-    }
-
-    throw new CliUsageError(`Unknown UI argument: ${arg}`);
-};
-
-export const parseUiCliArgs = (argv: string[]): UiCliOptions => {
-    let state: UiCliOptions = {
-        dbPath: null,
-        host: DEFAULT_UI_HOST,
-        openBrowser: true,
-        port: DEFAULT_UI_PORT,
-    };
-
-    for (let index = 0; index < argv.length; index += 1) {
-        const next = applyUiCliArg(argv, index, state);
-        state = next.state;
-        index = next.index;
-    }
-
-    return state;
-};
-
-export const getUiHelpText = (): string => {
-    return [
-        'Launch the Spiracha browser UI for Codex, Cursor, and Antigravity history.',
-        '',
-        'Usage:',
-        '  spiracha ui [--port 3000] [--host 127.0.0.1] [--db FILE] [--no-open]',
-        '',
-        'Options:',
-        `  --port     HTTP port to bind (default: ${DEFAULT_UI_PORT})`,
-        `  --host     Hostname to bind (default: ${DEFAULT_UI_HOST})`,
-        '  --db       Override the Codex SQLite database path for the UI',
-        '  --no-open  Do not open the browser automatically',
-        '  --help,-h  Show this help text',
-        '',
-        'Stop the UI with Ctrl+C.',
-    ].join('\n');
-};
-
-const toPublicFilePath = (clientDir: string, pathname: string) => {
-    const normalizedPath = pathname === '/' ? '' : pathname.replace(/^\/+/u, '');
-    const resolved = path.resolve(clientDir, normalizedPath);
-    const relative = path.relative(clientDir, resolved);
-
-    if (relative.startsWith('..') || path.isAbsolute(relative)) {
-        return null;
-    }
-
-    return resolved;
-};
-
-export const getUiStaticResponse = async (clientDir: string, pathname: string): Promise<Response | null> => {
-    if (pathname === '/') {
-        return null;
-    }
-
-    const exportFilePath = resolveUiExportFilePathFromRequestPath(pathname);
-    if (exportFilePath) {
-        try {
-            await access(exportFilePath, constants.R_OK);
-        } catch {
-            return new Response('Not Found', { status: 404 });
-        }
-
-        return new Response(Bun.file(exportFilePath), {
-            headers: {
-                'cache-control': 'no-store',
-                'content-disposition': buildUiExportContentDisposition(exportFilePath),
-            },
-        });
-    }
-
-    const targetPath = toPublicFilePath(clientDir, pathname);
-    if (!targetPath) {
-        return new Response('Forbidden', { status: 403 });
-    }
-
-    const file = Bun.file(targetPath);
-    if (!(await file.exists())) {
-        return null;
-    }
-
-    return new Response(file);
-};
-
-const openBrowserIfRequested = async (url: string, openBrowser: boolean) => {
-    if (!openBrowser) {
-        return;
-    }
-
-    try {
-        await openUrlNatively(url);
-    } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.warn(`Could not open the browser automatically: ${message}`);
-    }
-};
-
-const startUiServer = async (options: UiCliOptions) => {
-    await ensureUiBuildExists();
-    const { clientDir, serverEntryPath } = resolveUiDistPaths();
-    const serverModule = (await import(serverEntryPath)) as {
-        default: {
-            fetch: (request: Request) => Promise<Response> | Response;
-        };
-    };
-
-    if (options.dbPath) {
-        process.env.SPIRACHA_CODEX_DB = options.dbPath;
-    }
-
-    for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt += 1) {
-        const port = options.port + attempt;
-
-        try {
-            const server = Bun.serve({
-                fetch: async (request) => {
-                    const url = new URL(request.url);
-                    const staticResponse = await getUiStaticResponse(clientDir, url.pathname);
-                    if (staticResponse) {
-                        return staticResponse;
-                    }
-
-                    return serverModule.default.fetch(request);
-                },
-                hostname: options.host,
-                idleTimeout: 30,
-                port,
-            });
-
-            return {
-                port,
-                server,
-            };
-        } catch (error) {
-            if (
-                attempt < MAX_PORT_ATTEMPTS - 1 &&
-                error instanceof Error &&
-                /address already in use|EADDRINUSE/i.test(error.message)
-            ) {
-                continue;
-            }
-
-            throw error;
-        }
-    }
-
-    throw new Error(`Unable to bind the UI server after ${MAX_PORT_ATTEMPTS} port attempts.`);
-};
-
-export const runUiCli = async (argv = process.argv.slice(2)) => {
-    try {
-        if (argv.includes('--help') || argv.includes('-h')) {
-            console.log(getUiHelpText());
-            return;
-        }
-        const options = parseUiCliArgs(argv);
-        const { port, server } = await startUiServer(options);
-        const url = `http://${options.host}:${port}`;
-
-        console.log(`Spiracha UI running at ${url}`);
-        console.log('Press Ctrl+C to stop.');
-
-        await openBrowserIfRequested(url, options.openBrowser);
-
-        let shuttingDown = false;
-        const shutdown = () => {
-            if (shuttingDown) {
-                return;
-            }
-            shuttingDown = true;
-            server.stop(true);
-            console.log('Spiracha UI stopped.');
-            process.exit(0);
-        };
-
-        process.once('SIGINT', shutdown);
-        process.once('SIGTERM', shutdown);
-
-        await new Promise<void>(() => {});
-    } catch (error) {
-        if (error instanceof CliUsageError) {
-            console.error(error.message);
-            console.error('');
-            console.error(getUiHelpText());
-            process.exit(1);
-        }
-
-        if (error instanceof Error) {
-            console.error(error.message);
-            process.exit(1);
-        }
-
-        throw error;
-    }
-};
-
-if (import.meta.main) {
-    await runUiCli();
-}