@timetotest/cli 0.3.1 → 0.3.3

package/dist/src/commands/chat-ink.js

@@ -9,42 +9,58 @@ import { render } from "ink";
 import { AgentOrchestrator } from "../lib/agent-orchestrator.js";
 import { resolveApiUrl, getAuthToken, configManager } from "../lib/config.js";
 import { ChatApp } from "./chat/ChatApp.js";
-import { performInteractiveLogin } from "./login.js";
+import { performCliSignup, performInteractiveLogin } from "./login.js";
 import { resolveTestingMode } from "../lib/testing-mode.js";
 export async function runChatInk(options) {
     try {
         const apiUrl = resolveApiUrl();
         let token = getAuthToken();
+        const isAuthError = (error) => {
+            const status = error?.response?.status;
+            if (status === 401 || status === 403)
+                return true;
+            const message = String(error?.message || "");
+            return message.includes("status code 401") || message.includes("status code 403");
+        };
         if (!token) {
-            // Use TUI onboarding instead of direct login
-            // We need to dynamically import OnboardingApp to avoid top-level side effects if possible
             const { OnboardingApp } = await import("./chat/OnboardingApp.js");
-            // Wrap TUI in a promise to wait for user interaction
-            await new Promise((resolve, reject) => {
+            const promptOnboardingAction = () => new Promise((resolve) => {
                 const { unmount } = render(React.createElement(OnboardingApp, {
-                    onLogin: async () => {
+                    onSignIn: () => {
                         unmount();
-                        try {
-                            await performInteractiveLogin();
-                            // Update token after authentication
-                            token = getAuthToken();
-                            if (!token) {
-                                console.error("❌ Authentication failed");
-                                process.exit(1);
-                            }
-                            resolve();
-                        }
-                        catch (error) {
-                            console.error(`❌ Authentication failed: ${error?.message || error}`);
-                            process.exit(1);
-                        }
+                        resolve("signin");
+                    },
+                    onSignUp: () => {
+                        unmount();
+                        resolve("signup");
                     },
                     onExit: () => {
                         unmount();
-                        process.exit(0);
+                        resolve("exit");
                     },
                 }));
             });
+            while (!token) {
+                const action = await promptOnboardingAction();
+                if (action === "exit") {
+                    process.exit(0);
+                }
+                try {
+                    if (action === "signup") {
+                        await performCliSignup();
+                    }
+                    else {
+                        await performInteractiveLogin();
+                    }
+                    token = getAuthToken();
+                    if (!token) {
+                        throw new Error("Authentication completed but no token was saved.");
+                    }
+                }
+                catch (error) {
+                    console.error(`❌ Authentication failed: ${error?.message || error}\nRetry with Sign In/Sign Up or press Exit.`);
+                }
+            }
         }
         // Fetch user information
         const { createHttpClient } = await import("../lib/http.js");
@@ -58,24 +74,30 @@ export async function runChatInk(options) {
         catch (error) {
             const status = error?.response?.status;
             if (status === 401 || status === 403) {
-                // Token expired or invalid - re-authenticate
-                try {
-                    await performInteractiveLogin();
-                    // Update token after re-authentication
-                    token = getAuthToken();
-                    if (!token) {
-                        console.error("❌ Re-authentication failed");
-                        process.exit(1);
+                let reauthed = false;
+                for (let attempt = 1; attempt <= 2; attempt += 1) {
+                    try {
+                        await performInteractiveLogin();
+                        token = getAuthToken();
+                        if (!token) {
+                            throw new Error("No token returned after login.");
+                        }
+                        http = createHttpClient();
+                        const retryUserResp = await http.get("/api/v1/auth/me");
+                        userName =
+                            retryUserResp.data?.email ||
+                                retryUserResp.data?.display_name ||
+                                "Unknown";
+                        reauthed = true;
+                        break;
+                    }
+                    catch (reauthError) {
+                        const suffix = attempt < 2 ? " Retrying once..." : " Continuing with limited context.";
+                        console.error(`❌ Re-authentication failed: ${reauthError?.message || reauthError}.${suffix}`);
                     }
-                    http = createHttpClient();
-                    // Retry fetching user info
-                    const userResp = await http.get("/api/v1/auth/me");
-                    userName =
-                        userResp.data?.email || userResp.data?.display_name || "Unknown";
                 }
-                catch (reauthError) {
-                    console.error(`❌ Re-authentication failed: ${reauthError?.message || reauthError}`);
-                    process.exit(1);
+                if (!reauthed) {
+                    userName = "Unknown";
                 }
             }
             else {
@@ -114,6 +136,15 @@ export async function runChatInk(options) {
             apiBaseUrl: options.apiBaseUrl,
         };
         const orchestrator = new AgentOrchestrator(config, options.session);
+        try {
+            const preferredModel = await configManager.getPreferredModel();
+            if (preferredModel) {
+                await orchestrator.setModel(preferredModel);
+            }
+        }
+        catch {
+            // Ignore preference load failures; session can proceed with backend default.
+        }
         let userCancelled = false; // Track when the user cancels an operation
         function getAppInterface() {
             return globalThis.__chatAppInterface;
@@ -168,6 +199,11 @@ export async function runChatInk(options) {
             const appInterface = getAppInterface();
             const toolName = data.data?.tool || data.tool;
             const toolArgs = data.data?.arguments || {};
+            const callId = data.data?.call_id || data.call_id;
+            if (toolName === "todo") {
+                // Render todo changes in the dedicated panel (avoid transcript spam).
+                return;
+            }
             // Add tool call as a system message with tool metadata
             appInterface?.addMessage({
                 id: `tool-${Date.now()}`,
@@ -176,6 +212,7 @@ export async function runChatInk(options) {
                 metadata: {
                     isTool: true,
                     toolName,
+                    toolCallId: callId,
                     toolArgs,
                     isLoading: true,
                 },
@@ -192,9 +229,28 @@ export async function runChatInk(options) {
             const appInterface = getAppInterface();
             const toolName = data.data?.tool || data.tool;
             const result = data.data?.result;
+            const callId = data.data?.call_id || data.call_id;
+            if (toolName === "todo") {
+                const todoData = result?.data || result?.todo_list_snapshot || result?.todo_list || {};
+                const items = Array.isArray(todoData.todos) ? todoData.todos : [];
+                const snapshot = items.length > 0 || typeof todoData.title === "string" || typeof todoData.description === "string"
+                    ? {
+                        title: typeof todoData.title === "string" ? todoData.title : undefined,
+                        description: typeof todoData.description === "string" ? todoData.description : undefined,
+                        todos: items,
+                        updated_at: typeof todoData.updated_at === "string"
+                            ? todoData.updated_at
+                            : new Date().toISOString(),
+                        current_id: typeof todoData.current_id === "string" ? todoData.current_id : undefined,
+                    }
+                    : null;
+                appInterface?.setTodos?.(snapshot);
+                return;
+            }
             // Update the last tool message with the result
             appInterface?.updateLastToolMessage?.({
                 toolName,
+                callId,
                 result,
                 isLoading: false,
             });
@@ -241,117 +297,8 @@ export async function runChatInk(options) {
             chatContext.toolCount = history.filter((msg) => msg.role === "tool").length;
         };
         updateContextFromOrchestrator();
-        // Define slash commands (alphabetically sorted)
+        // Define slash commands (only user-approved set)
         const slashCommands = [
-            {
-                name: "cancel",
-                description: "Alias for /stop",
-                handler: async () => {
-                    handleUserCancel();
-                    return "continue";
-                },
-            },
-            {
-                name: "clear",
-                description: "Clear the transcript visually",
-                handler: async () => "continue",
-            },
-            {
-                name: "bugs",
-                description: "List all bugs identified in this session",
-                handler: async (args, orchestrator) => {
-                    const history = orchestrator.getConversationHistory();
-                    const findings = history
-                        .filter((msg) => msg.role === "tool" && msg.toolCall?.name === "generate_document")
-                        .map((msg) => {
-                        try {
-                            const res = JSON.parse(msg.content);
-                            return res.findings || [];
-                        }
-                        catch {
-                            return [];
-                        }
-                    })
-                        .flat();
-                    const appInterface = getAppInterface();
-                    if (findings.length === 0) {
-                        appInterface?.addMessage({
-                            id: Date.now().toString(),
-                            type: "system",
-                            content: "No bugs have been formally reported yet. Use /report to generate a report.",
-                        });
-                    }
-                    else {
-                        const list = findings
-                            .map((f, i) => `${i + 1}. [${f.severity?.toUpperCase()}] ${f.title}`)
-                            .join("\n");
-                        appInterface?.addMessage({
-                            id: Date.now().toString(),
-                            type: "system",
-                            content: `🐞 Identified Bugs:\n${list}`,
-                        });
-                    }
-                    return "continue";
-                },
-            },
-            {
-                name: "compact",
-                description: "Compact conversation context to manage token limits",
-                handler: async () => {
-                    const stats = orchestrator.getContextStats();
-                    const appInterface = getAppInterface();
-                    if (!stats.needsCompaction) {
-                        appInterface?.addMessage({
-                            id: Date.now().toString(),
-                            type: "system",
-                            content: `Context: ${stats.totalMessages} messages, ${stats.tokens.toLocaleString()} tokens (${stats.utilizationPercent.toFixed(1)}% of limit), ${stats.conversationTurns} turns. No compaction needed.`,
-                        });
-                        return "continue";
-                    }
-                    const result = await orchestrator.compactContext();
-                    appInterface?.addMessage({
-                        id: Date.now().toString(),
-                        type: "system",
-                        content: `✅ Context compacted: ${result.stats.removedCount} messages removed\n` +
-                            `Before: ${result.stats.tokensBeforeCompaction.toLocaleString()} tokens\n` +
-                            `After: ${result.stats.tokensAfterCompaction.toLocaleString()} tokens\n` +
-                            `Strategy: ${result.stats.strategy}` +
-                            (result.stats.summaryGenerated
-                                ? "\n📝 LLM summary generated"
-                                : ""),
-                    });
-                    updateContextFromOrchestrator();
-                    appInterface?.updateContext(chatContext);
-                    return "continue";
-                },
-            },
-            {
-                name: "exit",
-                description: "Exit the session (saves progress)",
-                handler: async () => "exit",
-            },
-            {
-                name: "goto",
-                description: "Direct the agent to a specific URL",
-                handler: async (args, orchestrator) => {
-                    if (args.length === 0) {
-                        getAppInterface()?.addMessage({
-                            id: Date.now().toString(),
-                            type: "system",
-                            content: "Usage: /goto <url>",
-                        });
-                        return "continue";
-                    }
-                    const url = args[0];
-                    getAppInterface()?.addMessage({
-                        id: Date.now().toString(),
-                        type: "system",
-                        content: `🚀 Navigating to ${url}...`,
-                    });
-                    void handleUserMessage(`Navigate to ${url} and tell me what you see.`);
-                    return "continue";
-                },
-            },
             {
                 name: "help",
                 description: "Show available slash commands",
@@ -367,149 +314,6 @@ export async function runChatInk(options) {
                     return "continue";
                 },
             },
-            {
-                name: "history",
-                description: "Show the last few conversation turns",
-                handler: async () => {
-                    const history = orchestrator.getConversationHistory();
-                    const recent = history.slice(-10);
-                    const historyText = recent
-                        .map((message) => {
-                        const roleLabel = message.role === "user"
-                            ? "You"
-                            : message.role === "assistant"
-                                ? "Agent"
-                                : message.role.toUpperCase();
-                        const content = typeof message.content === "string"
-                            ? message.content
-                            : JSON.stringify(message.content, null, 2);
-                        return `${roleLabel}: ${content}`;
-                    })
-                        .join("\n");
-                    getAppInterface()?.addMessage({
-                        id: Date.now().toString(),
-                        type: "system",
-                        content: `History (${history.length} total):\n${historyText}`,
-                    });
-                    return "continue";
-                },
-            },
-            {
-                name: "progress",
-                description: "Show conversation summary and tool usage",
-                handler: async () => {
-                    const history = orchestrator.getConversationHistory();
-                    const totals = history.reduce((acc, message) => {
-                        acc.total += 1;
-                        acc[message.role] = (acc[message.role] || 0) + 1;
-                        return acc;
-                    }, {
-                        total: 0,
-                        user: 0,
-                        assistant: 0,
-                        tool: 0,
-                        system: 0,
-                    });
-                    let progressText = `Messages: ${totals.total} (you ${totals.user}, agent ${totals.assistant}, tool ${totals.tool})`;
-                    if (totals.tool > 0) {
-                        const toolNames = history
-                            .filter((msg) => msg.role === "tool" && msg.toolCall)
-                            .map((msg) => msg.toolCall.name);
-                        const uniqueTools = Array.from(new Set(toolNames));
-                        progressText += `\nTools used: ${uniqueTools.join(", ")}`;
-                    }
-                    getAppInterface()?.addMessage({
-                        id: Date.now().toString(),
-                        type: "system",
-                        content: progressText,
-                    });
-                    return "continue";
-                },
-            },
-            {
-                name: "report",
-                description: "Force the agent to generate a final report",
-                handler: async (args, orchestrator) => {
-                    getAppInterface()?.addMessage({
-                        id: Date.now().toString(),
-                        type: "system",
-                        content: "📑 Generating report based on session history...",
-                    });
-                    void handleUserMessage("Please generate a final report of your findings for this session.");
-                    return "continue";
-                },
-            },
-            {
-                name: "scan",
-                description: "Instruct the agent to scan the page for interactive elements",
-                handler: async () => {
-                    getAppInterface()?.addMessage({
-                        id: Date.now().toString(),
-                        type: "system",
-                        content: "🔍 Scanning page for interactive elements...",
-                    });
-                    void handleUserMessage("Scan the current page and list all interactive elements you find.");
-                    return "continue";
-                },
-            },
-            {
-                name: "screenshot",
-                description: "Force the agent to take a screenshot and show the state",
-                handler: async () => {
-                    getAppInterface()?.addMessage({
-                        id: Date.now().toString(),
-                        type: "system",
-                        content: "📸 Capturing fresh screenshot...",
-                    });
-                    void handleUserMessage("Please take a screenshot of the current page and tell me what's visible.");
-                    return "continue";
-                },
-            },
-            {
-                name: "where",
-                description: "Get the current URL and page title from the agent",
-                handler: async () => {
-                    getAppInterface()?.addMessage({
-                        id: Date.now().toString(),
-                        type: "system",
-                        content: "📍 Checking location...",
-                    });
-                    void handleUserMessage("What is the current URL and page title?");
-                    return "continue";
-                },
-            },
-            {
-                name: "reset",
-                description: "Reset session and clear all messages",
-                handler: async (args, orchestrator) => {
-                    orchestrator.cancel();
-                    getAppInterface()?.addMessage({
-                        id: Date.now().toString(),
-                        type: "system",
-                        content: "🧹 Session reset. History cleared.",
-                    });
-                    // Note: In a real app we'd want to tell the orchestrator to reset its internal state too
-                    return "continue";
-                },
-            },
-            {
-                name: "session",
-                description: "Display session metadata and storage path",
-                handler: async () => {
-                    const sessionText = [
-                        `ID: ${chatContext.sessionId}`,
-                        `Path: ${chatContext.sessionPath}`,
-                        `Mode: ${chatContext.mode}`,
-                        `Testing mode: ${chatContext.testingMode}`,
-                    ].join("\n");
-                    getAppInterface()?.addMessage({
-                        id: Date.now().toString(),
-                        type: "system",
-                        content: sessionText,
-                    });
-                    return "continue";
-                },
-            },
             {
                 name: "stop",
                 description: "Stop the assistant (same as ESC)",
@@ -518,29 +322,6 @@ export async function runChatInk(options) {
                     return "continue";
                 },
             },
-            {
-                name: "logout",
-                description: "Log out and clear local credentials",
-                handler: async () => {
-                    try {
-                        const { clearAuthToken } = await import("../lib/config.js");
-                        clearAuthToken();
-                        getAppInterface()?.addMessage({
-                            id: Date.now().toString(),
-                            type: "system",
-                            content: "✅ Logged out. Credentials cleared.",
-                        });
-                    }
-                    catch (e) {
-                        getAppInterface()?.addMessage({
-                            id: Date.now().toString(),
-                            type: "system",
-                            content: `❌ Failed to logout: ${e?.message || String(e)}`,
-                        });
-                    }
-                    return "exit";
-                },
-            },
             {
                 name: "model",
                 description: "Switch AI model (Pro tier required)",
@@ -562,37 +343,59 @@ export async function runChatInk(options) {
                         }
                         // No args - show available models
                         if (args.length === 0) {
-                            const modelsList = availableModels
-                                .map((m) => {
-                                const usesInfo = m.usesRemaining !== null
-                                    ? ` (${m.usesRemaining} free uses left)`
-                                    : "";
-                                const creditInfo = m.credits > 0
-                                    ? ` - ${m.credits} credit${m.credits !== 1 ? "s" : ""}/msg`
-                                    : "";
-                                return `  ${m.id} - ${m.name}${creditInfo}${usesInfo}`;
-                            })
-                                .join("\n");
-                            // Show appropriate balance/plan info
-                            const planTier = data.planTier || "free";
-                            const isPaidPlan = planTier !== "free";
-                            const creditBalance = data.creditBalance || 0;
-                            let balanceInfo = "";
-                            if (isPaidPlan) {
-                                // Paid plan users - show plan tier
-                                balanceInfo = `Plan: ${planTier.charAt(0).toUpperCase() + planTier.slice(1)}`;
-                                if (creditBalance > 0) {
-                                    balanceInfo += ` | Extra credits: ${creditBalance}`;
-                                }
+                            if (availableModels.length === 0) {
+                                appInterface?.addMessage({
+                                    id: Date.now().toString(),
+                                    type: "system",
+                                    content: "No models are currently available for your account.",
+                                });
+                                return "continue";
                             }
-                            else {
-                                // Free tier - show credits
-                                balanceInfo = `Credits: ${creditBalance}`;
+                            if (appInterface?.promptModelSelection) {
+                                const currentModelForPicker = orchestrator.getCurrentModel?.() || data.currentModel;
+                                const selectedModelId = await appInterface.promptModelSelection({
+                                    models: availableModels,
+                                    currentModel: currentModelForPicker,
+                                    planTier: data.planTier,
+                                    creditBalance: data.creditBalance,
+                                });
+                                if (!selectedModelId) {
+                                    appInterface?.addMessage({
+                                        id: Date.now().toString(),
+                                        type: "system",
+                                        content: "Model selection cancelled.",
+                                    });
+                                    return "continue";
+                                }
+                                const selectedModel = availableModels.find((m) => m.id === selectedModelId);
+                                if (!selectedModel) {
+                                    appInterface?.addMessage({
+                                        id: Date.now().toString(),
+                                        type: "system",
+                                        content: `❌ Unknown model: ${selectedModelId}`,
+                                    });
+                                    return "continue";
+                                }
+                                await orchestrator.setModel(selectedModelId);
+                                await configManager.setPreferredModel(selectedModelId);
+                                const statusInfo = selectedModel.credits > 0
+                                    ? ` (${selectedModel.credits} credit${selectedModel.credits !== 1 ? "s" : ""}/msg)`
+                                    : "";
+                                appInterface?.addMessage({
+                                    id: Date.now().toString(),
+                                    type: "system",
+                                    content: `✅ Switched to ${selectedModel.name}${statusInfo}`,
+                                });
+                                return "continue";
                             }
+                            // Fallback for non-INK contexts
+                            const modelsList = availableModels
+                                .map((m) => `  ${m.id} - ${m.name}`)
+                                .join("\n");
                             appInterface?.addMessage({
                                 id: Date.now().toString(),
                                 type: "system",
-                                content: `Available Models:\n${modelsList}\n\n${balanceInfo}\n\nUsage: /model <model-id>`,
+                                content: `Available Models:\n${modelsList}\n\nUsage: /model <model-id>`,
                             });
                             return "continue";
                         }
@@ -610,6 +413,7 @@ export async function runChatInk(options) {
                             return "continue";
                         }
                         await orchestrator.setModel(modelId);
+                        await configManager.setPreferredModel(modelId);
                         // Show appropriate success message
                         const planTier = data.planTier || "free";
                         const isPaidPlan = planTier !== "free";
@@ -643,6 +447,34 @@ export async function runChatInk(options) {
                     }
                 },
             },
+            {
+                name: "logout",
+                description: "Log out and clear local credentials",
+                handler: async () => {
+                    try {
+                        const { clearAuthToken } = await import("../lib/config.js");
+                        clearAuthToken();
+                        getAppInterface()?.addMessage({
+                            id: Date.now().toString(),
+                            type: "system",
+                            content: "✅ Logged out. Credentials cleared.",
+                        });
+                    }
+                    catch (e) {
+                        getAppInterface()?.addMessage({
+                            id: Date.now().toString(),
+                            type: "system",
+                            content: `❌ Failed to logout: ${e?.message || String(e)}`,
+                        });
+                    }
+                    return "exit";
+                },
+            },
+            {
+                name: "exit",
+                description: "Exit the session (saves progress)",
+                handler: async () => "exit",
+            },
         ];
         const commandMap = new Map(slashCommands.map((command) => [command.name, command.handler]));
         const executeSlashCommand = async (cmd, args) => {
@@ -665,7 +497,34 @@ export async function runChatInk(options) {
                     text: "Agent thinking...",
                     type: "loading",
                 });
-                const response = await orchestrator.chat(message);
+                let response = "";
+                try {
+                    response = await orchestrator.chat(message);
+                }
+                catch (error) {
+                    if (!isAuthError(error)) {
+                        throw error;
+                    }
+                    appInterface?.setStatus({
+                        text: "Authentication required. Opening login...",
+                        type: "info",
+                    });
+                    try {
+                        await performInteractiveLogin();
+                        token = getAuthToken();
+                        if (!token) {
+                            throw new Error("Login did not return a valid token");
+                        }
+                    }
+                    catch (loginError) {
+                        throw new Error(`Authentication required. Login failed: ${loginError?.message || loginError}. Retry your message or run /logout then sign in again.`);
+                    }
+                    appInterface?.setStatus({
+                        text: "Authenticated. Retrying...",
+                        type: "loading",
+                    });
+                    response = await orchestrator.chat(message);
+                }
                 if (userCancelled) {
                     return;
                 }
@@ -705,7 +564,7 @@ export async function runChatInk(options) {
         };
         const handleExit = () => {
             cleanupOrchestratorListeners();
-            console.error(chalk.green("\n✓ Session saved. Run 'ttt resume' to continue."));
+            console.error(chalk.green("\n✓ Session saved. Run 'ttt chat --session <id>' to continue."));
             process.exit(0);
         };
         // Prepare slash commands for the UI