@thegitai/cli 1.0.0-preview.24 → 1.0.0-preview.26

package/dist/bin/ai.js

@@ -4,7 +4,7 @@ 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 { authenticationErrorMessage, isAuthenticationError, isTransientNetworkError, } from '../src/api/http.js';
+import { STARTUP_RETRY_BUDGET, authenticationErrorMessage, isAuthenticationError, isTransientNetworkError, } from '../src/api/http.js';
 import { formatCliHelpText } from '../src/help-text.js';
 import { createIndex } from '../src/project-index.js';
 import { createSession } from '../src/session.js';
@@ -20,6 +20,20 @@ const { auth, chat, models, sessions } = ServerApi;
 function printUsage() {
     console.log(formatCliHelpText({ color: process.stdout.isTTY === true }));
 }
+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';
+}
 async function promptText(question, fallback = null) {
     const rl = readline.createInterface({ input, output });
     try {
@@ -184,41 +198,51 @@ export async function main() {
     const authConfig = requireCliAuthConfig();
     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;
     }
-    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 if (isTransientNetworkError(whoamiOutcome.reason)) {
+        whoami = {
+            customer: {
+                id: '',
+                uuid: '',
+                email: authConfig.email,
+                customer_type: authConfig.customerType ?? 'USER',
+                scopes: [],
+            },
+            debugUi: { showSessionId: false },
+        };
+        offlineNotice ??= unreachableReason(whoamiOutcome.reason);
+    }
+    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.`));

package/dist/src/api/auth.js

@@ -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.');
     }

package/dist/src/api/chat.js

@@ -2,6 +2,7 @@ import { drainBackgroundJobNotifications } from '../background-jobs.js';
 import { createPromptCheckpoint, sanitizeSessionSafetyForServer, } from '../session-safety.js';
 import { applySessionSnapshot, saveSessionState, snapshotFromSession, } from '../session-store.js';
 import { executeLocalToolCall } from '../tool-executor.js';
+import { saveGeneratedImage } from '../tools/save-generated-image.js';
 import { isUserInputQuestionArray } from './contracts.js';
 import { createTraceContext, gatewayFailureCategory, normalizeServerUrl, readErrorResponse, } from './http.js';
 import { collectClientEnvironment } from '../client-environment.js';
@@ -165,6 +166,9 @@ function publicStatusMessage(data) {
     if (event.phase === 'analyzing_image') {
         return (event.imageCount ?? 1) > 1 ? 'Analyzing images...' : 'Analyzing image...';
     }
+    if (event.phase === 'generating_image') {
+        return 'Generating image...';
+    }
     if (event.phase === 'running_tool')
         return `Running ${toolName}...`;
     if (event.phase === 'waiting_for_tool')
@@ -312,7 +316,14 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
     }
     try {
         const call = normalizeShellJobToolCall(event.call);
-        const rawResult = await executeLocalToolCall({ projectIndex }, session, call);
+        const rawResult = event.generatedImage
+            ? saveGeneratedImage({
+                base64Data: event.generatedImage.base64Data,
+                mimeType: event.generatedImage.mimeType,
+                suggestedFilename: event.generatedImage.suggestedFilename ||
+                    String(call.args?.filename ?? call.args?.file_name ?? ''),
+            })
+            : await executeLocalToolCall({ projectIndex }, session, call);
         preserveCancelledTurnToolResult(session, input, { ...event, call }, rawResult);
         if (signal?.aborted) {
             throw new TurnCancelledError();
@@ -383,9 +394,15 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             const data = event.data;
             if (data?.phase === 'analyzing_image') {
                 session.onImageAnalysis?.(Math.max(1, Number(data.imageCount ?? 1) || 1));
+                session.onImageGeneration?.(false);
+            }
+            else if (data?.phase === 'generating_image') {
+                session.onImageGeneration?.(true);
+                session.onImageAnalysis?.(0);
             }
             else if (data?.phase) {
                 session.onImageAnalysis?.(0);
+                session.onImageGeneration?.(false);
             }
             const message = publicStatusMessage(event.data);
             if (message)

package/dist/src/api/http.js

@@ -29,6 +29,14 @@ export function createTraceContext(traceId = createTraceId()) {
     };
 }
 export const REQUEST_TIMEOUT_MS = 8000;
+export const STARTUP_REQUEST_TIMEOUT_MS = 3000;
+export const STARTUP_DEADLINE_MS = 10_000;
+export const STARTUP_RETRY_BUDGET = {
+    retries: 3,
+    baseDelayMs: 200,
+    deadlineMs: STARTUP_DEADLINE_MS,
+    timeoutMs: STARTUP_REQUEST_TIMEOUT_MS,
+};
 const TRANSIENT_NETWORK_CODES = new Set([
     'ECONNRESET',
     'ECONNREFUSED',
@@ -60,7 +68,9 @@ export function isTransientNetworkError(error) {
     }
     return false;
 }
-export async function retryTransient(run, { retries = 2, baseDelayMs = 400 } = {}) {
+export async function retryTransient(run, { retries = 2, baseDelayMs = 400, deadlineMs, now = () => Date.now(), } = {}) {
+    const startedAt = now();
+    const remainingMs = () => deadlineMs == null ? Infinity : deadlineMs - (now() - startedAt);
     let attempt = 0;
     for (;;) {
         try {
@@ -70,6 +80,8 @@ export async function retryTransient(run, { retries = 2, baseDelayMs = 400 } = {
             if (attempt >= retries || !isTransientNetworkError(error))
                 throw error;
             const delayMs = baseDelayMs * 2 ** attempt;
+            if (remainingMs() <= delayMs)
+                throw error;
             attempt += 1;
             await new Promise((resolve) => setTimeout(resolve, delayMs));
         }

package/dist/src/api/models.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { getClientStateDir } from '../client-state.js';
 import { REQUEST_TIMEOUT_MS, ServerApiError, createTraceContext, failureCode, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } from './http.js';
@@ -58,12 +58,21 @@ export function selectCacheForServer(cached, serverUrl) {
 export function writeCachedServerModels(cache, env = process.env) {
     const filePath = getModelsCachePath(env);
     mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
-    writeFileSync(filePath, `${JSON.stringify(cache, null, 2)}\n`, {
-        encoding: 'utf8',
-        mode: 0o600,
-    });
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    try {
+        writeFileSync(tempPath, `${JSON.stringify(cache, null, 2)}\n`, {
+            encoding: 'utf8',
+            mode: 0o600,
+        });
+        renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        rmSync(tempPath, { force: true });
+        throw error;
+    }
 }
-export async function fetchServerModels({ config, fetchImpl = globalThis.fetch, }) {
+export async function fetchServerModels({ config, fetchImpl = globalThis.fetch, budget = {}, }) {
+    const { timeoutMs = REQUEST_TIMEOUT_MS, ...ladder } = budget;
     return retryTransient(async () => {
         const trace = createTraceContext();
         const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/models`, {
@@ -71,7 +80,7 @@ export async function fetchServerModels({ config, fetchImpl = globalThis.fetch,
                 authorization: `Bearer ${config.token}`,
                 ...trace.headers,
             },
-            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            signal: AbortSignal.timeout(timeoutMs),
         });
         const data = (await readJsonResponse(response));
         if (!response.ok) {
@@ -84,7 +93,7 @@ export async function fetchServerModels({ config, fetchImpl = globalThis.fetch,
             throw new Error('Server returned an invalid model list.');
         }
         return { models };
-    });
+    }, ladder);
 }
 export function selectServerModel({ requestedModelId, cached, serverModels, }) {
     const supportedIds = new Set(serverModels.models.map((model) => model.id));

package/dist/src/session-store.js

@@ -4,6 +4,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, w
 import path from 'node:path';
 import { getClientStateDir } from './client-state.js';
 import { findStoredImageByContent, pruneSessionImages, readSessionImage, sweepOrphanSessionImages, } from './core/session-image-store.js';
+import { sweepGeneratedImages } from './tools/save-generated-image.js';
 import { normalizeAssistantEditJournal } from './edit-journal.js';
 import { createSessionGrants } from './permissions.js';
 import { cloneSessionSafetyState, createSessionSafetyState, mergeLocalSessionSafetyState, normalizeSessionSafetyState, } from './session-safety.js';
@@ -224,6 +225,7 @@ export function pruneSavedSessions(rootDir, env = process.env) {
         activeSessionIds: listAllSessionIds(env),
         env,
     });
+    sweepGeneratedImages({ env });
 }
 export function readGitBranch(rootDir) {
     try {

package/dist/src/tools/index.js

@@ -23,6 +23,7 @@ import { strReplace } from './str-replace.js';
 import { undoEdit } from './undo-edit.js';
 import { updateTodos } from './update-todos.js';
 import { readImageFile } from './read-image-file.js';
+import { saveGeneratedImage } from './save-generated-image.js';
 import { writeFile } from './write-file.js';
 export const TOOL_MAP = {
     search_code: (context, args) => searchCode(context.projectIndex, args),
@@ -52,6 +53,16 @@ export const TOOL_MAP = {
     shell_job_kill: shellJobKill,
     update_todos: updateTodos,
     analyze_image: (context, args) => readImageFile(context, args),
+    generate_image: (_context, args) => {
+        if (!String(args.base64Data ?? '').trim()) {
+            return {
+                ok: false,
+                error: 'This CLI build cannot generate images without server-supplied image bytes. Update TheGitAI CLI.',
+                failureCategory: 'tool_exception',
+            };
+        }
+        return saveGeneratedImage(args);
+    },
 };
 function invalidToolCall(error) {
     return {

package/dist/src/tools/save-generated-image.js

@@ -0,0 +1,120 @@
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+import { getClientStateDir } from '../client-state.js';
+import { MAX_IMAGE_SIZE_BYTES, sniffImageMimeType, } from '../core/image-limits.js';
+const IMAGE_FILE_MODE = 0o600;
+const IMAGE_DIR_MODE = 0o700;
+export const GENERATED_IMAGES_SUBDIR = 'generated_images';
+export const GENERATED_IMAGE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+export function getGeneratedImagesDir(env = process.env) {
+    return path.join(getClientStateDir(env), GENERATED_IMAGES_SUBDIR);
+}
+export function sanitizeGeneratedImageBasename(raw) {
+    const trimmed = String(raw ?? '').trim();
+    const base = trimmed
+        .replace(/\\/g, '/')
+        .split('/')
+        .pop()
+        ?.replace(/^\.+/, '')
+        .replace(/[^\w.\-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-\.|\.-/g, '.')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80);
+    if (!base || base === '.' || base === '..') {
+        return `generated-${Date.now()}.png`;
+    }
+    if (/\.png$/i.test(base)) {
+        return base.replace(/\.png$/i, '.png');
+    }
+    const withoutExt = base.replace(/\.[^.]+$/, '').replace(/-+$/g, '');
+    return `${withoutExt || 'generated'}.png`;
+}
+function uniquePath(dir, basename) {
+    const candidate = path.join(dir, basename);
+    if (!existsSync(candidate)) {
+        return candidate;
+    }
+    const ext = path.extname(basename) || '.png';
+    const stem = path.basename(basename, ext);
+    for (let i = 2; i < 10_000; i += 1) {
+        const next = path.join(dir, `${stem}-${i}${ext}`);
+        if (!existsSync(next)) {
+            return next;
+        }
+    }
+    return path.join(dir, `${stem}-${Date.now()}${ext}`);
+}
+export function sweepGeneratedImages({ maxAgeMs = GENERATED_IMAGE_MAX_AGE_MS, env = process.env, now = Date.now(), } = {}) {
+    const dir = getGeneratedImagesDir(env);
+    if (!existsSync(dir))
+        return 0;
+    let removed = 0;
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        const filePath = path.join(dir, entry);
+        try {
+            if (now - statSync(filePath).mtimeMs < maxAgeMs)
+                continue;
+            rmSync(filePath, { force: true });
+            removed += 1;
+        }
+        catch {
+        }
+    }
+    return removed;
+}
+export function saveGeneratedImage(args) {
+    const base64Data = String(args.base64Data ?? '').trim();
+    if (!base64Data) {
+        return {
+            ok: false,
+            error: 'This CLI build cannot generate images without server-supplied image bytes. Update TheGitAI CLI.',
+            failureCategory: 'tool_exception',
+        };
+    }
+    let bytes;
+    try {
+        bytes = Buffer.from(base64Data, 'base64');
+    }
+    catch {
+        return {
+            ok: false,
+            error: 'Generated image bytes are invalid.',
+            failureCategory: 'invalid_argument',
+        };
+    }
+    if (bytes.length === 0 || bytes.length > MAX_IMAGE_SIZE_BYTES) {
+        return {
+            ok: false,
+            error: 'Generated image exceeded the allowed size limit.',
+            failureCategory: 'invalid_argument',
+        };
+    }
+    const sniffed = sniffImageMimeType(bytes);
+    if (sniffed !== 'image/png') {
+        return {
+            ok: false,
+            error: 'Generated image must be a PNG.',
+            failureCategory: 'invalid_argument',
+        };
+    }
+    const env = args.env ?? process.env;
+    const dir = getGeneratedImagesDir(env);
+    mkdirSync(dir, { recursive: true, mode: IMAGE_DIR_MODE });
+    const basename = sanitizeGeneratedImageBasename(args.suggestedFilename ?? args.filename);
+    const target = uniquePath(dir, basename);
+    writeFileSync(target, bytes, { mode: IMAGE_FILE_MODE });
+    return {
+        ok: true,
+        path: target,
+        message: `Image saved to ${target}`,
+    };
+}

package/dist/src/ui/repl.js

@@ -982,6 +982,7 @@ function createInitialShellState(session, serverModels, debugUi) {
         activeTurnInputPreformatted: false,
         agentMode: session.agentMode,
         analyzingImages: 0,
+        generatingImage: false,
         approvalCursor: 0,
         approvalPrompt: null,
         approvalScrollOffset: 0,
@@ -2623,6 +2624,7 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
                 activeTurnInput: input,
                 activeTurnInputPreformatted: preformatted,
                 analyzingImages: 0,
+                generatingImage: false,
                 busy: true,
                 busyPausedAt: null,
                 busySince: turnStartedAt,
@@ -2777,6 +2779,14 @@ export async function runClientInteractive({ appendPromptHistory, authConfig, de
             store.update((current) => ({
                 ...current,
                 analyzingImages: Math.max(0, activeImageCount),
+                generatingImage: activeImageCount > 0 ? false : current.generatingImage,
+            }));
+        };
+        session.onImageGeneration = (active) => {
+            store.update((current) => ({
+                ...current,
+                generatingImage: Boolean(active),
+                analyzingImages: active ? 0 : current.analyzingImages,
             }));
         };
         session.onStatus = (message) => {

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

@@ -953,11 +953,13 @@ export function buildWorkingClockLine(state, elapsedSeconds) {
     if (state.busyPausedAt != null) {
         return `${WORKING_CLOCK_ICON} Paused · ${elapsed} · waiting for your response`;
     }
-    const label = state.analyzingImages > 0
-        ? state.analyzingImages > 1
-            ? 'Analyzing images'
-            : 'Analyzing image'
-        : 'Working';
+    const label = state.generatingImage
+        ? 'Generating image'
+        : state.analyzingImages > 0
+            ? state.analyzingImages > 1
+                ? 'Analyzing images'
+                : 'Analyzing image'
+            : 'Working';
     return `${WORKING_CLOCK_ICON} ${label} · ${elapsed}`;
 }
 export function approvalPanelInnerWidth(width) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thegitai/cli",
-  "version": "1.0.0-preview.24",
+  "version": "1.0.0-preview.26",
   "description": "TheGitAI is an AI coding agent for your terminal. It indexes your repository, writes and edits files, runs commands, and builds features with you.",
   "keywords": [
     "ai",
@@ -37,10 +37,10 @@
     "@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.24",
-    "@thegitai/tui-darwin-x64": "1.0.0-preview.24",
-    "@thegitai/tui-linux-x64": "1.0.0-preview.24",
-    "@thegitai/tui-win32-x64": "1.0.0-preview.24",
+    "@thegitai/tui-darwin-arm64": "1.0.0-preview.26",
+    "@thegitai/tui-darwin-x64": "1.0.0-preview.26",
+    "@thegitai/tui-linux-x64": "1.0.0-preview.26",
+    "@thegitai/tui-win32-x64": "1.0.0-preview.26",
     "@vscode/ripgrep": "1.18.0"
   },
   "publishConfig": {