@thegitai/cli 1.0.0-preview.48 → 1.0.0-preview.49

package/dist/src/api/startup-handshake.js

@@ -0,0 +1,36 @@
+import { fetchWhoamiResponse } from './auth.js';
+import { STARTUP_RETRY_BUDGET, isTransientNetworkError, } from './http.js';
+import { fetchServerModels } from './models.js';
+import { abortableDelay, createTurnRecovery, isRetryableTurnFailure, isTurnRecoveryExhausted, } from './turn-recovery.js';
+export async function loadStartupHandshake({ config, canStartOffline, fetchImpl, budget = STARTUP_RETRY_BUDGET, sleep = abortableDelay, onStatus = () => { }, }) {
+    let lastFailure;
+    const recovery = createTurnRecovery({
+        signal: new AbortController().signal,
+        sleep,
+        onStatus: (status) => onStatus(status, lastFailure),
+    });
+    const attempt = async () => {
+        const [models, whoami] = await Promise.allSettled([
+            fetchServerModels({ config, fetchImpl, budget }),
+            fetchWhoamiResponse({ config, fetchImpl, budget }),
+        ]);
+        const unreachable = models.status === 'rejected' &&
+            isRetryableTurnFailure(models.reason) &&
+            !(canStartOffline && isTransientNetworkError(models.reason));
+        if (unreachable) {
+            lastFailure = models.reason;
+            throw models.reason;
+        }
+        return { models, whoami };
+    };
+    try {
+        return await recovery.run('loading your models', attempt);
+    }
+    catch (error) {
+        const reason = isTurnRecoveryExhausted(error) ? error.cause : error;
+        return {
+            models: { status: 'rejected', reason },
+            whoami: { status: 'rejected', reason },
+        };
+    }
+}

package/dist/src/api/turn-recovery.js

@@ -0,0 +1,189 @@
+import { isTransientNetworkError, ServerApiError, transportFailureDetail, } from './http.js';
+export const TURN_RECOVERY_DELAY_MS = 10_000;
+export const TURN_RECOVERY_RETRIES = 3;
+export const TURN_REQUEST_TIMEOUT_MS = 30_000;
+export const TURN_STREAM_IDLE_TIMEOUT_MS = 60_000;
+const RETRYABLE_TURN_STATUSES = new Set([408, 500, 502, 503, 504, 520, 521, 522, 523, 524]);
+export function isRetryableTurnStatus(status) {
+    return RETRYABLE_TURN_STATUSES.has(status);
+}
+export function isRetryableTurnFailure(error) {
+    if (error instanceof ServerApiError)
+        return isRetryableTurnStatus(error.status);
+    return isTransientNetworkError(error);
+}
+export function interruptedStream(message = 'The turn stream ended before the turn finished.') {
+    return Object.assign(new Error(message), { code: 'ECONNRESET' });
+}
+export function formatTurnRecoveryStatus(status) {
+    if (status.phase === 'waiting') {
+        return `Connection interrupted · retrying in ${TURN_RECOVERY_DELAY_MS / 1000}s · retry ${status.retry}/${TURN_RECOVERY_RETRIES}`;
+    }
+    if (status.phase === 'reconnecting') {
+        return `Reconnecting · retry ${status.retry}/${TURN_RECOVERY_RETRIES}`;
+    }
+    if (status.phase === 'reconnected')
+        return 'Reconnected';
+    if (status.phase === 'continuing')
+        return 'Server restarted · continuing from the finished steps';
+    if (status.phase === 'continued')
+        return 'Server restarted · continued from the finished steps';
+    return 'Connection restored · continued the same turn';
+}
+export const TURN_RECOVERY_EXHAUSTED = 'TURN_RECOVERY_EXHAUSTED';
+export function isTurnRecoveryExhausted(error) {
+    return error?.code === TURN_RECOVERY_EXHAUSTED;
+}
+function recoveryExhausted(operation, cause) {
+    const detail = transportFailureDetail(cause);
+    const reason = detail ?? (cause instanceof ServerApiError ? `HTTP ${cause.status}` : 'no response');
+    return Object.assign(new Error(`Connection lost while ${operation} (${reason}). Reconnecting failed after ${TURN_RECOVERY_RETRIES} retries. Some actions in this turn may already have completed.`, { cause }), { code: TURN_RECOVERY_EXHAUSTED });
+}
+export function abortableDelay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+function untilAborted(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(signal.reason);
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(signal.reason);
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise
+            .then(resolve, reject)
+            .finally(() => signal.removeEventListener('abort', onAbort));
+    });
+}
+export function createTurnRecovery({ signal, onStatus = () => { }, sleep = abortableDelay, }) {
+    const affected = new Set();
+    let retry = 0;
+    let gate = null;
+    let exhausted = null;
+    async function retryAfter(token, operation, error, caller = signal) {
+        signal.throwIfAborted();
+        withdrawIfAborted(token, caller);
+        if (exhausted)
+            throw exhausted;
+        if (!isRetryableTurnFailure(error))
+            throw error;
+        affected.add(token);
+        if (!gate) {
+            if (retry === TURN_RECOVERY_RETRIES) {
+                exhausted = recoveryExhausted(operation, error);
+                throw exhausted;
+            }
+            retry += 1;
+            const current = retry;
+            onStatus({ phase: 'waiting', retry: current });
+            gate = sleep(TURN_RECOVERY_DELAY_MS, signal)
+                .then(() => {
+                signal.throwIfAborted();
+                onStatus({ phase: 'reconnecting', retry: current });
+            })
+                .finally(() => {
+                gate = null;
+            });
+        }
+        if (caller === signal) {
+            await gate;
+            return;
+        }
+        await untilAborted(gate, caller).catch((reason) => {
+            withdrawIfAborted(token, caller);
+            throw reason;
+        });
+    }
+    function withdrawIfAborted(token, caller) {
+        if (!caller.aborted)
+            return;
+        affected.delete(token);
+        throw caller.reason;
+    }
+    function reconnected(token) {
+        if (!affected.has(token) || gate || exhausted)
+            return;
+        onStatus({ phase: 'reconnected' });
+    }
+    function restored(token) {
+        if (!affected.delete(token))
+            return;
+        if (affected.size > 0 || gate || exhausted)
+            return;
+        retry = 0;
+        onStatus({ phase: 'restored' });
+    }
+    async function run(operation, attempt, caller = signal) {
+        const token = {};
+        for (;;) {
+            signal.throwIfAborted();
+            withdrawIfAborted(token, caller);
+            if (exhausted)
+                throw exhausted;
+            try {
+                const value = await attempt();
+                restored(token);
+                return value;
+            }
+            catch (error) {
+                await retryAfter(token, operation, error, caller);
+            }
+        }
+    }
+    return { run, retryAfter, reconnected, restored };
+}
+export async function fetchTurnAttempt(fetchImpl, url, init, signal, { readBody = false } = {}) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(signal.reason);
+    signal.addEventListener('abort', onAbort, { once: true });
+    if (signal.aborted)
+        onAbort();
+    const timer = setTimeout(() => controller.abort(new DOMException('The request did not get a response in time.', 'TimeoutError')), TURN_REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(url, { ...init, signal: controller.signal });
+        if (!readBody && response.ok)
+            return response;
+        return new Response(await response.arrayBuffer(), {
+            status: response.status,
+            headers: response.headers,
+        });
+    }
+    finally {
+        clearTimeout(timer);
+        signal.removeEventListener('abort', onAbort);
+    }
+}
+export async function readTurnChunk(reader, signal) {
+    let timer;
+    let onAbort;
+    try {
+        return await Promise.race([
+            reader.read(),
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(interruptedStream(`The turn stream sent nothing for ${TURN_STREAM_IDLE_TIMEOUT_MS / 1000} seconds.`)), TURN_STREAM_IDLE_TIMEOUT_MS);
+                onAbort = () => reject(signal.reason);
+                signal.addEventListener('abort', onAbort, { once: true });
+                if (signal.aborted)
+                    onAbort();
+            }),
+        ]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (onAbort)
+            signal.removeEventListener('abort', onAbort);
+    }
+}

package/dist/src/help-text.js

@@ -194,6 +194,13 @@ const HELP_MARKDOWN = [
     '  computer" on that page, and paste the code back into the terminal.',
     '- A local session was used with a different sign-in → sign in with the',
     '  account you used for that session or start a new session.',
+    '- The connection drops mid-turn → nothing to do: the CLI reconnects to the',
+    '  same turn up to three times, ten seconds apart, without running anything',
+    '  twice. Esc stops it. If it cannot reconnect it says so; some actions may',
+    '  already have completed, and a queued message waits in the composer.',
+    '  If the service restarted mid-turn, the turn continues from the steps that',
+    '  had finished. Starting `ai` while the service is briefly unavailable waits',
+    '  the same way.',
     '- For anything else, re-run the command and file the printed error',
     '  message with `/report` — there is no client-side debug mode by design.',
 ].join('\n');

package/dist/src/tool-executor.js

@@ -213,6 +213,7 @@ function recordAssistantEdit(session, call, result, before) {
     clearEditFailure(session.clientState.safety, filePath);
 }
 export async function executeLocalToolCall(session, call) {
+    session.turnAbortSignal?.throwIfAborted();
     session.onStatus(formatToolCallForStatus(call));
     try {
         const agentModeBlocked = buildAgentModeToolBlockedResult(session.agentMode, call);

package/dist/src/ui/repl.js

@@ -12,7 +12,8 @@ export { getInputCommandToken, getSlashCommandSuggestions, SLASH_COMMANDS, slash
 import { composerInputWidth, frameContentWidth } from './tui/composer-layout.js';
 import { agentModeLabel, nextAgentMode, } from '../agent-mode.js';
 import { chat, models } from '../api/index.js';
-import { isTurnCancelledError } from '../api/chat.js';
+import { isTurnCancelledError, isTurnOutcomeKnown } from '../api/chat.js';
+import { formatTurnRecoveryStatus } from '../api/turn-recovery.js';
 import { getJobBufferedOutput, getJobOutputPreview, hasRunningBackgroundJobs, killAllBackgroundJobs, killBackgroundJob, listBackgroundJobs, setBackgroundJobSession, setBackgroundJobUpdateHook, } from '../background-jobs.js';
 import { clearTodos, listTodos, setTodoSession } from '../todo-list.js';
 import { setScratchSession } from '../scratch-dir.js';
@@ -542,15 +543,7 @@ function getToolFilePath(call, result) {
         '').trim();
 }
 function formatToolResultState(result) {
-    if (result?.skipped)
-        return 'Skipped';
-    if (result?.blocked)
-        return 'Blocked';
-    if (result?.ok === true)
-        return 'OK';
-    if (Number.isInteger(result?.httpStatus))
-        return String(result.httpStatus);
-    return 'Failed';
+    return result?.skipped ? 'Skipped' : 'OK';
 }
 function formatRunCommandResultState(result) {
     if (result?.timedOut)
@@ -588,12 +581,15 @@ function buildFileChangeEntry(event) {
             : call.name === 'undo_edit'
                 ? 'Undo'
                 : 'Edit';
-        return {
-            body: error || `${call.name} ${filePath}`,
-            filePath,
-            kind: skipped ? 'system' : 'error',
-            title: skipped ? `${verb} skipped: ${filePath}` : `${verb} failed: ${filePath}`,
-        };
+        if (skipped) {
+            return {
+                body: error || `${call.name} ${filePath}`,
+                filePath,
+                kind: 'system',
+                title: `${verb} skipped: ${filePath}`,
+            };
+        }
+        return { body: '', filePath, kind: 'system', title: `${verb}: ${filePath}` };
     }
     if (result?.scratch === true) {
         const scratchName = truncate(filePath.split(/[\\/]/).filter(Boolean).at(-1) ?? filePath, 72);
@@ -710,22 +706,25 @@ function buildFileChangeEntry(event) {
 }
 export function buildWorkingToolEntry(event) {
     const { call, result } = event;
-    const error = typeof result?.error === 'string' && result.error.trim()
+    const failed = result?.ok !== true && result?.skipped !== true;
+    const kind = result?.ok === true ? 'tool' : 'system';
+    const state = (text) => (failed ? '' : text);
+    const error = !failed && typeof result?.error === 'string' && result.error.trim()
         ? `\n${truncate(result.error.trim(), 180)}`
         : '';
     if (call.name === 'run_command') {
         const command = String(call.args?.command ?? result?.command ?? '').trim();
         if (result?.backgrounded === true && result?.jobId) {
             return {
-                body: `$ ${truncate(command, 180)}\nBackground job ${String(result.jobId)} started.${error}`,
-                kind: result?.ok === true ? 'tool' : 'error',
+                body: `$ ${truncate(command, 180)}${state(`\nBackground job ${String(result.jobId)} started.`)}${error}`,
+                kind,
                 preformatted: true,
                 title: 'Shell',
             };
         }
         return {
-            body: `$ ${truncate(command, 180)}\n${formatRunCommandResultState(result)}${error}`,
-            kind: result?.ok === true ? 'tool' : 'error',
+            body: `$ ${truncate(command, 180)}${state(`\n${formatRunCommandResultState(result)}`)}${error}`,
+            kind,
             title: 'Shell',
         };
     }
@@ -737,15 +736,15 @@ export function buildWorkingToolEntry(event) {
             ? `${status}${exitCode != null ? ` (code ${exitCode})` : ''}`
             : formatToolResultState(result);
         return {
-            body: `${jobId || '(unknown job)'} · ${stateText}${error}`,
-            kind: result?.ok === true ? 'tool' : 'error',
+            body: `${jobId || '(unknown job)'}${state(` · ${stateText}`)}${error}`,
+            kind,
             title: call.name === 'shell_job_kill' ? 'Kill job' : 'Job output',
         };
     }
     if (call.name === 'run_node_script') {
         return {
-            body: `node --input-type=module <script via stdin>\n${formatRunCommandResultState(result)}${error}`,
-            kind: result?.ok === true ? 'tool' : 'error',
+            body: `node --input-type=module <script via stdin>${state(`\n${formatRunCommandResultState(result)}`)}${error}`,
+            kind,
             title: 'Node',
         };
     }
@@ -754,8 +753,8 @@ export function buildWorkingToolEntry(event) {
     }
     const args = formatToolArgs(call, result);
     return {
-        body: `${call.name}${args ? ` ${args}` : ''} -> ${formatToolResultState(result)}${error}`,
-        kind: result?.ok === true ? 'tool' : 'error',
+        body: `${call.name}${args ? ` ${args}` : ''}${state(` -> ${formatToolResultState(result)}`)}${error}`,
+        kind,
         title: 'Tool',
     };
 }
@@ -873,10 +872,10 @@ export function buildTranscriptFromSessionHistory(history) {
             }
             if (!call || !isFileChangeTool(call.name))
                 continue;
-            entries.push(buildFileChangeEntry({
-                call,
-                result: functionResponse.response ?? {},
-            }));
+            const result = (functionResponse.response ?? {});
+            if (result.ok !== true && result.skipped !== true)
+                continue;
+            entries.push(buildFileChangeEntry({ call, result }));
         }
         if (entry.role === 'user' && entry.kind === 'turnStart') {
             const text = displayUserTextFromHistoryEntry(entry);
@@ -1751,6 +1750,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 promptHistoryCursor: queued ? null : current.promptHistoryCursor,
                 promptHistoryDraft: queued ? '' : current.promptHistoryDraft,
                 queuedMessage: null,
+                recoveryStatus: '',
                 status: 'Ready',
                 thinkingTitle: '',
                 thinkingNotes: [],
@@ -2009,13 +2009,18 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             pending.resolve(result);
             scheduleLiveFrameRemount();
         };
-        const openApprovalPrompt = (request) => new Promise((resolve) => {
+        const openApprovalPrompt = (request, signal) => new Promise((resolve) => {
             const deny = { kind: 'deny' };
-            if (exiting) {
+            if (exiting || signal?.aborted) {
                 resolve(deny);
                 return;
             }
-            resolvePermissionDecision = resolve;
+            const onAbort = () => dismissPendingApproval();
+            signal?.addEventListener('abort', onAbort, { once: true });
+            resolvePermissionDecision = (decision) => {
+                signal?.removeEventListener('abort', onAbort);
+                resolve(decision);
+            };
             store.update((current) => ({
                 ...pauseBusyClock(current, Date.now()),
                 ...closedJobsPickerFields(current),
@@ -2816,6 +2821,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 busyPausedAt: null,
                 busySince: turnStartedAt,
                 clockNow: turnStartedAt,
+                recoveryStatus: '',
                 status: 'Running turn...',
                 thinkingTitle: '',
                 thinkingNotes: [],
@@ -2897,6 +2903,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     busy: false,
                     busyPausedAt: null,
                     busySince: null,
+                    recoveryStatus: '',
                     status: result.waitingForApproval ? 'Awaiting approval' : 'Ready',
                     tokenUsage: formatClientTokenUsage(Date.now() - turnStartedAt, latestUsageSummary),
                 }));
@@ -2913,6 +2920,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 const cancelled = isTurnCancelledError(error);
                 if (exitForAuthenticationError(error))
                     return;
+                dismissPendingApproval();
+                dismissPendingSudoPassword();
+                dismissPendingUserInput();
                 const failedTurnAttachments = activeTurnImageAttachments;
                 activeTurnImageAttachments = [];
                 const quotaNotice = cancelled ? null : buildQuotaNotice(error);
@@ -2925,6 +2935,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     busySince: null,
                     commandLog: [],
                     imageAttachments: failedTurnAttachments,
+                    recoveryStatus: '',
                     status: cancelled
                         ? 'Ready'
                         : quotaNotice
@@ -2964,8 +2975,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                     appendStaticEntries(buildTurnFailureHintEntries(cancelled));
                 }
                 await remountTui();
-                recoverUnacknowledgedMessages(!cancelled);
-                if (!cancelled && turnGeneration === activeTurnGeneration) {
+                const autoSubmits = !cancelled && isTurnOutcomeKnown(error);
+                recoverUnacknowledgedMessages(autoSubmits);
+                if (autoSubmits && turnGeneration === activeTurnGeneration) {
                     await flushQueuedMessage();
                 }
             }
@@ -2988,6 +3000,23 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 generatingImage: activeImageCount > 0 ? false : current.generatingImage,
             }));
         };
+        session.onRecovery = (status) => {
+            if (status.phase === 'restored' || status.phase === 'continued') {
+                store.update((current) => ({ ...current, recoveryStatus: '' }));
+                appendTurnAwareEntry(status.phase === 'restored'
+                    ? { body: 'Continued the same turn.', kind: 'system', title: 'Connection restored' }
+                    : {
+                        body: 'Continued from the steps that had finished.',
+                        kind: 'system',
+                        title: 'Server restarted',
+                    });
+                return;
+            }
+            store.update((current) => ({
+                ...current,
+                recoveryStatus: status.phase === 'reconnected' ? '' : formatTurnRecoveryStatus(status),
+            }));
+        };
         session.onImageGeneration = (active) => {
             store.update((current) => ({
                 ...current,
@@ -3026,7 +3055,9 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             if (isFileChangeTool(event.call.name)) {
                 const entry = buildFileChangeEntry(event);
                 store.appendWorkingTool(entry);
-                appendTurnAwareEntry(entry);
+                const result = event.result;
+                if (result?.ok === true || result?.skipped === true)
+                    appendTurnAwareEntry(entry);
                 return;
             }
             store.appendWorkingTool(buildWorkingToolEntry(event));
@@ -3079,7 +3110,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 return deny;
             if (sessionAutoYes)
                 return { kind: 'once' };
-            const decision = await openApprovalPrompt(request);
+            const decision = await openApprovalPrompt(request, session.turnAbortSignal);
             if (decision.kind === 'always-bucket') {
                 appendTurnAwareEntry({
                     body: `Allowed for the rest of this session: ${bucketActionLabel(request.bucket)}.`,

package/dist/src/ui/tui/build-frame.js

@@ -691,6 +691,20 @@ function thinkingHeaderLine(spinnerFrame, title, width) {
 function thinkingNoteLine(note, width) {
     return line(span('│  ', { color: 'green' }), span(fitLine(note, Math.max(8, width - 3)), { color: 'ansi256(248)' }));
 }
+function buildRecoveryStatusLines(status, width) {
+    const [label = '', ...rest] = status.split(' · ');
+    const detail = rest.join(' · ');
+    const labelSpan = span(fitLine(label, Math.max(1, width - 2)), { color: 'yellow', bold: true });
+    if (!detail)
+        return [line(span('● ', { color: 'yellow' }), labelSpan)];
+    if (displayWidth(`● ${label} · ${detail}`) <= width) {
+        return [line(span('● ', { color: 'yellow' }), labelSpan, span(` · ${detail}`))];
+    }
+    return [
+        line(span('● ', { color: 'yellow' }), labelSpan),
+        ...wrapText(detail, Math.max(1, width - 2)).map((row) => plainLine(`  ${row}`)),
+    ];
+}
 function buildLiveLines(state, width, spinnerFrame, elapsedSeconds, nowMs) {
     if (!state.busy)
         return [];
@@ -722,6 +736,9 @@ function buildLiveLines(state, width, spinnerFrame, elapsedSeconds, nowMs) {
         lines.push(plainLine(''));
     }
     lines.push(plainLine(buildWorkingClockLine(state, elapsedSeconds), { color: 'yellow' }));
+    if (state.recoveryStatus) {
+        lines.push(...buildRecoveryStatusLines(state.recoveryStatus, width));
+    }
     const turnMessages = state.turnMessages ?? [];
     if (turnMessages.length > 0) {
         lines.push(plainLine(''));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thegitai/cli",
-  "version": "1.0.0-preview.48",
+  "version": "1.0.0-preview.49",
   "description": "TheGitAI is an agentic AI coding tool for your terminal. It reads and searches your repository, writes and edits files, runs your tests, and verifies the change before handing it back.",
   "keywords": [
     "agentic-ai",
@@ -44,11 +44,11 @@
     "@lydell/node-pty-linux-x64": "1.1.0",
     "@lydell/node-pty-win32-arm64": "1.1.0",
     "@lydell/node-pty-win32-x64": "1.1.0",
-    "@thegitai/tui-darwin-arm64": "1.0.0-preview.48",
-    "@thegitai/tui-darwin-x64": "1.0.0-preview.48",
-    "@thegitai/tui-linux-arm64": "1.0.0-preview.48",
-    "@thegitai/tui-linux-x64": "1.0.0-preview.48",
-    "@thegitai/tui-win32-x64": "1.0.0-preview.48",
+    "@thegitai/tui-darwin-arm64": "1.0.0-preview.49",
+    "@thegitai/tui-darwin-x64": "1.0.0-preview.49",
+    "@thegitai/tui-linux-arm64": "1.0.0-preview.49",
+    "@thegitai/tui-linux-x64": "1.0.0-preview.49",
+    "@thegitai/tui-win32-x64": "1.0.0-preview.49",
     "@vscode/ripgrep": "1.18.0"
   },
   "repository": {