@supatest/cli 0.0.2 → 0.0.3

package/dist/agent-runner.js

@@ -3,8 +3,11 @@ import { dirname, join } from "node:path";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import chalk from "chalk";
 import ora from "ora";
-import { logger } from "./utils/logger.js";
-import { generateSummary } from "./utils/summary.js";
+import { config as envConfig } from "./config";
+import { ApiClient } from "./services/api-client";
+import { EventStreamer } from "./services/event-streamer";
+import { logger } from "./utils/logger";
+import { generateSummary } from "./utils/summary";
 const CLI_VERSION = "0.0.1";
 // Fun spinner messages that rotate randomly
 const SPINNER_MESSAGES = [
@@ -46,7 +49,7 @@ export async function runAgent(config) {
     let claudeCodeStderr = "";
     logger.setVerbose(config.verbose);
     // Display metadata
-    console.log("");
+    logger.raw("");
     // Get git branch if available
     let gitBranch = "";
     try {
@@ -61,16 +64,16 @@ export async function runAgent(config) {
     }
     const metadataParts = [
         chalk.dim("Supatest AI ") + chalk.cyan(`v${CLI_VERSION}`),
-        chalk.dim("Model: ") + chalk.cyan(process.env.ANTHROPIC_MODEL_NAME || "claude-sonnet-4-5"),
+        chalk.dim("Model: ") + chalk.cyan(envConfig.anthropicModelName),
     ];
     if (gitBranch) {
         metadataParts.push(chalk.dim("Branch: ") + chalk.cyan(gitBranch));
     }
-    console.log(metadataParts.join(chalk.dim(" • ")));
-    console.log(chalk.gray("─".repeat(60)));
+    logger.raw(metadataParts.join(chalk.dim(" • ")));
+    logger.divider();
     // Show environment info in verbose mode
     if (config.verbose) {
-        console.log("");
+        logger.raw("");
         logger.debug("Environment & System Info:");
         // Node.js version
         logger.debug(`  Node.js: ${process.version}`);
@@ -103,15 +106,39 @@ export async function runAgent(config) {
             logger.debug(`  Available Disk: unable to determine`);
         }
     }
-    console.log("");
-    console.log("");
-    console.log(chalk.white.bold("Task:"), chalk.cyan(config.task));
+    logger.raw("");
+    logger.raw("");
+    logger.raw(chalk.white.bold("Task:") + " " + chalk.cyan(config.task));
     if (config.logs) {
         logger.info("Processing provided logs...");
     }
-    console.log("");
-    console.log("");
-    console.log("");
+    logger.raw("");
+    // Create session on backend and initialize event streaming
+    const apiUrl = config.supatestApiUrl || "https://api.supatest.ai";
+    const apiClient = new ApiClient(apiUrl, config.supatestApiKey);
+    let sessionId;
+    let webUrl;
+    let eventStreamer;
+    try {
+        const session = await apiClient.createSession(config.task, {
+            cliVersion: CLI_VERSION,
+            cwd: process.cwd(),
+        });
+        sessionId = session.sessionId;
+        webUrl = session.webUrl;
+        eventStreamer = new EventStreamer(apiClient, sessionId);
+        logger.raw("");
+        logger.divider();
+        logger.raw(chalk.white.bold("View session live: ") +
+            chalk.cyan.underline(webUrl));
+        logger.divider();
+        logger.raw("");
+    }
+    catch (error) {
+        logger.warn(`Failed to create session on backend: ${error.message}`);
+        logger.warn("Continuing without web streaming...");
+    }
+    logger.raw("");
     // Initialize spinner variable (will be created on first agent turn)
     let spinner = null;
     // Resolve path to Claude Code executable
@@ -122,11 +149,26 @@ export async function runAgent(config) {
         if (config.logs) {
             prompt = `${config.task}\n\nHere are the logs to analyze:\n\`\`\`\n${config.logs}\n\`\`\``;
         }
-        // Set API key
-        process.env.ANTHROPIC_API_KEY = config.apiKey;
+        const proxyUrl = config.supatestApiUrl || "https://api.supatest.ai";
+        // Build base URL with session ID embedded in the path for message tracking
+        // The proxy will extract the session ID from the path and lookup the message ID in Redis
+        // Format: {proxyUrl}/v1/sessions/{sessionId}/anthropic
+        let baseUrl = `${proxyUrl}/public`;
+        if (sessionId) {
+            baseUrl = `${proxyUrl}/v1/sessions/${sessionId}/anthropic`;
+            if (config.verbose) {
+                logger.debug(`Using session-based proxy URL: ${baseUrl}`);
+            }
+        }
+        process.env.ANTHROPIC_BASE_URL = baseUrl;
+        process.env.ANTHROPIC_API_KEY = config.supatestApiKey;
+        if (config.verbose) {
+            logger.debug(`Using Supatest proxy: ${proxyUrl}/public`);
+            logger.debug(`Supatest API key: ${config.supatestApiKey?.substring(0, 15)}...`);
+        }
         // Allow override via environment variable for testing/debugging
-        if (process.env.CLAUDE_CODE_EXECUTABLE_PATH) {
-            claudeCodePath = process.env.CLAUDE_CODE_EXECUTABLE_PATH;
+        if (envConfig.claudeCodeExecutablePath) {
+            claudeCodePath = envConfig.claudeCodeExecutablePath;
             if (config.verbose) {
                 logger.debug(`Using CLAUDE_CODE_EXECUTABLE_PATH: ${claudeCodePath}`);
             }
@@ -174,22 +216,46 @@ export async function runAgent(config) {
             logger.debug(`  Prompt: ${prompt.substring(0, 100)}${prompt.length > 100 ? '...' : ''}`);
             logger.debug(`  Max turns: ${config.maxIterations}`);
             logger.debug(`  Working directory: ${process.cwd()}`);
-            logger.debug(`  Model: ${process.env.ANTHROPIC_MODEL_NAME || "claude-sonnet-4-5"}`);
+            logger.debug(`  Model: ${envConfig.anthropicModelName}`);
             logger.debug(`  Claude Code executable: ${claudeCodePath}`);
-            logger.debug(`  API Key: ${config.apiKey ? `${config.apiKey.substring(0, 10)}...` : 'not set'}`);
+            logger.debug(`  Supatest API Key: ${config.supatestApiKey?.substring(0, 10)}...`);
             logger.debug(`  Environment ANTHROPIC_API_KEY: ${process.env.ANTHROPIC_API_KEY ? 'set' : 'not set'}`);
         }
+        // Stream initial user message and capture assistant message ID for usage tracking
+        let assistantMessageId;
+        if (eventStreamer && sessionId) {
+            const userMessageEvent = {
+                type: "user_message",
+                content: [{ type: "text", text: prompt }],
+            };
+            const eventResponse = await apiClient.streamEvent(sessionId, userMessageEvent);
+            assistantMessageId = eventResponse.assistantMessageId;
+            if (assistantMessageId && config.verbose) {
+                logger.debug(`Assistant message ID for tracking: ${assistantMessageId}`);
+            }
+        }
         // Run the agent using the SDK
+        // Note: The proxy will automatically look up the message ID via Redis using the API key
         const queryOptions = {
             maxTurns: config.maxIterations,
             cwd: process.cwd(),
-            model: process.env.ANTHROPIC_MODEL_NAME || "claude-sonnet-4-5",
+            model: envConfig.anthropicModelName,
             permissionMode: "bypassPermissions",
             allowDangerouslySkipPermissions: true,
             pathToClaudeCodeExecutable: claudeCodePath,
+            // Enable streaming delta events for real-time updates
+            includePartialMessages: true,
             // Force Node.js runtime even when running from a Bun binary
             // The claude-code-cli.js is a large minified JS file that Bun can't parse correctly
             executable: 'node',
+            // Explicitly pass environment variables to the subprocess
+            env: {
+                ...process.env,
+                ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || '',
+                ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL || '',
+                ANTHROPIC_AUTH_TOKEN: '', // Clear stored OAuth token
+                CLAUDE_CODE_AUTH_TOKEN: '', // Clear any other auth tokens
+            },
             stderr: (msg) => {
                 claudeCodeStderr += msg + "\n";
                 if (config.verbose) {
@@ -197,14 +263,24 @@ export async function runAgent(config) {
                 }
             },
         };
-        if (config.verbose) {
-            logger.debug("\nQuery options:");
-            logger.debug(JSON.stringify(queryOptions, null, 2));
+        // Start initial spinner while waiting for first assistant message (skip in silent mode)
+        if (!logger.isSilent()) {
+            const message = getRandomSpinnerMessage();
+            spinner = ora({
+                spinner: {
+                    interval: 80,
+                    frames: createShimmerFrames(message),
+                }
+            });
+            spinner.start();
         }
         for await (const msg of query({
             prompt,
             options: queryOptions,
         })) {
+            if (config.verbose) {
+                logger.debug(`Received SDK message: ${msg.type}`);
+            }
             // Handle different message types
             if (msg.type === "assistant") {
                 stats.iterations++;
@@ -216,12 +292,41 @@ export async function runAgent(config) {
                 if (Array.isArray(content)) {
                     for (const block of content) {
                         if (block.type === "text") {
-                            console.log(block.text);
+                            logger.raw(block.text);
                             resultText += block.text + "\n";
+                            // WORKAROUND: Since SDK doesn't emit stream_event with includePartialMessages,
+                            // send the complete text as an assistant_text event immediately
+                            if (eventStreamer && block.text) {
+                                const textEvent = {
+                                    type: "assistant_text",
+                                    delta: block.text,
+                                };
+                                await eventStreamer.queueEvent(textEvent);
+                            }
+                        }
+                        else if (block.type === "thinking") {
+                            // Send thinking blocks as well
+                            if (eventStreamer && block.thinking) {
+                                const thinkingEvent = {
+                                    type: "assistant_thinking",
+                                    delta: block.thinking,
+                                };
+                                await eventStreamer.queueEvent(thinkingEvent);
+                            }
                         }
                         else if (block.type === "tool_use") {
                             const toolName = block.name;
                             const input = block.input;
+                            // Stream tool use event
+                            if (eventStreamer) {
+                                const toolUseEvent = {
+                                    type: "tool_use",
+                                    id: block.id,
+                                    name: toolName,
+                                    input: input || {},
+                                };
+                                await eventStreamer.queueEvent(toolUseEvent);
+                            }
                             // Display tool calls to user
                             if (toolName === "Read") {
                                 const filePath = input?.file_path || 'file';
@@ -267,37 +372,60 @@ export async function runAgent(config) {
                                     logger.info("📝 Updated todos");
                                 }
                             }
-                            else {
-                                logger.debug(`🔧 Using tool: ${toolName}`);
-                            }
-                            if (config.verbose) {
-                                logger.debug(`   Input: ${JSON.stringify(input).substring(0, 100)}`);
-                            }
                         }
                     }
                 }
-                console.log("");
+                // Stream message_complete event with full content
+                if (eventStreamer) {
+                    // Flush any pending delta events first to ensure they arrive before message_complete
+                    await eventStreamer.flush();
+                    const messageCompleteEvent = {
+                        type: "message_complete",
+                        message: {
+                            role: "assistant",
+                            content: content, // Cast to avoid type mismatch between SDK and shared types
+                        },
+                    };
+                    await eventStreamer.queueEvent(messageCompleteEvent);
+                }
+                logger.raw("");
                 // Stop and clear previous spinner if it exists
                 if (spinner) {
                     spinner.stop();
                     spinner.clear();
                 }
-                // Create a new spinner instance with a random message
-                const message = getRandomSpinnerMessage();
-                spinner = ora({
-                    spinner: {
-                        interval: 80,
-                        frames: createShimmerFrames(message),
-                    }
-                });
-                spinner.start();
+                // Create a new spinner instance with a random message (skip in silent mode)
+                if (!logger.isSilent()) {
+                    const message = getRandomSpinnerMessage();
+                    spinner = ora({
+                        spinner: {
+                            interval: 80,
+                            frames: createShimmerFrames(message),
+                        }
+                    });
+                    spinner.start();
+                }
             }
             else if (msg.type === "stream_event") {
-                // Handle streaming events
-                if (config.verbose) {
-                    const event = msg.event;
-                    if (event.type === "content_block_start") {
-                        logger.debug("Content block started");
+                // NOTE: This code path is currently not triggered due to an SDK issue with includePartialMessages
+                // We've implemented a workaround above to send text immediately when assistant messages arrive
+                // Keeping this code in case future SDK versions fix the streaming support
+                const event = msg.event;
+                if (event.type === "content_block_delta") {
+                    const delta = event.delta;
+                    if (delta.type === "text_delta" && eventStreamer) {
+                        const textDeltaEvent = {
+                            type: "assistant_text",
+                            delta: delta.text,
+                        };
+                        await eventStreamer.queueEvent(textDeltaEvent);
+                    }
+                    else if (delta.type === "thinking_delta" && eventStreamer) {
+                        const thinkingDeltaEvent = {
+                            type: "assistant_thinking",
+                            delta: delta.thinking,
+                        };
+                        await eventStreamer.queueEvent(thinkingDeltaEvent);
                     }
                 }
             }
@@ -318,10 +446,6 @@ export async function runAgent(config) {
                             logger.error(error);
                         }
                     }
-                    if (config.verbose) {
-                        logger.debug("Result message details:");
-                        logger.debug(JSON.stringify(msg, null, 2));
-                    }
                 }
             }
         }
@@ -329,6 +453,16 @@ export async function runAgent(config) {
             spinner.stop();
         }
         stats.endTime = Date.now();
+        // Complete usage tracking for this message turn
+        if (assistantMessageId && apiClient) {
+            try {
+                await apiClient.completeUsage(assistantMessageId);
+            }
+            catch (error) {
+                logger.warn(`Failed to complete usage tracking: ${error.message}`);
+                // Don't fail the task if usage tracking fails
+            }
+        }
         // Generate result
         const result = {
             success: !hasError && stats.errors.length === 0,
@@ -337,9 +471,31 @@ export async function runAgent(config) {
             iterations: stats.iterations,
             error: stats.errors.length > 0 ? stats.errors.join("; ") : undefined,
         };
+        // Stream session completion or error
+        if (eventStreamer) {
+            if (result.success) {
+                await eventStreamer.queueEvent({ type: "session_complete" });
+            }
+            else {
+                await eventStreamer.queueEvent({
+                    type: "session_error",
+                    error: result.error || "Unknown error",
+                });
+            }
+            // Flush and shutdown event streamer
+            await eventStreamer.shutdown();
+        }
         // Print summary
         const summaryText = generateSummary(stats, result, config.verbose);
-        console.log(summaryText);
+        logger.raw(summaryText);
+        // Display web URL again at the end if available
+        if (webUrl) {
+            logger.raw("");
+            logger.divider();
+            logger.raw(chalk.white.bold("Continue on web: ") +
+                chalk.cyan.underline(webUrl));
+            logger.divider();
+        }
         return result;
     }
     catch (error) {
@@ -401,7 +557,7 @@ export async function runAgent(config) {
             }
         }
         if (config.verbose && error instanceof Error && error.stack) {
-            console.error(error.stack);
+            logger.error(error.stack);
         }
         const result = {
             success: false,
@@ -410,8 +566,24 @@ export async function runAgent(config) {
             iterations: stats.iterations,
             error: errorMessage,
         };
+        // Stream session error and shutdown event streamer
+        if (eventStreamer) {
+            await eventStreamer.queueEvent({
+                type: "session_error",
+                error: errorMessage,
+            });
+            await eventStreamer.shutdown();
+        }
         const summaryText = generateSummary(stats, result, config.verbose);
-        console.log(summaryText);
+        logger.raw(summaryText);
+        // Display web URL at the end if available
+        if (webUrl) {
+            logger.raw("");
+            logger.divider();
+            logger.raw(chalk.white.bold("View session: ") +
+                chalk.cyan.underline(webUrl));
+            logger.divider();
+        }
         return result;
     }
 }