@thegitai/cli 1.0.0-beta.9 → 1.0.0-preview.10

package/dist/src/api/chat.js

@@ -1,8 +1,12 @@
+import { drainBackgroundJobNotifications } from '../background-jobs.js';
 import { createPromptCheckpoint, sanitizeSessionSafetyForServer, } from '../session-safety.js';
 import { applySessionSnapshot, snapshotFromSession, } from '../session-store.js';
 import { executeLocalToolCall } from '../tool-executor.js';
 import { createTraceContext, normalizeServerUrl, readErrorResponse, } from './http.js';
 import { collectClientEnvironment } from '../client-environment.js';
+import { collectProjectOrientation } from '../project-orientation.js';
+import { autoAttachImages } from '../core/image-path-extractor.js';
+import { formatTurnFailureMarker } from '../turn-failure-marker.js';
 export class TurnCancelledError extends Error {
     name = 'TurnCancelledError';
     constructor(message = 'Turn cancelled.') {
@@ -48,6 +52,7 @@ function parseSseBlock(block) {
         return { event, data: text };
     }
 }
+let toolStateSeqCounter = 0;
 function toolStateFromSession(session) {
     return {
         autoYes: session.autoYes,
@@ -63,6 +68,11 @@ function snapshotForServer(session) {
     snapshot.clientState.safety = sanitizeSessionSafetyForServer(snapshot.clientState.safety);
     return snapshot;
 }
+function imageAttachmentsForServer(attachments) {
+    return (attachments ?? []).map(({ filePath, ...attachment }) => attachment.source === 'file' && filePath
+        ? { ...attachment, filePath }
+        : attachment);
+}
 function userHistoryText(entry) {
     return (entry.parts ?? [])
         .map((part) => (typeof part?.text === 'string' ? part.text : ''))
@@ -85,16 +95,26 @@ export function preserveCancelledTurnInput(session, input) {
             return;
         break;
     }
-    session.history.push({ role: 'user', parts: [{ text }], kind: 'turnStart' });
+    session.history.push({
+        role: 'user',
+        parts: [{ text }],
+        kind: 'turnStart',
+        userInput: text,
+    });
 }
 function preserveFailedTurnInput(session, input, category) {
     const text = input.trim();
     if (!text)
         return;
-    session.history.push({ role: 'user', parts: [{ text }], kind: 'turnStart' });
+    session.history.push({
+        role: 'user',
+        parts: [{ text }],
+        kind: 'turnStart',
+        userInput: text,
+    });
     session.history.push({
         role: 'model',
-        parts: [{ text: `Turn failed before completion: ${category}.` }],
+        parts: [{ text: formatTurnFailureMarker(category) }],
     });
 }
 function historyHasToolCall(session, callId) {
@@ -136,17 +156,50 @@ function publicStatusMessage(data) {
         : 'tool';
     if (event.phase === 'thinking')
         return 'Thinking...';
+    if (event.phase === 'analyzing_image') {
+        return (event.imageCount ?? 1) > 1 ? 'Analyzing images...' : 'Analyzing image...';
+    }
     if (event.phase === 'running_tool')
         return `Running ${toolName}...`;
     if (event.phase === 'waiting_for_tool')
         return `Running ${toolName} locally...`;
     return null;
 }
+function normalizeShellJobToolCall(call) {
+    if (call.name !== 'shell_job_output' && call.name !== 'shell_job_kill') {
+        return call;
+    }
+    const args = call.args && typeof call.args === 'object' && !Array.isArray(call.args)
+        ? { ...call.args }
+        : {};
+    let changed = false;
+    if (args.job_id === undefined) {
+        const alias = args.jobId ?? args.id;
+        if (alias !== undefined) {
+            args.job_id = alias;
+            delete args.jobId;
+            delete args.id;
+            changed = true;
+        }
+    }
+    if (call.name === 'shell_job_output' && args.wait_ms === undefined) {
+        const alias = args.waitMs ?? args.wait ?? args.wait_millis;
+        if (alias !== undefined) {
+            args.wait_ms = alias;
+            delete args.waitMs;
+            delete args.wait;
+            delete args.wait_millis;
+            changed = true;
+        }
+    }
+    return changed ? { ...call, args } : call;
+}
 async function postToolResult({ config, turnId, event, result, session, fetchImpl, traceId, }) {
     const payload = {
         toolCallId: event.call.id,
         result,
         toolState: toolStateFromSession(session),
+        toolStateSeq: ++toolStateSeqCounter,
     };
     const trace = createTraceContext(traceId);
     const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/tool-result`, {
@@ -165,6 +218,29 @@ async function postToolResult({ config, turnId, event, result, session, fetchImp
         throw await readErrorResponse(response, trace.traceId);
     }
 }
+const turnIdOverrides = new WeakMap();
+function enterServerTurnId(session, serverSessionTurnId) {
+    const active = turnIdOverrides.get(session);
+    if (active) {
+        active.depth += 1;
+        return;
+    }
+    turnIdOverrides.set(session, {
+        previousTurnId: session.turnState.id,
+        depth: 1,
+    });
+    session.turnState.id = serverSessionTurnId;
+}
+function exitServerTurnId(session) {
+    const active = turnIdOverrides.get(session);
+    if (!active)
+        return;
+    active.depth -= 1;
+    if (active.depth === 0) {
+        session.turnState.id = active.previousTurnId;
+        turnIdOverrides.delete(session);
+    }
+}
 async function executeAndPostToolResult({ config, projectIndex, session, event, input, fetchImpl, signal, traceId, }) {
     const turnId = String(event?.turnId ?? '').trim();
     if (!turnId || !event?.call?.id || !event.call.name) {
@@ -173,17 +249,17 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
     if (signal?.aborted) {
         throw new TurnCancelledError();
     }
-    const previousTurnId = session.turnState.id;
     const serverSessionTurnId = String(event.sessionTurnId ?? '').trim();
     if (serverSessionTurnId) {
-        session.turnState.id = serverSessionTurnId;
+        enterServerTurnId(session, serverSessionTurnId);
         if (!session.clientState.safety.checkpoints.some((checkpoint) => checkpoint.turnId === serverSessionTurnId)) {
             createPromptCheckpoint(session.clientState.safety, 'prompt boundary', serverSessionTurnId);
         }
     }
     try {
-        const rawResult = await executeLocalToolCall({ projectIndex }, session, event.call);
-        preserveCancelledTurnToolResult(session, input, event, rawResult);
+        const call = normalizeShellJobToolCall(event.call);
+        const rawResult = await executeLocalToolCall({ projectIndex }, session, call);
+        preserveCancelledTurnToolResult(session, input, { ...event, call }, rawResult);
         if (signal?.aborted) {
             throw new TurnCancelledError();
         }
@@ -198,7 +274,9 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
         });
     }
     finally {
-        session.turnState.id = previousTurnId;
+        if (serverSessionTurnId) {
+            exitServerTurnId(session);
+        }
     }
 }
 async function consumeTurnStream({ response, config, projectIndex, session, input, fetchImpl, signal, traceId, }) {
@@ -211,8 +289,40 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
     const finalResult = {
         current: null,
     };
+    const pendingParallelTools = [];
+    let firstParallelFailure = null;
+    let rejectOnParallelFailure = null;
+    const parallelToolFailure = new Promise((_, reject) => {
+        rejectOnParallelFailure = reject;
+    });
+    parallelToolFailure.catch(() => { });
+    function recordParallelFailure(error) {
+        const failure = error ?? new Error('Local tool execution failed.');
+        if (firstParallelFailure == null) {
+            firstParallelFailure = failure;
+            rejectOnParallelFailure?.(failure);
+        }
+        return failure;
+    }
+    async function drainParallelTools() {
+        if (!pendingParallelTools.length)
+            return;
+        const pending = pendingParallelTools.splice(0);
+        const outcomes = await Promise.all(pending);
+        for (const outcome of outcomes) {
+            if (outcome != null)
+                throw outcome;
+        }
+    }
     async function handleEvent(event) {
         if (event.event === 'status') {
+            const data = event.data;
+            if (data?.phase === 'analyzing_image') {
+                session.onImageAnalysis?.(Math.max(1, Number(data.imageCount ?? 1) || 1));
+            }
+            else if (data?.phase) {
+                session.onImageAnalysis?.(0);
+            }
             const message = publicStatusMessage(event.data);
             if (message)
                 session.onStatus(message);
@@ -222,11 +332,26 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             return;
         }
         if (event.event === 'tool-call') {
+            const data = event.data;
+            if (data?.parallelSafe === true) {
+                pendingParallelTools.push(executeAndPostToolResult({
+                    config,
+                    projectIndex,
+                    session,
+                    event: data,
+                    input,
+                    fetchImpl,
+                    signal,
+                    traceId,
+                }).then(() => null, (error) => recordParallelFailure(error)));
+                return;
+            }
+            await drainParallelTools();
             await executeAndPostToolResult({
                 config,
                 projectIndex,
                 session,
-                event: event.data,
+                event: data,
                 input,
                 fetchImpl,
                 signal,
@@ -242,10 +367,12 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             return;
         }
         if (event.event === 'result') {
+            await drainParallelTools();
             finalResult.current = event.data;
             return;
         }
         if (event.event === 'cancelled' || event.event === 'error') {
+            await drainParallelTools().catch(() => { });
             const message = String(event.data?.message ?? 'Server chat failed.');
             if (event.event === 'cancelled') {
                 throw new TurnCancelledError(message);
@@ -253,24 +380,34 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             throw new ChatTurnFailedError(message, typeof event.data?.category === 'string' ? event.data.category : 'unknown_error', Boolean(event.data?.retryable), typeof event.data?.traceId === 'string' ? event.data.traceId : traceId);
         }
     }
-    while (true) {
-        if (signal?.aborted) {
-            await reader.cancel().catch(() => { });
-            throw new TurnCancelledError();
-        }
-        const read = await reader.read();
-        if (read.done)
-            break;
-        buffer += decoder.decode(read.value, { stream: true });
-        let separatorIndex = buffer.indexOf('\n\n');
-        while (separatorIndex !== -1) {
-            const block = buffer.slice(0, separatorIndex);
-            buffer = buffer.slice(separatorIndex + 2);
-            const event = parseSseBlock(block);
-            if (event)
-                await handleEvent(event);
-            separatorIndex = buffer.indexOf('\n\n');
+    try {
+        while (true) {
+            if (signal?.aborted) {
+                await reader.cancel().catch(() => { });
+                throw new TurnCancelledError();
+            }
+            const read = await Promise.race([reader.read(), parallelToolFailure]);
+            if (read.done)
+                break;
+            buffer += decoder.decode(read.value, { stream: true });
+            let separatorIndex = buffer.indexOf('\n\n');
+            while (separatorIndex !== -1) {
+                const block = buffer.slice(0, separatorIndex);
+                buffer = buffer.slice(separatorIndex + 2);
+                const event = parseSseBlock(block);
+                if (event)
+                    await handleEvent(event);
+                separatorIndex = buffer.indexOf('\n\n');
+            }
         }
+        await drainParallelTools();
+    }
+    catch (error) {
+        await reader.cancel().catch(() => { });
+        throw error;
+    }
+    finally {
+        await drainParallelTools().catch(() => { });
     }
     buffer += decoder.decode();
     const tail = buffer.trim();
@@ -285,19 +422,32 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
     return finalResult.current;
 }
 export async function sendServerUserMessage({ config, projectIndex, session, input, imageAttachments = [], fetchImpl = globalThis.fetch, signal, }) {
+    const autoAttach = autoAttachImages(input, session.rootDir, imageAttachments);
+    const requestImageAttachments = autoAttach.attachments.length > 0
+        ? [...imageAttachments, ...autoAttach.attachments]
+        : imageAttachments;
+    const requestInputBase = autoAttach.attachments.length > 0 ? autoAttach.sanitizedInput : input;
+    const backgroundJobUpdate = drainBackgroundJobNotifications({
+        sessionId: session.sessionId,
+    });
+    for (const err of autoAttach.errors) {
+        session.onStatus(`Image: ${err}`);
+    }
     const request = {
         modelId: session.modelId,
         session: snapshotForServer(session),
-        input,
+        input: requestInputBase,
+        backgroundJobUpdate: backgroundJobUpdate || undefined,
         clientEnvironment: collectClientEnvironment({ env: session.env }),
-        imageAttachments,
+        projectOrientation: collectProjectOrientation(session.rootDir) ?? undefined,
+        imageAttachments: imageAttachmentsForServer(requestImageAttachments),
         maxToolSteps: session.maxToolSteps,
         autoYes: session.autoYes,
         agentMode: session.agentMode,
     };
     const trace = createTraceContext();
     const preTurnHistoryLength = session.history.length;
-    const preserveOnAbort = () => preserveCancelledTurnInput(session, input);
+    const preserveOnAbort = () => preserveCancelledTurnInput(session, requestInputBase);
     if (signal?.aborted) {
         preserveOnAbort();
     }
@@ -324,7 +474,7 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
             config,
             projectIndex,
             session,
-            input,
+            input: requestInputBase,
             fetchImpl,
             signal,
             traceId: trace.traceId,
@@ -339,16 +489,13 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
     }
     catch (error) {
         if (isTurnCancelledError(error)) {
-            preserveCancelledTurnInput(session, input);
+            preserveCancelledTurnInput(session, requestInputBase);
             throw error instanceof TurnCancelledError
                 ? error
                 : new TurnCancelledError();
         }
-        // Non-cancel failures (e.g. upstream connection errors) must not leave
-        // speculative cancelled-turn entries in history — otherwise the next
-        // request replays a malformed transcript to the server.
         session.history.length = preTurnHistoryLength;
-        preserveFailedTurnInput(session, input, error instanceof ChatTurnFailedError ? error.category : 'unknown_error');
+        preserveFailedTurnInput(session, requestInputBase, error instanceof ChatTurnFailedError ? error.category : 'unknown_error');
         throw error;
     }
     finally {

package/dist/src/api/http.js

@@ -6,11 +6,13 @@ export const CLIENT_PLATFORM_HEADER = 'x-thegitai-client-platform';
 export class ServerApiError extends Error {
     status;
     traceId;
-    constructor(message, status, traceId) {
+    code;
+    constructor(message, status, traceId, code = '') {
         super(traceId ? `${message}\nTrace ID: ${traceId}` : message);
         this.name = 'ServerApiError';
         this.status = status;
         this.traceId = traceId;
+        this.code = code;
     }
 }
 export function createTraceId() {
@@ -26,6 +28,53 @@ export function createTraceContext(traceId = createTraceId()) {
         },
     };
 }
+export const REQUEST_TIMEOUT_MS = 8000;
+const TRANSIENT_NETWORK_CODES = new Set([
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ETIMEDOUT',
+    'EAI_AGAIN',
+    'ENOTFOUND',
+    'ENETUNREACH',
+    'EHOSTUNREACH',
+    'EPIPE',
+    'UND_ERR_CONNECT_TIMEOUT',
+    'UND_ERR_SOCKET',
+    'UND_ERR_HEADERS_TIMEOUT',
+    'UND_ERR_BODY_TIMEOUT',
+]);
+export function isTransientNetworkError(error) {
+    if (error instanceof ServerApiError)
+        return false;
+    if (!error || typeof error !== 'object')
+        return false;
+    const err = error;
+    if (err.name === 'AbortError' || err.name === 'TimeoutError')
+        return true;
+    const code = err.code ?? err.cause?.code;
+    if (code) {
+        return TRANSIENT_NETWORK_CODES.has(code);
+    }
+    if (error instanceof TypeError && /fetch failed/i.test(err.message ?? '')) {
+        return true;
+    }
+    return false;
+}
+export async function retryTransient(run, { retries = 2, baseDelayMs = 400 } = {}) {
+    let attempt = 0;
+    for (;;) {
+        try {
+            return await run();
+        }
+        catch (error) {
+            if (attempt >= retries || !isTransientNetworkError(error))
+                throw error;
+            const delayMs = baseDelayMs * 2 ** attempt;
+            attempt += 1;
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+    }
+}
 export function normalizeServerUrl(serverUrl) {
     const normalized = String(serverUrl || DEFAULT_SERVER_URL)
         .trim()
@@ -49,11 +98,22 @@ export async function readJsonResponse(response) {
 export function failureMessage(data, status) {
     return String(data?.error?.message ?? data?.message ?? `Request failed with ${status}`);
 }
+export function failureCode(data) {
+    return typeof data?.error?.code === 'string' ? data.error.code : '';
+}
+export function isAuthenticationError(error) {
+    return error instanceof ServerApiError && error.status === 401;
+}
+export function authenticationErrorMessage(error) {
+    return error.code === 'AUTH_TOKEN_EXPIRED'
+        ? 'Your login expired after 24 hours of inactivity. Run `ai login` and resume this saved session.'
+        : 'Your login is no longer valid. Run `ai login` and resume this saved session.';
+}
 export async function readErrorResponse(response, traceId = response.headers.get(TRACE_ID_HEADER) ?? '') {
     const data = await readJsonResponse(response);
-    return new ServerApiError(failureMessage(data, response.status), response.status, traceId);
+    return new ServerApiError(failureMessage(data, response.status), response.status, traceId, failureCode(data));
 }
-export async function authorizedJson({ config, path, method = 'GET', body = null, headers = {}, fetchImpl = globalThis.fetch, }) {
+export async function authorizedJson({ config, path, method = 'GET', body = null, headers = {}, fetchImpl = globalThis.fetch, timeoutMs = REQUEST_TIMEOUT_MS, }) {
     const trace = createTraceContext();
     const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}${path}`, {
         method,
@@ -64,10 +124,11 @@ export async function authorizedJson({ config, path, method = 'GET', body = null
             ...(body === null ? {} : { 'content-type': 'application/json' }),
         },
         body: body === null ? undefined : JSON.stringify(body),
+        signal: AbortSignal.timeout(timeoutMs),
     });
     const data = await readJsonResponse(response);
     if (!response.ok) {
-        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
+        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId, failureCode(data));
     }
     return data;
 }

package/dist/src/api/models.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { getClientStateDir } from '../client-state.js';
-import { ServerApiError, createTraceContext, failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
+import { REQUEST_TIMEOUT_MS, ServerApiError, createTraceContext, failureCode, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } from './http.js';
 function sanitizeModelInfo(raw) {
     if (!raw || typeof raw !== 'object') {
         return null;
@@ -9,10 +9,15 @@ function sanitizeModelInfo(raw) {
     const value = raw;
     const id = Number(value.id);
     const label = String(value.label ?? '').trim();
-    if (!Number.isInteger(id) || id <= 0 || !label) {
+    const costRating = Number(value.costRating);
+    const description = String(value.description ?? '').trim();
+    if (!Number.isInteger(id) || id <= 0 || !label || !isCostRating(costRating)) {
         return null;
     }
-    return { id, label };
+    return { id, label, costRating, description };
+}
+function isCostRating(value) {
+    return Number.isInteger(value) && value >= 1 && value <= 3;
 }
 export function getModelsCachePath(env = process.env) {
     return path.join(getClientStateDir(env), 'models.json');
@@ -45,6 +50,11 @@ export function readCachedServerModels(env = process.env) {
         return null;
     }
 }
+export function selectCacheForServer(cached, serverUrl) {
+    if (!cached)
+        return null;
+    return cached.serverUrl === normalizeServerUrl(serverUrl) ? cached : null;
+}
 export function writeCachedServerModels(cache, env = process.env) {
     const filePath = getModelsCachePath(env);
     mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
@@ -54,26 +64,27 @@ export function writeCachedServerModels(cache, env = process.env) {
     });
 }
 export async function fetchServerModels({ config, fetchImpl = globalThis.fetch, }) {
-    const trace = createTraceContext();
-    const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/models`, {
-        headers: {
-            authorization: `Bearer ${config.token}`,
-            ...trace.headers,
-        },
+    return retryTransient(async () => {
+        const trace = createTraceContext();
+        const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/models`, {
+            headers: {
+                authorization: `Bearer ${config.token}`,
+                ...trace.headers,
+            },
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        const data = (await readJsonResponse(response));
+        if (!response.ok) {
+            throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId, failureCode(data));
+        }
+        const models = Array.isArray(data?.models)
+            ? data.models.map(sanitizeModelInfo).filter(Boolean)
+            : [];
+        if (models.length === 0) {
+            throw new Error('Server returned an invalid model list.');
+        }
+        return { models };
     });
-    const data = (await readJsonResponse(response));
-    if (!response.ok) {
-        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
-    }
-    const models = Array.isArray(data?.models)
-        ? data.models.map(sanitizeModelInfo).filter(Boolean)
-        : [];
-    if (models.length === 0) {
-        throw new Error('Server returned an invalid model list.');
-    }
-    return {
-        models,
-    };
 }
 export function selectServerModel({ requestedModelId, cached, serverModels, }) {
     const supportedIds = new Set(serverModels.models.map((model) => model.id));

package/dist/src/artifact-policy.js

@@ -154,6 +154,8 @@ const SENSITIVE_BASENAME_PATTERNS = [
     /^\.?pypirc$/i,
     /^credentials(?:\..*)?$/i,
     /^secrets?(?:\..*)?$/i,
+    /^service[-_]?account(?:\..*)?\.json$/i,
+    /^.*credentials.*\.json$/i,
 ];
 const SENSITIVE_PATH_PATTERNS = [
     /(^|[/\\])\.aws[/\\]credentials$/i,
@@ -161,6 +163,7 @@ const SENSITIVE_PATH_PATTERNS = [
     /(^|[/\\])credentials?([._-]|$)/i,
     /(^|[/\\])secrets?([._-]|$)/i,
     /(^|[/\\])private[-_]?key([._-]|$)/i,
+    /(^|[/\\])service[-_]?account/i,
     /\.(?:pem|key|p12|pfx)$/i,
 ];
 export function normalizeArtifactPath(relPath) {