@supatest/cli 0.0.2 → 0.0.3

package/dist/services/api-client.js

@@ -0,0 +1,244 @@
+import { logger } from "../utils/logger";
+/**
+ * API Error class with user-friendly messages
+ *
+ * Based on Gemini CLI (Apache 2.0 License)
+ * https://github.com/google-gemini/gemini-cli
+ * Copyright 2025 Google LLC
+ */
+export class ApiError extends Error {
+    status;
+    isAuthError;
+    constructor(status, statusText, body) {
+        let message;
+        if (status === 401) {
+            message = "Authentication required. Use /login to authenticate.";
+        }
+        else if (status === 403) {
+            message = "Access denied. Your token may have been revoked.";
+        }
+        else {
+            message = `API error: ${status} ${statusText}`;
+            if (body) {
+                // Try to extract a cleaner error message from JSON body
+                try {
+                    const parsed = JSON.parse(body);
+                    if (parsed.error) {
+                        message = parsed.error;
+                    }
+                    else if (parsed.message) {
+                        message = parsed.message;
+                    }
+                }
+                catch {
+                    // If not JSON, append raw body if short
+                    if (body.length < 200) {
+                        message += ` - ${body}`;
+                    }
+                }
+            }
+        }
+        super(message);
+        this.name = "ApiError";
+        this.status = status;
+        this.isAuthError = status === 401 || status === 403;
+    }
+}
+/**
+ * API Client for CLI to communicate with Supatest backend
+ */
+export class ApiClient {
+    apiUrl;
+    apiKey;
+    constructor(apiUrl, apiKey) {
+        this.apiUrl = apiUrl;
+        this.apiKey = apiKey;
+    }
+    /**
+     * Update the API key (used when user logs in during session)
+     */
+    setApiKey(apiKey) {
+        this.apiKey = apiKey;
+    }
+    /**
+     * Clear the API key (used when user logs out)
+     */
+    clearApiKey() {
+        this.apiKey = undefined;
+    }
+    /**
+     * Check if the client has an API key set
+     */
+    hasApiKey() {
+        return !!this.apiKey;
+    }
+    /**
+     * Create a new CLI session on the backend
+     * @param title - The session title
+     * @param originMetadata - Optional metadata about the session origin
+     * @returns The session ID and web URL
+     */
+    async createSession(title, originMetadata) {
+        const url = `${this.apiUrl}/v1/agent/sessions`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                title,
+                originMetadata,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new ApiError(response.status, response.statusText, errorText);
+        }
+        const data = await response.json();
+        return data;
+    }
+    /**
+     * Stream an event to the backend
+     * @param sessionId - The session ID
+     * @param event - The CLI event to stream
+     * @returns Success status
+     */
+    async streamEvent(sessionId, event) {
+        const url = `${this.apiUrl}/v1/agent/sessions/${sessionId}/events`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify(event),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new ApiError(response.status, response.statusText, errorText);
+        }
+        const data = await response.json();
+        return data;
+    }
+    /**
+     * Get session details from the backend
+     * @param sessionId - The session ID
+     * @returns Session details
+     */
+    async getSession(sessionId) {
+        const url = `${this.apiUrl}/v1/agent/sessions/${sessionId}`;
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new ApiError(response.status, response.statusText, errorText);
+        }
+        return await response.json();
+    }
+    /**
+     * Get paginated sessions accessible to the user
+     * @param limit - Maximum number of sessions to return
+     * @param offset - Number of sessions to skip
+     * @returns Paginated sessions with total count
+     */
+    async getSessions(limit, offset) {
+        const urlParams = new URLSearchParams({
+            limit: limit.toString(),
+            offset: offset.toString(),
+        });
+        const url = `${this.apiUrl}/v1/sessions?${urlParams.toString()}`;
+        logger.debug(`Fetching sessions: ${url}`);
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new ApiError(response.status, response.statusText, errorText);
+        }
+        const data = await response.json();
+        logger.debug(`Fetched ${data.sessions.length} sessions (${data.pagination.offset + 1}-${data.pagination.offset + data.sessions.length} of ${data.pagination.total})`);
+        return data;
+    }
+    /**
+     * Complete usage tracking for a message turn
+     * @param messageId - The assistant message ID
+     * @returns Success status
+     */
+    async completeUsage(messageId) {
+        const url = `${this.apiUrl}/v1/usage/complete`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({ messageId }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            logger.warn(`Failed to complete usage tracking: ${response.status} ${response.statusText} - ${errorText}`);
+            // Don't throw - this is best effort
+            return { success: false };
+        }
+        const data = await response.json();
+        return data;
+    }
+    /**
+     * Get messages for a session
+     * @param sessionId - The session ID
+     * @returns Messages with pagination info
+     */
+    async getSessionMessages(sessionId) {
+        const url = `${this.apiUrl}/v1/sessions/${sessionId}/messages`;
+        logger.debug(`Fetching messages for session: ${sessionId}`);
+        const response = await fetch(url, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new ApiError(response.status, response.statusText, errorText);
+        }
+        const data = await response.json();
+        logger.debug(`Fetched ${data.messages.length} messages for session: ${sessionId}`);
+        return data;
+    }
+    /**
+     * Update a session (title, providerSessionId)
+     * @param sessionId - The session ID
+     * @param data - The data to update
+     * @returns Updated session
+     */
+    async updateSession(sessionId, data) {
+        const url = `${this.apiUrl}/v1/sessions/${sessionId}`;
+        logger.debug(`Updating session: ${sessionId}`, {
+            hasTitle: !!data.title,
+            hasProviderSessionId: !!data.providerSessionId,
+        });
+        const response = await fetch(url, {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify(data),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new ApiError(response.status, response.statusText, errorText);
+        }
+        const result = await response.json();
+        logger.debug(`Session updated: ${sessionId}`);
+        return result;
+    }
+}

package/dist/services/event-streamer.js

@@ -0,0 +1,130 @@
+import { logger } from "../utils/logger";
+const BATCH_SIZE = 10; // Send events every 10 events
+const BATCH_INTERVAL_MS = 100; // Or every 100ms, whichever comes first
+const MAX_RETRY_ATTEMPTS = 3;
+const RETRY_DELAY_MS = 1000; // Start with 1s delay
+/**
+ * Event Streamer - Batches and streams CLI events to the backend with retry logic
+ */
+export class EventStreamer {
+    apiClient;
+    sessionId;
+    eventQueue = [];
+    batchTimer = null;
+    isFlushing = false;
+    isShutdown = false;
+    constructor(apiClient, sessionId) {
+        this.apiClient = apiClient;
+        this.sessionId = sessionId;
+    }
+    /**
+     * Queue an event for streaming
+     * @param event - The CLI event to queue
+     */
+    async queueEvent(event) {
+        if (this.isShutdown) {
+            logger.warn("EventStreamer is shutdown, cannot queue event");
+            return;
+        }
+        // Send streaming delta events immediately for real-time updates
+        // Batch other events to reduce API calls
+        if (event.type === "assistant_text" || event.type === "assistant_thinking") {
+            await this.sendEventWithRetry(event);
+            return;
+        }
+        this.eventQueue.push(event);
+        // Flush if we've reached batch size
+        if (this.eventQueue.length >= BATCH_SIZE) {
+            await this.flush();
+        }
+        else {
+            // Reset the batch timer
+            this.resetBatchTimer();
+        }
+    }
+    /**
+     * Reset the batch timer
+     */
+    resetBatchTimer() {
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+        }
+        this.batchTimer = setTimeout(() => {
+            this.flush().catch((error) => {
+                logger.error(`Failed to flush events on timer: ${error.message}`);
+            });
+        }, BATCH_INTERVAL_MS);
+    }
+    /**
+     * Flush all queued events to the backend
+     */
+    async flush() {
+        if (this.isFlushing || this.eventQueue.length === 0) {
+            return;
+        }
+        this.isFlushing = true;
+        // Clear the batch timer
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = null;
+        }
+        // Take all events from the queue
+        const eventsToSend = [...this.eventQueue];
+        this.eventQueue = [];
+        // Send each event with retry logic
+        for (const event of eventsToSend) {
+            await this.sendEventWithRetry(event);
+        }
+        this.isFlushing = false;
+    }
+    /**
+     * Send a single event with retry logic
+     * @param event - The event to send
+     */
+    async sendEventWithRetry(event) {
+        let attempts = 0;
+        let lastError = null;
+        while (attempts < MAX_RETRY_ATTEMPTS) {
+            try {
+                await this.apiClient.streamEvent(this.sessionId, event);
+                return; // Success
+            }
+            catch (error) {
+                lastError = error;
+                attempts++;
+                if (attempts < MAX_RETRY_ATTEMPTS) {
+                    const delay = RETRY_DELAY_MS * Math.pow(2, attempts - 1); // Exponential backoff
+                    logger.warn(`Failed to stream event (attempt ${attempts}/${MAX_RETRY_ATTEMPTS}), retrying in ${delay}ms...`);
+                    await this.sleep(delay);
+                }
+            }
+        }
+        // All retries failed
+        logger.error(`Failed to stream event after ${MAX_RETRY_ATTEMPTS} attempts: ${lastError?.message}`);
+        // Don't throw - continue processing other events
+        // The event is lost, but we don't want to crash the CLI
+    }
+    /**
+     * Sleep for a given duration
+     * @param ms - Duration in milliseconds
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Shutdown the event streamer and flush any remaining events
+     */
+    async shutdown() {
+        if (this.isShutdown) {
+            return;
+        }
+        this.isShutdown = true;
+        // Clear the batch timer
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = null;
+        }
+        // Flush any remaining events
+        await this.flush();
+    }
+}

package/dist/ui/App.js

@@ -0,0 +1,322 @@
+/**
+ * Main App Component
+ * Root component for the interactive CLI UI
+ */
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+import { Box, Text, useApp, useInput } from "ink";
+import React, { useEffect, useRef, useState } from "react";
+import { loginCommand } from "../commands/login.js";
+import { setupCommand } from "../commands/setup.js";
+import { isLoggedIn, removeToken, saveToken, } from "../utils/token-storage.js";
+import { AuthBanner } from "./components/AuthBanner.js";
+import { AuthDialog } from "./components/AuthDialog.js";
+import { HelpMenu } from "./components/HelpMenu.js";
+import { InputPrompt } from "./components/InputPrompt.js";
+import { MessageList } from "./components/MessageList.js";
+import { QueuedMessageDisplay } from "./components/QueuedMessageDisplay.js";
+import { SessionSelector } from "./components/SessionSelector.js";
+import { useSession } from "./contexts/SessionContext.js";
+import { useModeToggle } from "./hooks/useModeToggle.js";
+import { AuthState } from "./types/auth.js";
+const getGitBranch = () => {
+    try {
+        return execSync("git rev-parse --abbrev-ref HEAD", { encoding: "utf8" }).trim();
+    }
+    catch {
+        return "";
+    }
+};
+const getCurrentFolder = () => {
+    const cwd = process.cwd();
+    const home = homedir();
+    if (cwd.startsWith(home)) {
+        return `~${cwd.slice(home.length)}`;
+    }
+    return cwd;
+};
+/**
+ * Main app content (inside SessionProvider)
+ */
+const AppContent = ({ config, sessionId, webUrl, queuedTasks = [], onExit, onSubmitTask, apiClient, onResumeSession }) => {
+    const { exit } = useApp();
+    const { addMessage, clearMessages, isAgentRunning, messages, setSessionId, setWebUrl, setShouldInterruptAgent, toggleAllToolOutputs, allToolsExpanded } = useSession();
+    // Enable Shift+Tab mode toggle
+    useModeToggle();
+    const [terminalWidth, setTerminalWidth] = useState(process.stdout.columns || 80);
+    const [terminalHeight, setTerminalHeight] = useState(process.stdout.rows || 24);
+    const [showHelp, setShowHelp] = useState(false);
+    const [showInput, setShowInput] = useState(true); // Always show input
+    const [gitBranch] = useState(() => getGitBranch());
+    const [currentFolder] = useState(() => getCurrentFolder());
+    const [hasInputContent, setHasInputContent] = useState(false);
+    const [exitWarning, setExitWarning] = useState(null);
+    const inputPromptRef = useRef(null);
+    const [showSessionSelector, setShowSessionSelector] = useState(false);
+    // Auth state
+    const [authState, setAuthState] = useState(() => isLoggedIn() ? AuthState.Authenticated : AuthState.Unauthenticated);
+    const [showAuthDialog, setShowAuthDialog] = useState(false);
+    // Show auth dialog on first start if unauthenticated and no API key provided
+    useEffect(() => {
+        if (!isLoggedIn() && !config.supatestApiKey) {
+            setShowAuthDialog(true);
+        }
+    }, [config.supatestApiKey]);
+    // Initialize session data
+    useEffect(() => {
+        if (sessionId) {
+            setSessionId(sessionId);
+        }
+        if (webUrl) {
+            setWebUrl(webUrl);
+        }
+    }, [sessionId, webUrl, setSessionId, setWebUrl]);
+    // Handle login flow
+    const handleLogin = async () => {
+        setShowAuthDialog(false);
+        setAuthState(AuthState.Authenticating);
+        addMessage({
+            type: "assistant",
+            content: "Opening browser for authentication...",
+        });
+        try {
+            const result = await loginCommand();
+            saveToken(result.token, result.expiresAt);
+            // Update ApiClient with the new token
+            if (apiClient) {
+                apiClient.setApiKey(result.token);
+            }
+            setAuthState(AuthState.Authenticated);
+            addMessage({
+                type: "assistant",
+                content: "Successfully logged in!",
+            });
+        }
+        catch (error) {
+            setAuthState(AuthState.Unauthenticated);
+            addMessage({
+                type: "error",
+                content: `Login failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+                errorType: "error",
+            });
+        }
+    };
+    // Handle task submission from input prompt
+    const handleSubmitTask = async (task) => {
+        const trimmedTask = task.trim();
+        // Handle Slash Commands
+        if (trimmedTask.startsWith("/")) {
+            const command = trimmedTask.toLowerCase();
+            if (command === "/clear") {
+                clearMessages();
+                return;
+            }
+            if (command === "/exit") {
+                exit();
+                onExit(true);
+                return;
+            }
+            if (command === "/help" || command === "/?") {
+                setShowHelp((prev) => !prev);
+                return;
+            }
+            if (command === "/login") {
+                if (authState === AuthState.Authenticated) {
+                    addMessage({
+                        type: "assistant",
+                        content: "Already logged in. Use /logout first to log out.",
+                    });
+                    return;
+                }
+                setShowAuthDialog(true);
+                return;
+            }
+            if (command === "/logout") {
+                if (authState !== AuthState.Authenticated) {
+                    addMessage({
+                        type: "assistant",
+                        content: "Not currently logged in.",
+                    });
+                    return;
+                }
+                removeToken();
+                // Clear ApiClient token to prevent further API calls
+                if (apiClient) {
+                    apiClient.clearApiKey();
+                }
+                setAuthState(AuthState.Unauthenticated);
+                addMessage({
+                    type: "assistant",
+                    content: "Successfully logged out!",
+                });
+                return;
+            }
+            if (command === "/resume") {
+                if (!apiClient) {
+                    addMessage({
+                        type: "error",
+                        content: "API client not available. Cannot fetch sessions.",
+                        errorType: "error",
+                    });
+                    return;
+                }
+                setShowSessionSelector(true);
+                return;
+            }
+            if (command === "/setup") {
+                addMessage({
+                    type: "assistant",
+                    content: "Running setup...",
+                });
+                try {
+                    const result = await setupCommand();
+                    addMessage({
+                        type: "assistant",
+                        content: result.output,
+                    });
+                }
+                catch (error) {
+                    addMessage({
+                        type: "error",
+                        content: `Setup failed: ${error instanceof Error ? error.message : String(error)}`,
+                        errorType: "error",
+                    });
+                }
+                return;
+            }
+        }
+        // Check authentication before allowing task submission
+        if (authState !== AuthState.Authenticated) {
+            addMessage({
+                type: "error",
+                content: "Authentication required. Please login to continue.",
+                errorType: "warning",
+            });
+            setShowAuthDialog(true);
+            return;
+        }
+        setHasInputContent(false); // Reset content flag
+        setExitWarning(null);
+        // Don't add message here - let InteractiveApp handle it
+        // addMessage({
+        // 	type: "user",
+        // 	content: task,
+        // });
+        if (onSubmitTask) {
+            onSubmitTask(task);
+        }
+    };
+    // Handle session selection
+    const handleSessionSelect = (session) => {
+        setShowSessionSelector(false);
+        addMessage({
+            type: "assistant",
+            content: `Switching to session: ${session.title || "Untitled"} (${session.id})`,
+        });
+        if (onResumeSession) {
+            onResumeSession(session);
+        }
+    };
+    const handleSessionSelectorCancel = () => {
+        setShowSessionSelector(false);
+    };
+    // Handle terminal resize
+    useEffect(() => {
+        const handleResize = () => {
+            setTerminalWidth(process.stdout.columns || 80);
+            setTerminalHeight(process.stdout.rows || 24);
+        };
+        process.stdout.on("resize", handleResize);
+        return () => {
+            process.stdout.off("resize", handleResize);
+        };
+    }, []);
+    // Keyboard shortcuts
+    useInput((input, key) => {
+        // ESC: Cancel current request (abort running operations)
+        if (key.escape && isAgentRunning) {
+            setShouldInterruptAgent(true);
+            addMessage({
+                type: "error",
+                content: "Request cancelled",
+                errorType: "info",
+            });
+        }
+        // Ctrl+C: Cancel if running, or exit with warning
+        if (key.ctrl && input === "c") {
+            if (isAgentRunning) {
+                // Cancel the running request (same as Escape)
+                setShouldInterruptAgent(true);
+                addMessage({
+                    type: "error",
+                    content: "Request cancelled",
+                    errorType: "info",
+                });
+                // Show exit warning
+                setExitWarning("Press Ctrl+C again to exit");
+                setTimeout(() => setExitWarning(null), 1500);
+            }
+            else if (exitWarning) {
+                // Second Ctrl+C within warning period - exit
+                exit();
+                onExit(true);
+            }
+            else if (showInput && hasInputContent) {
+                // Clear input and show warning
+                inputPromptRef.current?.clear();
+                setExitWarning("Press Ctrl+C again to exit");
+                setTimeout(() => setExitWarning(null), 1500);
+            }
+            else {
+                // Nothing running, no input - show warning first
+                setExitWarning("Press Ctrl+C again to exit");
+                setTimeout(() => setExitWarning(null), 1500);
+            }
+        }
+        // Ctrl+D: Exit immediately
+        if (key.ctrl && input === "d") {
+            exit();
+            onExit(true);
+        }
+        // Ctrl+H: Toggle help (removing '?' check here as it conflicts with input)
+        if (key.ctrl && input === "h") {
+            setShowHelp((prev) => !prev);
+        }
+        // Ctrl+L: Clear screen (not messages, just terminal)
+        if (key.ctrl && input === "l") {
+            console.clear();
+        }
+        // Ctrl+O: Toggle all tool outputs
+        if (key.ctrl && input === "o") {
+            toggleAllToolOutputs();
+        }
+    });
+    // Show initial user message if task was provided
+    useEffect(() => {
+        if (config.task) {
+            addMessage({
+                type: "user",
+                content: config.task,
+            });
+        }
+    }, []); // eslint-disable-line react-hooks/exhaustive-deps
+    return (React.createElement(Box, { flexDirection: "column", flexGrow: 0, flexShrink: 0, height: terminalHeight, overflow: "hidden", paddingX: 1 },
+        React.createElement(MessageList, { currentFolder: currentFolder, gitBranch: gitBranch, terminalWidth: terminalWidth }),
+        showHelp && React.createElement(HelpMenu, { isAuthenticated: authState === AuthState.Authenticated }),
+        showSessionSelector && apiClient && (React.createElement(SessionSelector, { apiClient: apiClient, onCancel: handleSessionSelectorCancel, onSelect: handleSessionSelect })),
+        showAuthDialog && (React.createElement(AuthDialog, { onLogin: handleLogin })),
+        React.createElement(Box, { flexDirection: "column", flexGrow: 0, flexShrink: 0 },
+            React.createElement(QueuedMessageDisplay, { messageQueue: queuedTasks }),
+            !showAuthDialog && React.createElement(AuthBanner, { authState: authState }),
+            showInput && !showSessionSelector && !showAuthDialog && (React.createElement(Box, { flexDirection: "column", marginTop: 0, width: "100%" },
+                exitWarning && (React.createElement(Box, { marginBottom: 0, paddingX: 1 },
+                    React.createElement(Text, { color: "yellow" }, exitWarning))),
+                React.createElement(InputPrompt, { currentFolder: currentFolder, gitBranch: gitBranch, onHelpToggle: () => setShowHelp(prev => !prev), onInputChange: (val) => setHasInputContent(val.trim().length > 0), onSubmit: handleSubmitTask, placeholder: "Enter your task...", ref: inputPromptRef }))))));
+};
+/**
+ * Root App component
+ * Note: SessionProvider should be provided by the parent component
+ */
+export const App = (props) => {
+    return React.createElement(AppContent, { ...props });
+};