@supatest/cli 0.0.4 → 0.0.5

package/dist/modes/headless.js

@@ -0,0 +1,117 @@
+import chalk from "chalk";
+import { config as envConfig } from "../config";
+import { CoreAgent } from "../core/agent";
+import { CompositePresenter } from "../presenters/composite";
+import { ConsolePresenter } from "../presenters/console";
+import { WebPresenter } from "../presenters/web";
+import { ApiClient } from "../services/api-client";
+import { logger } from "../utils/logger";
+import { CLI_VERSION } from "../version";
+export async function runAgent(config) {
+    // Configure logger
+    logger.setVerbose(config.verbose);
+    // --- Metadata Display (CLI only) ---
+    logger.raw("");
+    // Get git branch if available
+    let gitBranch = "";
+    try {
+        const { execSync } = await import("node:child_process");
+        gitBranch = execSync("git rev-parse --abbrev-ref HEAD", {
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "ignore"]
+        }).trim();
+    }
+    catch {
+        // Not in a git repo or git not available
+    }
+    const metadataParts = [
+        chalk.dim("Supatest AI ") + chalk.cyan(`v${CLI_VERSION}`),
+        chalk.dim("Model: ") + chalk.cyan(envConfig.anthropicModelName),
+    ];
+    if (gitBranch) {
+        metadataParts.push(chalk.dim("Branch: ") + chalk.cyan(gitBranch));
+    }
+    logger.raw(metadataParts.join(chalk.dim(" • ")));
+    logger.divider();
+    // --- Session & API Setup ---
+    const apiUrl = config.supatestApiUrl || "https://code-api.supatest.ai";
+    const apiClient = new ApiClient(apiUrl, config.supatestApiKey);
+    let sessionId;
+    let webUrl;
+    try {
+        // Truncate title to 50 characters (backend will auto-generate a better title later)
+        const truncatedTitle = config.task.length > 50 ? config.task.slice(0, 50) + "..." : config.task;
+        const session = await apiClient.createSession(truncatedTitle, {
+            cliVersion: CLI_VERSION,
+            cwd: config.cwd || process.cwd(),
+        });
+        sessionId = session.sessionId;
+        webUrl = session.webUrl;
+        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...");
+    }
+    // --- Environment Setup ---
+    // Build base URL with session ID embedded for the proxy
+    let baseUrl = `${apiUrl}/public`;
+    if (sessionId) {
+        baseUrl = `${apiUrl}/v1/sessions/${sessionId}/anthropic`;
+    }
+    // Set environment variables for the SDK to pick up (via CoreAgent)
+    process.env.ANTHROPIC_BASE_URL = baseUrl;
+    process.env.ANTHROPIC_API_KEY = config.supatestApiKey;
+    // --- Agent Execution ---
+    const presenters = [];
+    // 1. Console Presenter (stdout)
+    presenters.push(new ConsolePresenter({ verbose: config.verbose }));
+    // 2. Web Presenter (streaming)
+    if (sessionId) {
+        presenters.push(new WebPresenter(apiClient, sessionId));
+    }
+    const compositePresenter = new CompositePresenter(presenters);
+    const agent = new CoreAgent(compositePresenter);
+    try {
+        const result = await agent.run(config);
+        // Store the provider session ID for future resume capability
+        // This allows follow-up messages to continue the conversation with full context
+        if (sessionId && result.providerSessionId) {
+            try {
+                await apiClient.updateSession(sessionId, {
+                    providerSessionId: result.providerSessionId,
+                });
+                logger.debug(`Stored provider session ID for resume capability`);
+            }
+            catch (updateError) {
+                // Non-critical - log but don't fail
+                logger.warn(`Failed to store provider session ID: ${updateError.message}`);
+            }
+        }
+        // Display web URL again at completion
+        if (webUrl) {
+            logger.raw("");
+            logger.divider();
+            logger.raw(chalk.white.bold("View session: ") +
+                chalk.cyan.underline(webUrl));
+            logger.divider();
+        }
+        return result;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Error is already logged by presenter.onError
+        return {
+            success: false,
+            summary: `Failed: ${errorMessage}`,
+            filesModified: [],
+            iterations: 0,
+            error: errorMessage,
+        };
+    }
+}

package/dist/modes/interactive.js

@@ -0,0 +1,418 @@
+/**
+ * Interactive mode entry point
+ * Launches the Ink UI and runs the agent with real-time updates
+ */
+import { render } from "ink";
+import React, { useEffect, useRef } from "react";
+import { config as envConfig } from "../config";
+import { CoreAgent } from "../core/agent";
+import { ReactPresenter } from "../presenters/react";
+import { ApiClient, ApiError } from "../services/api-client";
+import { App } from "../ui/App";
+import { KeypressProvider } from "../ui/contexts/KeypressContext";
+import { MouseProvider } from "../ui/contexts/MouseContext";
+import { SessionProvider, useSession } from "../ui/contexts/SessionContext";
+import { useBracketedPaste } from "../ui/hooks/useBracketedPaste";
+import { disableMouseEvents, enableMouseEvents } from "../ui/utils/mouse";
+import { logger } from "../utils/logger";
+import { createInkStdio, patchStdio } from "../utils/stdio";
+import { CLI_VERSION } from "../version";
+/**
+ * Get human-readable description for tool call (used when resuming sessions)
+ */
+function getToolDescription(toolName, input) {
+    switch (toolName) {
+        case "Read":
+            return input?.file_path || "file";
+        case "Write":
+            return input?.file_path || "file";
+        case "Edit":
+            return input?.file_path || "file";
+        case "Bash": {
+            const cmd = input?.command || "";
+            return cmd.length > 60 ? `${cmd.substring(0, 60)}...` : cmd;
+        }
+        case "Glob":
+            return `pattern: "${input?.pattern || "files"}"`;
+        case "Grep": {
+            const pattern = input?.pattern || "code";
+            const path = input?.path;
+            return path ? `"${pattern}" (in ${path})` : `"${pattern}"`;
+        }
+        case "Task":
+            return input?.subagent_type || "task";
+        case "TodoWrite":
+            return "Updated todos";
+        case "BashOutput":
+        case "Command Output":
+            return input?.bash_id || "shell output";
+        default:
+            return toolName;
+    }
+}
+/**
+ * Agent Runner Component
+ * Runs the agent via CoreAgent and updates the UI context in real-time
+ */
+const AgentRunner = ({ config, sessionId, apiClient, onComplete }) => {
+    const { addMessage, updateLastMessage, updateMessageByToolId, setIsAgentRunning, updateStats, setTodos, shouldInterruptAgent, setShouldInterruptAgent, agentMode, planFilePath, } = useSession();
+    // Keep a ref to the agent so we can call abort()
+    const agentRef = useRef(null);
+    // When shouldInterruptAgent changes to true, abort the agent
+    useEffect(() => {
+        if (shouldInterruptAgent && agentRef.current) {
+            agentRef.current.abort();
+            setShouldInterruptAgent(false);
+        }
+    }, [shouldInterruptAgent, setShouldInterruptAgent]);
+    useEffect(() => {
+        let isMounted = true;
+        const runAgent = async () => {
+            setIsAgentRunning(true);
+            try {
+                // Set up environment for Claude Code
+                const proxyUrl = config.supatestApiUrl || "https://code-api.supatest.ai";
+                const baseUrl = `${proxyUrl}/v1/sessions/${sessionId}/anthropic`;
+                process.env.ANTHROPIC_BASE_URL = baseUrl;
+                process.env.ANTHROPIC_API_KEY = config.supatestApiKey;
+                // Create presenter with callbacks to React state
+                const presenter = new ReactPresenter({
+                    addMessage: (msg) => {
+                        if (isMounted)
+                            addMessage(msg);
+                    },
+                    updateLastMessage: (update) => {
+                        if (isMounted)
+                            updateLastMessage(update);
+                    },
+                    updateMessageByToolId: (toolId, update) => {
+                        if (isMounted)
+                            updateMessageByToolId(toolId, update);
+                    },
+                    updateStats: (stats) => {
+                        if (isMounted)
+                            updateStats(stats);
+                    },
+                    setTodos: (todos) => {
+                        if (isMounted)
+                            setTodos(todos);
+                    },
+                    // Note: onComplete is now called after agent.run() returns
+                    // to capture the providerSessionId from the result
+                    onComplete: () => { },
+                }, apiClient, sessionId, config.verbose);
+                // Build mode-specific configuration
+                // Plan mode uses planSystemPrompt and restricts to read-only tools
+                const runConfig = {
+                    ...config,
+                    mode: agentMode,
+                    planFilePath,
+                    systemPromptAppend: agentMode === 'plan'
+                        ? envConfig.planSystemPrompt
+                        : config.systemPromptAppend,
+                };
+                // Run the agent through CoreAgent
+                // Store ref so we can abort from interrupt effect
+                const agent = new CoreAgent(presenter);
+                agentRef.current = agent;
+                const result = await agent.run(runConfig);
+                // Pass providerSessionId on completion for storage
+                if (isMounted) {
+                    onComplete(result.success, result.providerSessionId);
+                }
+            }
+            catch (error) {
+                if (isMounted) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    addMessage({
+                        type: "error",
+                        content: errorMessage,
+                        errorType: "error",
+                    });
+                    await apiClient.streamEvent(sessionId, {
+                        type: "session_error",
+                        error: errorMessage,
+                    });
+                    onComplete(false);
+                }
+            }
+            finally {
+                if (isMounted) {
+                    setIsAgentRunning(false);
+                }
+            }
+        };
+        runAgent();
+        return () => {
+            isMounted = false;
+            agentRef.current = null;
+        };
+    }, []); // eslint-disable-line react-hooks/exhaustive-deps
+    return null; // This component doesn't render anything
+};
+/**
+ * Content component for InteractiveApp that has access to SessionContext
+ */
+const InteractiveAppContent = ({ config, sessionId: initialSessionId, webUrl, apiClient, onExit }) => {
+    const { addMessage, loadMessages, setSessionId: setContextSessionId, } = useSession();
+    const [sessionId, setSessionId] = React.useState(initialSessionId);
+    const [currentTask, setCurrentTask] = React.useState(config.task);
+    const [taskId, setTaskId] = React.useState(0);
+    const [shouldRunAgent, setShouldRunAgent] = React.useState(!!config.task);
+    const [taskQueue, setTaskQueue] = React.useState([]);
+    // Track provider session ID for resume capability
+    const [providerSessionId, setProviderSessionId] = React.useState();
+    const handleSubmitTask = async (task) => {
+        // Create session on first message if it doesn't exist
+        if (!sessionId) {
+            try {
+                const truncatedTitle = task.length > 50 ? task.slice(0, 50) + "..." : task;
+                const session = await apiClient.createSession(truncatedTitle, {
+                    cliVersion: CLI_VERSION,
+                    cwd: config.cwd || process.cwd(),
+                });
+                setSessionId(session.sessionId);
+                setContextSessionId(session.sessionId);
+            }
+            catch (error) {
+                const errorMessage = error instanceof ApiError
+                    ? error.message
+                    : `Failed to create session: ${error instanceof Error ? error.message : String(error)}`;
+                addMessage({
+                    type: "error",
+                    content: errorMessage,
+                    errorType: error instanceof ApiError && error.isAuthError ? "warning" : "error",
+                });
+                return;
+            }
+        }
+        if (shouldRunAgent) {
+            setTaskQueue((prev) => [...prev, task]);
+        }
+        else {
+            setCurrentTask(task);
+            addMessage({
+                type: "user",
+                content: task,
+            });
+            setTaskId((prev) => prev + 1);
+            setShouldRunAgent(true);
+        }
+    };
+    const handleAgentComplete = async (_success, newProviderSessionId) => {
+        setShouldRunAgent(false);
+        // Store the provider session ID for future resume capability
+        if (sessionId && newProviderSessionId && newProviderSessionId !== providerSessionId) {
+            setProviderSessionId(newProviderSessionId);
+            try {
+                await apiClient.updateSession(sessionId, {
+                    providerSessionId: newProviderSessionId,
+                });
+            }
+            catch {
+                // Non-critical - session will work without resume capability
+            }
+        }
+    };
+    // Process queued tasks when agent becomes idle
+    React.useEffect(() => {
+        if (!shouldRunAgent && taskQueue.length > 0) {
+            const [nextTask, ...remaining] = taskQueue;
+            setTaskQueue(remaining);
+            setCurrentTask(nextTask);
+            addMessage({
+                type: "user",
+                content: nextTask,
+            });
+            setTaskId((prev) => prev + 1);
+            setShouldRunAgent(true);
+        }
+    }, [shouldRunAgent, taskQueue, addMessage]);
+    return (React.createElement(React.Fragment, null,
+        React.createElement(App, { apiClient: apiClient, config: { ...config, task: currentTask }, onExit: onExit, onResumeSession: async (session) => {
+                try {
+                    if (!apiClient) {
+                        addMessage({
+                            type: "error",
+                            content: "API client not available. Cannot resume session.",
+                            errorType: "error",
+                        });
+                        return;
+                    }
+                    const response = await apiClient.getSessionMessages(session.id);
+                    const apiMessages = response.messages;
+                    // First pass: collect all tool_results by tool_use_id
+                    const toolResults = new Map();
+                    for (const msg of apiMessages) {
+                        const contentBlocks = msg.content;
+                        if (!contentBlocks)
+                            continue;
+                        for (const block of contentBlocks) {
+                            if (block.type === "tool_result" && block.tool_use_id) {
+                                // Extract text content from tool result
+                                let resultText = "";
+                                if (typeof block.content === "string") {
+                                    resultText = block.content;
+                                }
+                                else if (Array.isArray(block.content)) {
+                                    resultText = block.content
+                                        .map((c) => c.text || "")
+                                        .join("\n");
+                                }
+                                toolResults.set(block.tool_use_id, resultText);
+                            }
+                        }
+                    }
+                    // Convert API messages to UI Message format
+                    const uiMessages = apiMessages.flatMap((msg) => {
+                        const messages = [];
+                        const contentBlocks = msg.content;
+                        if (!contentBlocks || contentBlocks.length === 0) {
+                            return [];
+                        }
+                        for (const block of contentBlocks) {
+                            if (block.type === "text") {
+                                messages.push({
+                                    id: `${msg.id}-${messages.length}`,
+                                    type: msg.role,
+                                    content: block.text,
+                                    timestamp: new Date(msg.createdAt).getTime(),
+                                });
+                            }
+                            else if (block.type === "thinking") {
+                                messages.push({
+                                    id: `${msg.id}-${messages.length}`,
+                                    type: "thinking",
+                                    content: block.thinking,
+                                    timestamp: new Date(msg.createdAt).getTime(),
+                                });
+                            }
+                            else if (block.type === "tool_use") {
+                                // Look up the tool result for this tool_use
+                                const toolResult = toolResults.get(block.id);
+                                messages.push({
+                                    id: `${msg.id}-${messages.length}`,
+                                    type: "tool",
+                                    content: getToolDescription(block.name, block.input),
+                                    toolName: block.name,
+                                    toolInput: block.input,
+                                    toolResult: toolResult,
+                                    toolUseId: block.id,
+                                    timestamp: new Date(msg.createdAt).getTime(),
+                                });
+                            }
+                        }
+                        return messages;
+                    });
+                    setSessionId(session.id);
+                    setContextSessionId(session.id);
+                    // Set the provider session ID for resume capability
+                    // The session object may have providerSessionId from the API
+                    if (session.providerSessionId) {
+                        setProviderSessionId(session.providerSessionId);
+                    }
+                    uiMessages.push({
+                        id: `resume-info-${Date.now()}`,
+                        type: "error",
+                        content: `Resumed session: ${session.title || "Untitled"} (${apiMessages.length} messages loaded)`,
+                        errorType: "info",
+                        timestamp: Date.now(),
+                    });
+                    loadMessages(uiMessages);
+                }
+                catch (error) {
+                    const errorMessage = error instanceof ApiError
+                        ? error.message
+                        : `Failed to resume session: ${error instanceof Error ? error.message : String(error)}`;
+                    addMessage({
+                        type: "error",
+                        content: errorMessage,
+                        errorType: error instanceof ApiError && error.isAuthError
+                            ? "warning"
+                            : "error",
+                    });
+                }
+            }, onSubmitTask: handleSubmitTask, queuedTasks: taskQueue, sessionId: sessionId, webUrl: webUrl }),
+        shouldRunAgent && currentTask && sessionId && (React.createElement(AgentRunner, { apiClient: apiClient, config: { ...config, task: currentTask, providerSessionId }, key: `${taskId}`, onComplete: handleAgentComplete, sessionId: sessionId }))));
+};
+/**
+ * Main wrapper component that combines UI and agent
+ */
+const InteractiveApp = (props) => {
+    useBracketedPaste();
+    return (React.createElement(KeypressProvider, null,
+        React.createElement(MouseProvider, { mouseEventsEnabled: true },
+            React.createElement(SessionProvider, null,
+                React.createElement(InteractiveAppContent, { ...props })))));
+};
+/**
+ * Run the interactive mode with Ink UI
+ */
+export async function runInteractive(config) {
+    let success = false;
+    let unmountFn = null;
+    let isExiting = false;
+    const cleanupStdio = patchStdio();
+    const gracefulExit = async (exitCode) => {
+        if (isExiting)
+            return;
+        isExiting = true;
+        disableMouseEvents();
+        cleanupStdio();
+        if (unmountFn) {
+            unmountFn();
+        }
+        process.exit(exitCode);
+    };
+    const handleSigInt = async () => {
+        await gracefulExit(0);
+    };
+    process.on("SIGINT", handleSigInt);
+    process.on("SIGTERM", handleSigInt);
+    const isDev = process.env.NODE_ENV === "development";
+    logger.enableFileLogging(isDev);
+    const apiUrl = config.supatestApiUrl || "https://code-api.supatest.ai";
+    const apiClient = new ApiClient(apiUrl, config.supatestApiKey);
+    try {
+        process.stdout.write("\x1Bc");
+        console.clear();
+        enableMouseEvents();
+        const { stdout: inkStdout, stderr: inkStderr } = createInkStdio();
+        let sessionId;
+        let webUrl;
+        if (config.task) {
+            const truncatedTitle = config.task.length > 50 ? config.task.slice(0, 50) + "..." : config.task;
+            const session = await apiClient.createSession(truncatedTitle, {
+                cliVersion: CLI_VERSION,
+                cwd: config.cwd || process.cwd(),
+            });
+            sessionId = session.sessionId;
+            webUrl = session.webUrl;
+        }
+        const { unmount, waitUntilExit } = render(React.createElement(InteractiveApp, { apiClient: apiClient, config: config, onExit: (exitSuccess) => {
+                success = exitSuccess;
+            }, sessionId: sessionId, webUrl: webUrl }), {
+            stdout: inkStdout,
+            stderr: inkStderr,
+            stdin: process.stdin,
+            alternateBuffer: true,
+            exitOnCtrlC: false,
+        });
+        unmountFn = unmount;
+        await waitUntilExit();
+        unmount();
+        disableMouseEvents();
+        cleanupStdio();
+        process.off("SIGINT", handleSigInt);
+        process.off("SIGTERM", handleSigInt);
+        process.exit(success ? 0 : 1);
+    }
+    catch (error) {
+        disableMouseEvents();
+        cleanupStdio();
+        process.off("SIGINT", handleSigInt);
+        process.off("SIGTERM", handleSigInt);
+        console.error("Failed to start interactive mode:", error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

package/dist/presenters/composite.js

@@ -0,0 +1,32 @@
+export class CompositePresenter {
+    presenters;
+    constructor(presenters) {
+        this.presenters = presenters;
+    }
+    async onStart(config) {
+        await Promise.all(this.presenters.map((p) => p.onStart(config)));
+    }
+    onLog(message) {
+        for (const p of this.presenters) {
+            p.onLog(message);
+        }
+    }
+    async onAssistantText(text) {
+        await Promise.all(this.presenters.map((p) => p.onAssistantText(text)));
+    }
+    async onThinking(text) {
+        await Promise.all(this.presenters.map((p) => p.onThinking(text)));
+    }
+    async onToolUse(tool, input, toolId) {
+        await Promise.all(this.presenters.map((p) => p.onToolUse(tool, input, toolId)));
+    }
+    async onTurnComplete(content) {
+        await Promise.all(this.presenters.map((p) => p.onTurnComplete(content)));
+    }
+    async onError(error) {
+        await Promise.all(this.presenters.map((p) => p.onError(error)));
+    }
+    async onComplete(result) {
+        await Promise.all(this.presenters.map((p) => p.onComplete(result)));
+    }
+}