@okrapdf/cli 0.4.6 → 0.5.0

package/dist/commands/chat.js

@@ -1,22 +1,11 @@
 /**
- * Agent-driven chat via WebSocket (same session as web UI)
+ * Unified chat command.
  *
- * okra chat <jobId> -m "what tables are in this document?"
- *
- * Both the web UI and CLI are clients to the same Cloudflare Durable Object.
- * On reconnect the DO replays persisted events (EVENTS_BATCH) containing old
- * AGENT_MESSAGE, AGENT_DONE, etc. We must ignore those and only render events
- * triggered by OUR new message.
- *
- * Server message order on reconnect:
- *   Frame 1: CONNECTED
- *   Frame 2: READY (with sandboxId if running)
- *   Frame 3: SANDBOX_STATUS (live, not replayed)
- *   Frame 4: EVENTS_BATCH (replayed history — arrives AFTER SANDBOX_STATUS)
- *
- * Because EVENTS_BATCH arrives after SANDBOX_STATUS resolves, a simple
- * messageSent flag doesn't work. Instead we use a global listener to detect
- * EVENTS_BATCH and wait for it before sending our message.
+ * okra chat "what is EBITDA?"                        → general (no doc)
+ * okra chat "how many pages?" --doc ocr-XXX          → single-doc
+ * okra chat "compare revenue" --doc ocr-XXX,ocr-YYY  → multi-doc
+ * okra chat "compare all" -c my-collection            → multi-doc (collection)
+ * okra chat send ocr-XXX -m "question"                → legacy compat
  */
 import '../lib/ws-polyfill.js';
 import { Command } from 'commander';
@@ -31,320 +20,114 @@ import { createSpinner } from '../lib/progress.js';
 import { OkraApiError, EXIT_CODES, patch as apiPatch } from '../lib/client.js';
 import { resolveSchema, extractJson, listBuiltinNames, } from '../lib/structured-output.js';
 import { resolveJobId } from '../lib/resolver.js';
+import { runSingleDocChat } from '../lib/single-doc-chat.js';
+import { runGeneralChat } from '../lib/general-chat.js';
+import { runMultiDocChat } from '../lib/multi-doc-chat.js';
 const WSS_URL = getAgentSessionUrl();
 const SANDBOX_TEMPLATE = 'okra-claude-agent-sdk';
 const SANDBOX_TIMEOUT_MS = 120_000;
 export function createChatCommand() {
     const chat = new Command('chat')
-        .description('Chat with a document via agent session');
-    // Default subcommand: okra chat <document> -m "msg"
-    const send = new Command('send')
-        .description('Send a message to a document chat session')
-        .argument('[document]', 'Job ID (ocr-*), source ref (arxiv/1706.03762), or URL')
-        .requiredOption('-m, --message <message>', 'Message to send')
-        .option('-o, --output <format>', 'Output format (text, json)', 'text')
+        .description('Chat with documents or ask general questions')
+        .argument('[message]', 'Message to send (positional)')
+        .option('-d, --doc <ids>', 'Comma-separated job IDs (ocr-*)')
+        .option('-c, --collection <nameOrId>', 'Collection name or ID')
+        .option('-m, --message <message>', 'Message (alternative to positional)')
         .option('-s, --schema <schema>', 'Structured output: built-in name, inline JSON, or file path')
+        .option('--model <model>', 'Model to use')
         .option('--share', 'Generate a public share link')
-        .action(async (document, options) => {
-        // Handle --schema help
-        if (options.schema === 'help') {
-            console.log('Built-in schemas:');
-            for (const name of listBuiltinNames()) {
-                console.log(`  ${name}`);
-            }
-            console.log('\nYou can also pass inline JSON or a file path:');
-            console.log('  --schema \'{"type":"object","properties":{"name":{"type":"string"}}}\'');
-            console.log('  --schema ./my-schema.json');
-            process.exit(0);
-        }
-        // Resolve schema (built-in name, inline JSON, or file path)
-        let resolvedSchema;
-        if (options.schema) {
-            const result = resolveSchema(options.schema);
-            if ('error' in result) {
-                error(result.error);
-                process.exit(EXIT_CODES.INVALID_ARGS);
-            }
-            resolvedSchema = result.schema;
-        }
-        if (!document) {
-            error('Provide a document argument, or use `okra task` for multi-doc queries');
+        .option('--socket', 'Use legacy WebSocket + E2B sandbox path')
+        .option('--tools <type>', 'Tool mode: sandbox | code_interpreter (stub)')
+        .action(async (positionalMessage, options) => {
+        const message = positionalMessage || options.message;
+        if (!message) {
+            error('Provide a message: okra chat "your question" or okra chat -m "your question"');
             process.exit(EXIT_CODES.INVALID_ARGS);
-            return; // unreachable, helps TS narrow
         }
-        // Resolve document reference to jobId
-        const resolved = await resolveJobId(document).catch((err) => {
-            error(err instanceof Error ? err.message : String(err));
-            process.exit(EXIT_CODES.GENERAL_ERROR);
-        });
-        const jobId = resolved.jobId;
-        const apiKey = getApiKey();
-        if (!apiKey) {
-            error('Not authenticated. Run `okra auth login` first.');
-            process.exit(EXIT_CODES.AUTH_ERROR);
-        }
-        const quiet = isQuietMode();
-        // In schema mode, all human-friendly output goes to stderr (gh CLI pattern).
-        // stdout is reserved exclusively for the JSON result.
-        const spinnerStream = resolvedSchema ? process.stderr : undefined;
-        const useSpinners = !quiet && (resolvedSchema ? process.stderr.isTTY : process.stdout.isTTY);
-        // Suppress library console.log that pollutes stdout
-        // (AgentSessionClient logs "[AgentSession] ..." to console.log)
-        // Must happen before client.connect() so connect/connected logs are caught.
-        const origConsoleLog = console.log;
-        if (resolvedSchema) {
-            console.log = (...args) => {
-                const first = typeof args[0] === 'string' ? args[0] : '';
-                if (first.startsWith('[AgentSession]'))
-                    return;
-                origConsoleLog(...args);
-            };
-        }
-        // 1. Fetch bootstrap (archive URL + metadata)
-        const bootSpinner = useSpinners
-            ? createSpinner('Preparing document...', { stream: spinnerStream })
-            : null;
-        bootSpinner?.start();
-        let archiveUrl;
-        let totalPages;
-        try {
-            const bootstrap = await fetchBootstrap(jobId);
-            archiveUrl = bootstrap.archiveUrl;
-            totalPages = bootstrap.metadata.totalPages;
-            bootSpinner?.succeed(`Document ready (${totalPages} pages)`);
+        // --tools stub
+        if (options.tools) {
+            const chalk = (await import('chalk')).default;
+            process.stderr.write(chalk.yellow(`Warning: --tools ${options.tools} is not yet implemented. Proceeding without tools.\n`));
         }
-        catch (err) {
-            if (err instanceof OkraApiError) {
-                bootSpinner?.fail(`Failed to prepare document (${err.statusCode})`);
-                error(err.message);
-                if (err.details)
-                    error(JSON.stringify(err.details));
-            }
-            else {
-                bootSpinner?.fail('Failed to prepare document');
-                error(err instanceof Error ? err.message : String(err));
-            }
-            process.exit(EXIT_CODES.GENERAL_ERROR);
-        }
-        // 2. Connect WebSocket
-        const renderer = resolvedSchema
-            ? new SilentCollectorRenderer()
-            : new AgentRenderer();
-        const client = new AgentSessionClient({
-            url: WSS_URL,
-            sessionId: jobId,
-            autoConnect: false,
-            autoReconnect: false,
-        });
-        // Gate: ignore replayed agent events until we've sent our message.
-        // After SANDBOX_STATUS resolves we wait 100ms for EVENTS_BATCH to drain,
-        // then flip this flag and send. Events arriving before the flip are replay.
-        let messageSent = false;
-        // 3. Register event handlers
-        const sandboxSpinner = useSpinners
-            ? createSpinner('Booting sandbox...', { stream: spinnerStream })
-            : null;
-        // Promise that resolves when sandbox is ready.
-        // Two paths to resolution (matching web client Redux slice):
-        //   1. READY { sandboxId } — sandbox already running (reconnect)
-        //   2. SANDBOX_STATUS { status: 'ready' } — fresh boot completed
-        let resolveSandboxReady;
-        const sandboxReady = new Promise((resolve, reject) => {
-            resolveSandboxReady = resolve;
-            const timeout = setTimeout(() => {
-                reject(new Error('Sandbox boot timed out'));
-            }, SANDBOX_TIMEOUT_MS);
-            client.on('SANDBOX_STATUS', (event) => {
-                if (event.status === 'ready') {
-                    clearTimeout(timeout);
-                    resolve();
-                }
-                else if (event.status === 'error') {
-                    clearTimeout(timeout);
-                    reject(new Error(event.error || 'Sandbox boot failed'));
-                }
-            });
-        });
-        client.on('READY', (event) => {
-            if (event.sandboxId) {
-                // Sandbox already running on reconnect.
-                // Match web client behavior: READY { sandboxId } means sandbox is alive.
-                // (Redux slice setReady sets sandboxStatus = 'ready' when sandboxId present)
-                // Server validated sandbox health before including sandboxId — trust it.
-                resolveSandboxReady();
-            }
-            else {
-                sandboxSpinner?.start();
-                client.send({
-                    type: 'START_SANDBOX',
-                    template: SANDBOX_TEMPLATE,
-                    bootstrap: { archiveUrl },
-                });
-            }
-        });
-        // Wait for EVENTS_BATCH replay to finish (or timeout if no replay).
-        const replayDone = new Promise((resolve) => {
-            sandboxReady.then(() => {
-                setTimeout(resolve, 100);
-            }).catch(() => resolve());
-        });
-        // Promise that resolves when agent is done
-        let resolveAgent;
-        let rejectAgent;
-        const agentDone = new Promise((resolve, reject) => {
-            resolveAgent = resolve;
-            rejectAgent = reject;
-        });
-        client.on('LIFECYCLE', (event) => {
-            if (sandboxSpinner?.isSpinning) {
-                sandboxSpinner.text = event.message || event.phase;
-            }
-        });
-        // Agent events — gated on messageSent to skip replay
-        client.on('AGENT_STARTED', (_event) => {
-            if (!messageSent)
-                return;
-            renderer.onAgentStarted();
-        });
-        // Capture structured_output from SDK result event
-        let structuredOutput = undefined;
-        client.on('AGENT_MESSAGE', (event) => {
-            if (!messageSent)
-                return;
-            // Runner sends subtype:"result" with is_error:true on SDK failure
-            if (event.subtype === 'result' && event.is_error) {
-                const errMsg = event.result || 'Agent failed (no details)';
-                renderer.onAgentError(String(errMsg));
-                rejectAgent(new Error(String(errMsg)));
-                return;
-            }
-            // Capture SDK structured_output from result event
-            if (event.subtype === 'result' && event.structured_output != null) {
-                structuredOutput = event.structured_output;
-            }
-            renderer.onAgentMessage(event.message?.content);
-        });
-        client.on('AGENT_DONE', (event) => {
-            if (!messageSent)
-                return;
-            renderer.onAgentDone(event.total_cost_usd, event.duration_ms);
-            resolveAgent();
-        });
-        client.on('AGENT_ERROR', (event) => {
-            if (!messageSent)
+        // Route based on --doc / -c presence
+        const docIds = options.doc?.split(',').map(s => s.trim()).filter(Boolean) || [];
+        const hasCollection = Boolean(options.collection);
+        const docCount = docIds.length;
+        if (!options.doc && !hasCollection) {
+            // General chat — no documents
+            await runGeneralChat({ message, model: options.model });
+            return;
+        }
+        if (docCount === 1 && !hasCollection) {
+            // Single-doc chat
+            if (options.socket) {
+                // Legacy WS + E2B sandbox path
+                await runLegacySocketChat(docIds[0], message, options);
                 return;
-            renderer.onAgentError(event.error);
-            rejectAgent(new Error(event.error));
-        });
-        client.on('ERROR', (event) => {
-            error(`Server error: ${event.msg}`);
-            rejectAgent(new Error(event.msg));
-        });
-        // 4. Connect
-        client.connect();
-        // 5. Wait for sandbox
-        try {
-            await sandboxReady;
-            if (sandboxSpinner?.isSpinning) {
-                sandboxSpinner.succeed('Sandbox ready');
             }
+            await runSingleDocChat({
+                jobId: docIds[0],
+                message,
+                schema: options.schema,
+                share: options.share,
+                model: options.model,
+            });
+            return;
         }
-        catch (err) {
-            sandboxSpinner?.fail('Sandbox boot failed');
-            error(err instanceof Error ? err.message : String(err));
-            client.disconnect();
-            process.exit(EXIT_CODES.GENERAL_ERROR);
+        // Multi-doc (2+ docs or collection)
+        if (options.schema) {
+            error('--schema is not supported for multi-document chat');
+            process.exit(EXIT_CODES.INVALID_ARGS);
         }
-        // 6. Wait for replay to drain before sending
-        await replayDone;
-        // 6b. --share: set is_public and print share URL
-        const shareUrl = `https://okrapdf.com/share/${jobId}`;
-        if (options.share) {
-            try {
-                await apiPatch(`api/share/${jobId}`, { is_public: true });
-                info(`Share URL: ${shareUrl}`);
-            }
-            catch (err) {
-                error(`Failed to enable sharing: ${err instanceof Error ? err.message : String(err)}`);
-            }
+        await runMultiDocChat({
+            message,
+            documents: docIds.length > 0 ? docIds.join(',') : undefined,
+            collection: options.collection,
+            model: options.model,
+            share: options.share,
+        });
+    });
+    // ── Legacy `send` subcommand ──────────────────────────────────────────
+    // okra chat send ocr-XXX -m "question"
+    const send = new Command('send')
+        .description('Send a message (legacy — use `okra chat "msg" --doc <id>` instead)')
+        .argument('[document]', 'Job ID (ocr-*), source ref, or URL')
+        .requiredOption('-m, --message <message>', 'Message to send')
+        .option('-c, --collection <nameOrId>', 'Collection name or ID')
+        .option('-s, --schema <schema>', 'Structured output schema')
+        .option('--model <model>', 'Model to use', 'claude-sonnet-4-20250514')
+        .option('--share', 'Generate a public share link')
+        .option('--socket', 'Use legacy WebSocket + E2B sandbox path')
+        .action(async (document, options) => {
+        const hasMultipleDocs = document?.includes(',');
+        const hasCollection = Boolean(options.collection);
+        if (hasCollection || hasMultipleDocs) {
+            // Multi-doc via orchestrator
+            await runMultiDocChat({
+                message: options.message,
+                documents: document,
+                collection: options.collection,
+                model: options.model,
+                share: options.share,
+            });
+            return;
         }
-        // 7. Send message — flip gate so subsequent events are rendered
-        messageSent = true;
-        if (!resolvedSchema)
-            info(`Sending: ${options.message}`);
-        const systemPrompt = buildSystemPrompt({ schema: resolvedSchema });
-        // Send raw AGENT_MESSAGE so author metadata is preserved across
-        // older @steventsao/agent-session client versions used by the CLI.
-        const wsMessage = {
-            type: 'AGENT_MESSAGE',
-            content: options.message,
-            model: { id: 'claude-sonnet-4-20250514', provider: 'anthropic' },
-            systemPrompt,
-            agentType: 'claude-code',
-            author: { name: 'okra-cli', clientType: 'cli' },
-        };
-        // Send JSON Schema for SDK-native structured output
-        if (resolvedSchema) {
-            wsMessage.outputFormat = {
-                type: 'json_schema',
-                schema: resolvedSchema.jsonSchema,
-            };
-        }
-        client.send(wsMessage);
-        // 8. Wait for agent completion
-        try {
-            await agentDone;
-            if (options.share) {
-                info(`Share URL: ${shareUrl}`);
-            }
+        if (!document) {
+            error('Provide a document argument (or use -c/--collection for multi-doc mode)');
+            process.exit(EXIT_CODES.INVALID_ARGS);
+            return;
         }
-        catch (err) {
-            error(err instanceof Error ? err.message : String(err));
-            process.exitCode = EXIT_CODES.GENERAL_ERROR;
-        }
-        // Restore console.log before outputting results
-        if (resolvedSchema)
-            console.log = origConsoleLog;
-        // 8b. Structured output: prefer SDK structured_output, fall back to text extraction
-        // Write JSON to stdout via process.stdout.write (not console.log) to keep
-        // a clean machine-readable stream — gh CLI pattern.
-        if (resolvedSchema && !process.exitCode) {
-            let parsed = structuredOutput ?? null;
-            // Fallback: extract JSON from collected text if SDK didn't return structured_output
-            if (parsed === null) {
-                const raw = renderer.getCollectedText();
-                parsed = extractJson(raw);
-                if (parsed === null) {
-                    process.stderr.write('Failed to extract JSON from agent response.\n');
-                    process.stderr.write('Raw output:\n' + raw + '\n');
-                    process.exitCode = EXIT_CODES.VALIDATION_ERROR;
-                }
-            }
-            if (parsed !== null && !process.exitCode) {
-                // For built-in schemas, validate with Zod; for custom schemas, output as-is
-                if (resolvedSchema.zodSchema) {
-                    const result = resolvedSchema.zodSchema.safeParse(parsed);
-                    if (result.success) {
-                        process.stdout.write(JSON.stringify(result.data, null, 2) + '\n');
-                    }
-                    else {
-                        process.stderr.write('Schema validation failed:\n');
-                        for (const issue of result.error.issues) {
-                            process.stderr.write(`  - ${issue.path.join('.')}: ${issue.message}\n`);
-                        }
-                        process.stderr.write('\nRaw JSON:\n' + JSON.stringify(parsed, null, 2) + '\n');
-                        process.exitCode = EXIT_CODES.VALIDATION_ERROR;
-                    }
-                }
-                else {
-                    // Custom schema — SDK already validated via constrained decoding
-                    process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');
-                }
-            }
+        if (options.socket) {
+            await runLegacySocketChat(document, options.message, options);
+            return;
         }
-        // 9. Disconnect and exit
-        client.disconnect();
-        process.exit(process.exitCode ?? 0);
+        await runSingleDocChat({
+            jobId: document,
+            message: options.message,
+            schema: options.schema,
+            share: options.share,
+            model: options.model,
+        });
     });
     // ── view subcommand ──────────────────────────────────────────────────
     const view = new Command('view')
@@ -361,7 +144,6 @@ export function createChatCommand() {
         const chalk = (await import('chalk')).default;
         const got = (await import('got')).default;
         const { openInBrowser } = await import('../lib/browser.js');
-        // Resolve events source
         let events;
         if (opts.file) {
             try {
@@ -405,7 +187,6 @@ export function createChatCommand() {
             info('No events found');
             process.exit(0);
         }
-        // Output modes
         if (opts.jsonl) {
             for (const evt of events) {
                 console.log(JSON.stringify(evt));
@@ -429,10 +210,261 @@ export function createChatCommand() {
         }
         process.exit(0);
     });
-    chat.addCommand(send, { isDefault: true });
+    chat.addCommand(send);
     chat.addCommand(view);
     return chat;
 }
+// ── Legacy WebSocket + E2B sandbox path ─────────────────────────────────
+async function runLegacySocketChat(document, message, options) {
+    // Resolve schema
+    let resolvedSchema;
+    if (options.schema) {
+        if (options.schema === 'help') {
+            console.log('Built-in schemas:');
+            for (const name of listBuiltinNames()) {
+                console.log(`  ${name}`);
+            }
+            process.exit(0);
+        }
+        const result = resolveSchema(options.schema);
+        if ('error' in result) {
+            error(result.error);
+            process.exit(EXIT_CODES.INVALID_ARGS);
+        }
+        resolvedSchema = result.schema;
+    }
+    const apiKey = getApiKey();
+    if (!apiKey) {
+        error('Not authenticated. Run `okra auth login` first.');
+        process.exit(EXIT_CODES.AUTH_ERROR);
+    }
+    const resolved = await resolveJobId(document).catch((err) => {
+        error(err instanceof Error ? err.message : String(err));
+        process.exit(EXIT_CODES.GENERAL_ERROR);
+    });
+    const jobId = resolved.jobId;
+    const model = options.model || 'claude-sonnet-4-20250514';
+    const quiet = isQuietMode();
+    const spinnerStream = resolvedSchema ? process.stderr : undefined;
+    const useSpinners = !quiet && (resolvedSchema ? true : process.stdout.isTTY);
+    const origConsoleLog = console.log;
+    if (resolvedSchema) {
+        console.log = (...args) => {
+            const first = typeof args[0] === 'string' ? args[0] : '';
+            if (first.startsWith('[AgentSession]'))
+                return;
+            origConsoleLog(...args);
+        };
+    }
+    const bootSpinner = useSpinners
+        ? createSpinner('Preparing document...', { stream: spinnerStream })
+        : null;
+    bootSpinner?.start();
+    let archiveUrl;
+    let totalPages;
+    try {
+        const bootstrap = await fetchBootstrap(jobId);
+        archiveUrl = bootstrap.archiveUrl;
+        totalPages = bootstrap.metadata.totalPages;
+        bootSpinner?.succeed(`Document ready (${totalPages} pages)`);
+    }
+    catch (err) {
+        if (err instanceof OkraApiError) {
+            bootSpinner?.fail(`Failed to prepare document (${err.statusCode})`);
+            error(err.message);
+            if (err.details)
+                error(JSON.stringify(err.details));
+        }
+        else {
+            bootSpinner?.fail('Failed to prepare document');
+            error(err instanceof Error ? err.message : String(err));
+        }
+        process.exit(EXIT_CODES.GENERAL_ERROR);
+    }
+    const renderer = resolvedSchema
+        ? new SilentCollectorRenderer()
+        : new AgentRenderer();
+    const client = new AgentSessionClient({
+        url: WSS_URL,
+        sessionId: jobId,
+        autoConnect: false,
+        autoReconnect: false,
+    });
+    let messageSent = false;
+    const sandboxSpinner = useSpinners
+        ? createSpinner('Booting sandbox...', { stream: spinnerStream })
+        : null;
+    let resolveSandboxReady;
+    const sandboxReady = new Promise((resolve, reject) => {
+        resolveSandboxReady = resolve;
+        const timeout = setTimeout(() => {
+            reject(new Error('Sandbox boot timed out'));
+        }, SANDBOX_TIMEOUT_MS);
+        client.on('SANDBOX_STATUS', (event) => {
+            if (event.status === 'ready') {
+                clearTimeout(timeout);
+                resolve();
+            }
+            else if (event.status === 'error') {
+                clearTimeout(timeout);
+                reject(new Error(event.error || 'Sandbox boot failed'));
+            }
+        });
+    });
+    client.on('READY', (event) => {
+        if (event.sandboxId) {
+            resolveSandboxReady();
+        }
+        else {
+            sandboxSpinner?.start();
+            client.send({
+                type: 'START_SANDBOX',
+                template: SANDBOX_TEMPLATE,
+                bootstrap: { archiveUrl },
+            });
+        }
+    });
+    const replayDone = new Promise((resolve) => {
+        sandboxReady.then(() => {
+            setTimeout(resolve, 100);
+        }).catch(() => resolve());
+    });
+    let resolveAgent;
+    let rejectAgent;
+    const agentDone = new Promise((resolve, reject) => {
+        resolveAgent = resolve;
+        rejectAgent = reject;
+    });
+    client.on('LIFECYCLE', (event) => {
+        if (sandboxSpinner?.isSpinning) {
+            sandboxSpinner.text = event.message || event.phase;
+        }
+    });
+    client.on('AGENT_STARTED', (_event) => {
+        if (!messageSent)
+            return;
+        renderer.onAgentStarted();
+    });
+    let structuredOutput = undefined;
+    client.on('AGENT_MESSAGE', (event) => {
+        if (!messageSent)
+            return;
+        if (event.subtype === 'result' && event.is_error) {
+            const errMsg = event.result || 'Agent failed (no details)';
+            renderer.onAgentError(String(errMsg));
+            rejectAgent(new Error(String(errMsg)));
+            return;
+        }
+        if (event.subtype === 'result' && event.structured_output != null) {
+            structuredOutput = event.structured_output;
+        }
+        renderer.onAgentMessage(event.message?.content);
+    });
+    client.on('AGENT_DONE', (event) => {
+        if (!messageSent)
+            return;
+        renderer.onAgentDone(event.total_cost_usd, event.duration_ms);
+        resolveAgent();
+    });
+    client.on('AGENT_ERROR', (event) => {
+        if (!messageSent)
+            return;
+        renderer.onAgentError(event.error);
+        rejectAgent(new Error(event.error));
+    });
+    client.on('ERROR', (event) => {
+        error(`Server error: ${event.msg}`);
+        rejectAgent(new Error(event.msg));
+    });
+    client.connect();
+    try {
+        await sandboxReady;
+        if (sandboxSpinner?.isSpinning) {
+            sandboxSpinner.succeed('Sandbox ready');
+        }
+    }
+    catch (err) {
+        sandboxSpinner?.fail('Sandbox boot failed');
+        error(err instanceof Error ? err.message : String(err));
+        client.disconnect();
+        process.exit(EXIT_CODES.GENERAL_ERROR);
+    }
+    await replayDone;
+    const shareUrl = `https://okrapdf.com/share/${jobId}`;
+    if (options.share) {
+        try {
+            await apiPatch(`api/share/${jobId}`, { is_public: true });
+            info(`Share URL: ${shareUrl}`);
+        }
+        catch (err) {
+            error(`Failed to enable sharing: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    messageSent = true;
+    if (!resolvedSchema)
+        info(`Sending: ${message}`);
+    const systemPrompt = buildSystemPrompt({ schema: resolvedSchema });
+    const wsMessage = {
+        type: 'AGENT_MESSAGE',
+        content: message,
+        model: { id: model, provider: 'anthropic' },
+        systemPrompt,
+        agentType: 'claude-code',
+        author: { name: 'okra-cli', clientType: 'cli' },
+    };
+    if (resolvedSchema) {
+        wsMessage.outputFormat = {
+            type: 'json_schema',
+            schema: resolvedSchema.jsonSchema,
+        };
+    }
+    client.send(wsMessage);
+    try {
+        await agentDone;
+        if (options.share) {
+            info(`Share URL: ${shareUrl}`);
+        }
+    }
+    catch (err) {
+        error(err instanceof Error ? err.message : String(err));
+        process.exitCode = EXIT_CODES.GENERAL_ERROR;
+    }
+    if (resolvedSchema)
+        console.log = origConsoleLog;
+    if (resolvedSchema && !process.exitCode) {
+        let parsed = structuredOutput ?? null;
+        if (parsed === null) {
+            const raw = renderer.getCollectedText();
+            parsed = extractJson(raw);
+            if (parsed === null) {
+                process.stderr.write('Failed to extract JSON from agent response.\n');
+                process.stderr.write('Raw output:\n' + raw + '\n');
+                process.exitCode = EXIT_CODES.VALIDATION_ERROR;
+            }
+        }
+        if (parsed !== null && !process.exitCode) {
+            if (resolvedSchema.zodSchema) {
+                const result = resolvedSchema.zodSchema.safeParse(parsed);
+                if (result.success) {
+                    process.stdout.write(JSON.stringify(result.data, null, 2) + '\n');
+                }
+                else {
+                    process.stderr.write('Schema validation failed:\n');
+                    for (const issue of result.error.issues) {
+                        process.stderr.write(`  - ${issue.path.join('.')}: ${issue.message}\n`);
+                    }
+                    process.stderr.write('\nRaw JSON:\n' + JSON.stringify(parsed, null, 2) + '\n');
+                    process.exitCode = EXIT_CODES.VALIDATION_ERROR;
+                }
+            }
+            else {
+                process.stdout.write(JSON.stringify(parsed, null, 2) + '\n');
+            }
+        }
+    }
+    client.disconnect();
+    process.exit(process.exitCode ?? 0);
+}
 function parseJsonl(raw) {
     return raw
         .split('\n')
@@ -447,7 +479,6 @@ function parseJsonl(raw) {
     })
         .filter((e) => e !== null);
 }
-/* eslint-disable @typescript-eslint/no-explicit-any */
 function renderTerminalTranscript(events, chalk) {
     for (const evt of events) {
         const ts = evt.timestamp ? chalk.dim(new Date(evt.timestamp).toLocaleTimeString() + ' ') : '';