@thegitai/cli 1.0.0-preview.3 → 1.0.0-preview.30

package/dist/bin/ai.js

@@ -1,72 +1,48 @@
 #!/usr/bin/env node
 import chalk from '../src/colors.js';
-import { stdin as input, stdout as output } from 'node:process';
-import readline from 'node:readline/promises';
 import { ServerApi } from '../src/api/index.js';
-import { loginViaBrowser } from '../src/api/browser-login.js';
-import { isTransientNetworkError } from '../src/api/http.js';
-import { formatCliHelpText, formatInteractiveHelpText, } from '../src/help-text.js';
-import { renderMarkdownForTerminal } from '../src/markdown-renderer.js';
-import { createIndex } from '../src/project-index.js';
-import { createSession, clearConversation } from '../src/session.js';
-import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, } from '../src/session-store.js';
-import { runClientInteractive, shouldUseClientRatatuiShell, } from '../src/ui/repl.js';
+import { DEFAULT_THEGITAI_HOST } from '../src/api/default-host.js';
+import { isSignInCancelled } from '../src/api/browser-login.js';
+import { runSignIn } from '../src/signin.js';
+import { STARTUP_RETRY_BUDGET, authenticationErrorMessage, isAuthenticationError, isTransientNetworkError, } from '../src/api/http.js';
+import { formatCliHelpText } from '../src/help-text.js';
+import { createSession } from '../src/session.js';
+import { applySessionSnapshot, listSessionMetadata, loadSessionSnapshot, saveSessionState, sessionHasUserMessage, } from '../src/session-store.js';
+import { runClientInteractive } from '../src/ui/repl.js';
 import { appendPromptToFile } from '../src/ui/prompt-history-store.js';
 import { formatSessionExitNotice } from '../src/session-exit.js';
 import { formatUsageText } from '../src/usage.js';
 import { formatVersionLine } from '../src/version.js';
 import { parseArgs } from '../src/cli-args.js';
-import { getJobBufferedOutput, killBackgroundJob, killAllBackgroundJobs, listBackgroundJobs, setBackgroundJobSession, } from '../src/background-jobs.js';
-import { collectBackgroundJobUiKillMutations, collectBackgroundJobUiOutputMutations, } from '../src/tool-executor.js';
-import { setScratchSession } from '../src/scratch-dir.js';
-const DEFAULT_SERVER_URL = 'https://thegit.ai';
 const { auth, chat, models, sessions } = ServerApi;
 function printUsage() {
     console.log(formatCliHelpText({ color: process.stdout.isTTY === true }));
 }
-async function promptText(question, fallback = null) {
-    const rl = readline.createInterface({ input, output });
-    try {
-        const suffix = fallback ? ` (${fallback})` : '';
-        const answer = await rl.question(`${question}${suffix}: `);
-        return answer.trim() || fallback || '';
-    }
-    finally {
-        rl.close();
-    }
+function unreachableReason(error) {
+    const err = error;
+    const code = err?.code ?? err?.cause?.code;
+    if (err?.name === 'TimeoutError' || err?.name === 'AbortError') {
+        return 'network timeout';
+    }
+    if (code === 'ENOTFOUND' || code === 'EAI_AGAIN')
+        return 'DNS lookup failed';
+    if (code === 'ECONNREFUSED')
+        return 'connection refused';
+    if (code === 'ECONNRESET' || code === 'EPIPE')
+        return 'connection reset';
+    return err?.message ? String(err.message) : 'network error';
 }
 function appendPromptHistory(prompt, env = process.env) {
     appendPromptToFile(prompt, env);
 }
-async function runAuthCommand(command, args) {
-    if (command === 'login') {
-        const serverUrl = DEFAULT_SERVER_URL;
-        const noBrowser = args.includes('--no-browser');
-        console.log(chalk.dim(noBrowser
-            ? 'Sign in on the website, then paste the authorization code here.'
-            : 'Opening your browser to sign in…'));
-        const result = await loginViaBrowser({
-            serverUrl,
-            noBrowser,
-            onUrl: (url) => {
-                console.log(chalk.dim(noBrowser ? 'Open this URL to sign in:' : 'If your browser did not open, visit:'));
-                console.log(`  ${url}`);
-            },
-            onWaiting: () => console.log(chalk.dim('Waiting for you to finish signing in…')),
-            promptCode: noBrowser
-                ? () => promptText('Paste the authorization code')
-                : undefined,
-            deviceName: process.env.THEGITAI_DEVICE_NAME?.trim() || undefined,
-        });
-        auth.writeCliAuthConfig(result);
-        console.log(chalk.green(`✓ Logged in as ${result.customer.email}`));
-        console.log(chalk.dim(`Server: ${result.serverUrl}`));
-        console.log(chalk.dim('You can close the browser tab. Run `ai` in a repo to start.'));
-        return;
-    }
+async function runAuthCommand(command) {
     const config = auth.readCliAuthConfig();
     if (!config) {
-        throw new Error('Not logged in. Run `ai login` first.');
+        if (command === 'logout') {
+            console.log(chalk.green('Already signed out.'));
+            return;
+        }
+        throw new Error('Not signed in. Run `ai` to sign in.');
     }
     if (command === 'whoami') {
         const customer = await auth.fetchWhoami({ config });
@@ -74,19 +50,25 @@ async function runAuthCommand(command, args) {
         return;
     }
     if (command === 'logout') {
-        await auth.logoutFromServer({ config });
+        try {
+            await auth.logoutFromServer({ config });
+        }
+        catch {
+        }
         auth.clearCliAuthConfig();
         console.log(chalk.green('Logged out.'));
         return;
     }
     throw new Error(`Unknown auth command: ${command}`);
 }
-function requireCliAuthConfig() {
+async function ensureCliAuthConfig() {
     const config = auth.readCliAuthConfig();
-    if (!config) {
-        throw new Error('Not logged in. Run `ai login` first.');
+    if (config)
+        return config;
+    if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
+        throw new Error('Not signed in. Run `ai login` on a terminal to sign in.');
     }
-    return config;
+    return await runSignIn();
 }
 function formatSessionName(name) {
     return name ? `"${name}"` : '(unnamed)';
@@ -112,54 +94,16 @@ function printSessionList(rootDir, sessions, serverModels) {
         }
     }
 }
-function printStartupBanner(rootDir, modelLabel, autoYes) {
-    console.log(chalk.dim(`Project: ${rootDir}`));
-    console.log(chalk.dim(`Model: ${modelLabel}`));
-    if (autoYes) {
-        console.log(chalk.dim('Auto-confirm: enabled'));
-    }
-}
-function printSessionStartup(session) {
-    console.log(chalk.dim(`Session: ${session.sessionName ? `${session.sessionName} ` : ''}${session.sessionId}`));
-}
 function printSessionExit(session) {
     console.log(chalk.dim(`\n${formatSessionExitNotice(session.sessionId)}\n`));
 }
 function modelLabel(serverModels, modelId) {
-    return (serverModels.models.find((model) => model.id === modelId)?.label ??
-        'Unknown model');
-}
-function formatJobElapsedMs(ms) {
-    const totalSeconds = Math.max(0, Math.floor(ms / 1000));
-    if (totalSeconds < 60)
-        return `${totalSeconds}s`;
-    const minutes = Math.floor(totalSeconds / 60);
-    if (minutes < 60)
-        return `${minutes}m${String(totalSeconds % 60).padStart(2, '0')}s`;
-    return `${Math.floor(minutes / 60)}h${String(minutes % 60).padStart(2, '0')}m`;
-}
-function makeConfirmCommand(session) {
-    return async (command) => {
-        console.log(chalk.bold(`\nCommand approval needed:\n${command}\n`));
-        const answer = (await promptText('Approve? [y]es/[a]ll/[n]o', 'n')).toLowerCase();
-        if (answer === 'a' || answer === 'all') {
-            session.autoYes = true;
-            return true;
-        }
-        return answer === 'y' || answer === 'yes';
-    };
-}
-function makeConfirmPatch(session) {
-    return async (filePath) => {
-        const answer = (await promptText(`Apply patch to ${filePath}? [y]es/[a]ll/[n]o`, 'n')).toLowerCase();
-        if (answer === 'a' || answer === 'all') {
-            session.autoYes = true;
-            return true;
-        }
-        return answer === 'y' || answer === 'yes';
-    };
+    return (serverModels?.models.find((model) => model.id === modelId)?.label ??
+        `Model ${modelId}`);
 }
 async function saveSessionBoth({ session, serverSessionClient, }) {
+    if (!sessionHasUserMessage(session))
+        return;
     saveSessionState(session);
     try {
         await serverSessionClient.save(session);
@@ -168,200 +112,21 @@ async function saveSessionBoth({ session, serverSessionClient, }) {
         console.error(chalk.yellow(`Warning: session save failed: ${error.message}`));
     }
 }
-async function promptForModelSelection(currentModelId, authConfig) {
-    const serverModels = await models.fetchServerModels({ config: authConfig });
-    console.log(chalk.bold('\nAvailable models'));
-    for (const model of serverModels.models) {
-        const marker = model.id === currentModelId ? '*' : ' ';
-        console.log(`${marker} ${model.id}  ${model.label}`);
-    }
-    console.log();
-    const selected = (await promptText('Model id', '')).trim() || null;
-    if (!selected) {
-        return { selected: null, serverModels };
-    }
-    return {
-        selected: models.validateServerModel(selected, serverModels),
-        serverModels,
-    };
-}
-async function promptForResumeSession(rootDir, serverModels) {
-    const sessions = listSessionMetadata(rootDir);
-    if (!sessions.length) {
-        console.log(chalk.dim('No saved sessions for this repo.\n'));
-        return null;
-    }
-    printSessionList(rootDir, sessions, serverModels);
-    console.log();
-    const identifier = (await promptText('Session id or name', '')).trim();
-    if (!identifier) {
-        return null;
-    }
-    return loadSessionSnapshot(rootDir, identifier);
-}
-async function runTurn({ authConfig, projectIndex, serverSessionClient, session, inputText, }) {
-    const prompt = String(inputText ?? '').trim();
-    if (!prompt)
-        return;
-    appendPromptHistory(prompt, session.env);
-    const result = await chat.sendServerUserMessage({
-        config: authConfig,
-        projectIndex,
-        session,
-        input: prompt,
-    });
-    if (result.text) {
-        console.log(`\n${chalk.green('TheGitAI>')}`);
-        console.log(renderMarkdownForTerminal(result.text));
-        console.log();
-    }
-    await saveSessionBoth({ session, serverSessionClient });
-}
-async function mainInteractive({ authConfig, projectIndex, serverModels, serverSessionClient, session, usageText, initialPrompt, }) {
-    if (initialPrompt) {
-        console.log(chalk.dim(`Prompt: "${initialPrompt}"`));
-        await runTurn({
-            authConfig,
-            projectIndex,
-            serverSessionClient,
-            session,
-            inputText: initialPrompt,
-        });
-    }
-    while (true) {
-        const inputText = await promptText('you');
-        const trimmed = inputText.trim();
-        if (!trimmed)
-            continue;
-        if (trimmed === '/exit')
-            return;
-        if (trimmed === '/help') {
-            console.log(renderMarkdownForTerminal(formatInteractiveHelpText()));
-            continue;
-        }
-        if (trimmed === '/usage') {
-            console.log(await usageText());
-            continue;
-        }
-        if (trimmed === '/clear') {
-            clearConversation(session);
-            await saveSessionBoth({ session, serverSessionClient });
-            console.log(chalk.dim('Conversation cleared.\n'));
-            continue;
-        }
-        if (trimmed === '/jobs' || trimmed.startsWith('/jobs ')) {
-            const jobsArgs = trimmed.slice('/jobs'.length).trim();
-            const killMatch = jobsArgs.match(/^kill\s+(\S+)$/);
-            if (killMatch) {
-                const jobId = killMatch[1];
-                const killed = await killBackgroundJob(jobId);
-                await collectBackgroundJobUiKillMutations({
-                    session,
-                    projectIndex,
-                    jobId,
-                    result: killed,
-                });
-                if (!killed.ok) {
-                    console.log(chalk.red(killed.error ?? 'Background job kill failed.'));
-                }
-                else if (killed.alreadyFinished) {
-                    console.log(chalk.dim(`${jobId} had already finished.`));
-                }
-                continue;
-            }
-            const outputMatch = jobsArgs.match(/^output\s+(\S+)$/);
-            if (outputMatch) {
-                const jobId = outputMatch[1];
-                await collectBackgroundJobUiOutputMutations({
-                    session,
-                    projectIndex,
-                    jobId,
-                });
-                const job = listBackgroundJobs().find((candidate) => candidate.id === jobId);
-                const buffered = getJobBufferedOutput(jobId);
-                if (!job || !buffered) {
-                    console.log(chalk.red(`Unknown background job id: ${jobId}`));
-                    continue;
-                }
-                if (buffered.droppedChars > 0) {
-                    console.log(chalk.dim(`... (${buffered.droppedChars} chars of older output dropped) ...`));
-                }
-                console.log(buffered.output || chalk.dim('(no output captured)'));
-                continue;
-            }
-            if (jobsArgs) {
-                console.log(chalk.dim('Usage: /jobs — list · /jobs output <id> — full output · /jobs kill <id> — kill'));
-                continue;
-            }
-            const jobsList = listBackgroundJobs();
-            if (!jobsList.length) {
-                console.log(chalk.dim('No background jobs in this session.'));
-                continue;
-            }
-            for (const job of jobsList) {
-                const elapsed = formatJobElapsedMs((job.endedAt ?? Date.now()) - job.startedAt);
-                const stateText = job.status === 'running'
-                    ? `running · ${elapsed}`
-                    : job.status === 'killed'
-                        ? `killed · ran ${elapsed}`
-                        : job.status === 'error'
-                            ? 'failed to start'
-                            : `exited (code ${job.exitCode ?? 1}) · ran ${elapsed}`;
-                console.log(`${job.id} · ${stateText}\n    $ ${job.command}`);
-            }
-            continue;
-        }
-        if (trimmed === '/resume') {
-            const snapshot = await promptForResumeSession(session.rootDir, serverModels);
-            if (!snapshot) {
-                console.log(chalk.dim('Resume cancelled.\n'));
-                continue;
-            }
-            applySessionSnapshot(session, snapshot);
-            setBackgroundJobSession(session.sessionId);
-            setScratchSession(session.sessionId);
-            await saveSessionBoth({ session, serverSessionClient });
-            console.log(chalk.dim(`Resumed session${session.sessionName ? ` "${session.sessionName}"` : ''} (${session.sessionId})\n`));
-            continue;
-        }
-        if (trimmed === '/model' || trimmed.startsWith('/model ')) {
-            const inline = trimmed.slice('/model'.length).trim();
-            let serverModels;
-            let selected = null;
-            if (inline) {
-                serverModels = await models.fetchServerModels({ config: authConfig });
-                selected = models.validateServerModel(inline, serverModels);
-            }
-            else {
-                const response = await promptForModelSelection(session.modelId, authConfig);
-                serverModels = response.serverModels;
-                selected = response.selected;
-            }
-            if (!selected) {
-                console.log(chalk.dim('Model selection cancelled.\n'));
-                continue;
-            }
-            session.modelId = selected;
-            models.updateSelectedModelCache({
-                config: authConfig,
-                selectedModelId: selected,
-                serverModels,
-            });
-            await saveSessionBoth({ session, serverSessionClient });
-            console.log(chalk.dim(`Switched to ${modelLabel(serverModels, selected)}.\n`));
-            continue;
-        }
-        await runTurn({
-            authConfig,
-            projectIndex,
-            serverSessionClient,
-            session,
-            inputText: trimmed,
-        });
-    }
+function requireInteractiveTerminal() {
+    if (process.stdin.isTTY !== true) {
+        console.error('Error: stdin is not a terminal');
+        process.exitCode = 1;
+        return false;
+    }
+    if (process.stdout.isTTY !== true) {
+        console.error('Error: stdout is not a terminal');
+        process.exitCode = 1;
+        return false;
+    }
+    return true;
 }
 export async function main() {
-    const { autoYes, help, version, usage, command, commandArgs, session: sessionIdentifier, listSessions, unknownOption, prompt, } = parseArgs(process.argv);
+    const { autoYes, help, version, usage, command, session: sessionIdentifier, listSessions, unknownOption, prompt, } = parseArgs(process.argv);
     if (version) {
         console.log(formatVersionLine());
         return;
@@ -376,65 +141,84 @@ export async function main() {
         process.exitCode = 2;
         return;
     }
-    if (command) {
-        await runAuthCommand(command, commandArgs);
+    if (command && command !== 'login') {
+        await runAuthCommand(command);
         return;
     }
     if (usage) {
-        const authConfig = requireCliAuthConfig();
+        const authConfig = await ensureCliAuthConfig();
         console.log(formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })));
         return;
     }
     const rootDir = process.cwd();
-    const authConfig = requireCliAuthConfig();
+    if (listSessions) {
+        const activeServerUrl = auth.readCliAuthConfig()?.serverUrl ?? DEFAULT_THEGITAI_HOST;
+        printSessionList(rootDir, listSessionMetadata(rootDir), models.selectCacheForServer(models.readCachedServerModels(), activeServerUrl));
+        return;
+    }
+    const sourceSnapshot = sessionIdentifier
+        ? loadSessionSnapshot(rootDir, sessionIdentifier)
+        : null;
+    if (sessionIdentifier && !sourceSnapshot) {
+        console.error(`Error: No saved session named or identified by "${sessionIdentifier}" is available for this repo. Run \`ai --list-sessions\`.`);
+        process.exitCode = 1;
+        return;
+    }
+    if (!requireInteractiveTerminal()) {
+        return;
+    }
+    const authConfig = await ensureCliAuthConfig();
     const serverSessionClient = sessions.createServerSessionClient({ config: authConfig });
     const cachedModels = models.selectCacheForServer(models.readCachedServerModels(), authConfig.serverUrl);
+    const [modelsOutcome, whoamiOutcome] = await Promise.allSettled([
+        models.fetchServerModels({
+            config: authConfig,
+            budget: STARTUP_RETRY_BUDGET,
+        }),
+        auth.fetchWhoamiResponse({
+            config: authConfig,
+            budget: STARTUP_RETRY_BUDGET,
+        }),
+    ]);
     let offlineNotice = null;
     let serverModels;
-    try {
-        serverModels = await models.fetchServerModels({ config: authConfig });
+    if (modelsOutcome.status === 'fulfilled') {
+        serverModels = modelsOutcome.value;
     }
-    catch (error) {
-        if (isTransientNetworkError(error) && cachedModels?.models.length) {
-            serverModels = { models: cachedModels.models };
-            offlineNotice = error?.message ? String(error.message) : 'network error';
-        }
-        else {
-            throw error;
-        }
+    else if (isTransientNetworkError(modelsOutcome.reason) &&
+        cachedModels?.models.length) {
+        serverModels = { models: cachedModels.models };
+        offlineNotice = unreachableReason(modelsOutcome.reason);
+    }
+    else if (isTransientNetworkError(modelsOutcome.reason)) {
+        throw new Error(`Couldn't reach TheGitAI to load your models (${unreachableReason(modelsOutcome.reason)}).\nCheck your internet connection and run \`ai\` again.`);
+    }
+    else {
+        throw modelsOutcome.reason;
     }
     let whoami;
-    try {
-        whoami = await auth.fetchWhoamiResponse({ config: authConfig });
+    if (whoamiOutcome.status === 'fulfilled') {
+        whoami = whoamiOutcome.value;
+    }
+    else if (isTransientNetworkError(whoamiOutcome.reason)) {
+        whoami = {
+            customer: {
+                id: '',
+                uuid: '',
+                email: authConfig.email,
+                customer_type: authConfig.customerType ?? 'USER',
+                scopes: [],
+            },
+            debugUi: { showSessionId: false },
+        };
+        offlineNotice ??= unreachableReason(whoamiOutcome.reason);
     }
-    catch (error) {
-        if (isTransientNetworkError(error)) {
-            whoami = {
-                customer: {
-                    id: '',
-                    uuid: '',
-                    email: authConfig.email,
-                    customer_type: authConfig.customerType ?? 'USER',
-                    scopes: [],
-                },
-                debugUi: { showSessionId: false },
-            };
-            offlineNotice ??= error?.message ? String(error.message) : 'network error';
-        }
-        else {
-            throw error;
-        }
+    else {
+        throw whoamiOutcome.reason;
     }
     if (offlineNotice) {
         console.error(chalk.yellow(`⚠ Couldn't reach TheGitAI (${offlineNotice}). Starting with cached settings — it will reconnect on your next message.`));
     }
-    if (listSessions) {
-        printSessionList(rootDir, listSessionMetadata(rootDir), serverModels);
-        return;
-    }
-    const sourceSnapshot = sessionIdentifier
-        ? loadSessionSnapshot(rootDir, sessionIdentifier)
-        : null;
     const selectedModelId = models.selectServerModel({
         requestedModelId: sourceSnapshot?.modelId ?? null,
         cached: cachedModels,
@@ -450,66 +234,41 @@ export async function main() {
         autoYes,
         modelId: selectedModelId,
     });
-    session.confirmCommand = makeConfirmCommand(session);
-    session.confirmPatch = makeConfirmPatch(session);
     if (sourceSnapshot) {
         applySessionSnapshot(session, sourceSnapshot);
-        await saveSessionBoth({ session, serverSessionClient });
     }
-    setScratchSession(session.sessionId);
-    const projectIndex = createIndex({
-        rootDir,
-        onStatus: (message) => {
-            if (message.trim()) {
-                console.log(chalk.dim(`  ${message}`));
-            }
-        },
-        onContextLog: (message) => {
-            if (message.trim()) {
-                console.log(chalk.cyan(`  ${message}`));
-            }
-        },
-    });
     const initialPrompt = prompt || undefined;
-    if (shouldUseClientRatatuiShell()) {
-        await runClientInteractive({
-            appendPromptHistory: (value) => appendPromptHistory(value, session.env),
-            authConfig,
-            debugUi: whoami.debugUi,
-            projectIndex,
-            serverModels,
-            serverSessionClient,
-            session,
-            initialPrompt,
-            usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
-        });
-        await saveSessionBoth({ session, serverSessionClient });
-        printSessionExit(session);
+    const outcome = await runClientInteractive({
+        appendPromptHistory: (value) => appendPromptHistory(value, session.env),
+        authConfig,
+        debugUi: whoami.debugUi,
+        serverModels,
+        serverSessionClient,
+        session,
+        initialPrompt,
+        usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
+    });
+    if (outcome.signedOut) {
+        if (sessionHasUserMessage(session)) {
+            saveSessionState(session);
+        }
+        console.log(chalk.green('\n✓ Logged out.\n'));
         return;
     }
-    printStartupBanner(rootDir, modelLabel(serverModels, session.modelId), session.autoYes);
-    printSessionStartup(session);
-    setBackgroundJobSession(session.sessionId);
-    try {
-        await mainInteractive({
-            authConfig,
-            projectIndex,
-            serverModels,
-            serverSessionClient,
-            session,
-            usageText: async () => formatUsageText(await auth.fetchWhoamiResponse({ config: authConfig })),
-            initialPrompt,
-        });
-        await saveSessionBoth({ session, serverSessionClient });
-        printSessionExit(session);
-    }
-    finally {
-        killAllBackgroundJobs({ sessionId: session.sessionId, remove: true });
-        setBackgroundJobSession(null);
-        setScratchSession(null);
-    }
+    await saveSessionBoth({ session, serverSessionClient });
+    printSessionExit(session);
 }
 main().catch((error) => {
-    console.error(chalk.red(`\n✖ Error: ${error.message}\n`));
+    if (isSignInCancelled(error)) {
+        console.error(chalk.dim('\nSign-in cancelled. Nothing was saved.\n'));
+        process.exit(130);
+    }
+    if (isAuthenticationError(error)) {
+        auth.clearCliAuthConfig();
+        console.error(chalk.red(`\n✖ Error: ${authenticationErrorMessage(error)}\n`));
+    }
+    else {
+        console.error(chalk.red(`\n✖ Error: ${error.message}\n`));
+    }
     process.exit(1);
 });

package/dist/src/agent-mode.js

@@ -1,14 +1,9 @@
 export const AGENT_MODES = ['default', 'auto-accept', 'plan'];
 const PLAN_MODE_TOOL_NAMES = new Set([
-    'search_code',
     'list_files',
     'list_directories',
     'read_file',
     'grep_code',
-    'find_symbol',
-    'list_symbols',
-    'hover_symbol',
-    'signature_help',
     'read_document',
     'analyze_image',
     'run_command',
@@ -46,7 +41,7 @@ export function nextAgentMode(mode) {
 export function agentModeAllowsTool(mode, toolName) {
     return mode !== 'plan' || PLAN_MODE_TOOL_NAMES.has(toolName);
 }
-function getUnquotedShellText(command) {
+export function getUnquotedShellText(command) {
     let quote = null;
     let escaped = false;
     let text = '';

package/dist/src/api/auth.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { getClientStateDir } from '../client-state.js';
-import { ServerApiError, authorizedJson, createTraceContext, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } from './http.js';
+import { ServerApiError, authorizedJson, createTraceContext, failureCode, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } from './http.js';
 export function getAuthConfigPath(env = process.env) {
     const configured = String(env.THEGITAI_AUTH_CONFIG ?? '').trim();
     if (configured) {
@@ -50,12 +50,14 @@ export async function fetchWhoami({ config, fetchImpl = globalThis.fetch, }) {
     const data = await fetchWhoamiResponse({ config, fetchImpl });
     return data.customer;
 }
-export async function fetchWhoamiResponse({ config, fetchImpl = globalThis.fetch, }) {
+export async function fetchWhoamiResponse({ config, fetchImpl = globalThis.fetch, budget = {}, }) {
+    const { timeoutMs, ...ladder } = budget;
     const data = (await retryTransient(() => authorizedJson({
         config,
         path: '/v1/auth/whoami',
         fetchImpl,
-    })));
+        ...(timeoutMs == null ? {} : { timeoutMs }),
+    }), ladder));
     if (!data?.customer?.email) {
         throw new Error('Server returned an invalid whoami response.');
     }
@@ -78,6 +80,6 @@ export async function logoutFromServer({ config, fetchImpl = globalThis.fetch, }
     });
     if (!response.ok && response.status !== 401) {
         const data = (await readJsonResponse(response));
-        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
+        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId, failureCode(data));
     }
 }