@thegitai/cli 1.0.0-beta.2 → 1.0.0-beta.20

package/dist/src/api/chat.js

@@ -1,7 +1,10 @@
+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 { normalizeServerUrl, readErrorResponse, } from './http.js';
+import { createTraceContext, normalizeServerUrl, readErrorResponse, } from './http.js';
+import { collectClientEnvironment } from '../client-environment.js';
+import { autoAttachImages } from '../core/image-path-extractor.js';
 export class TurnCancelledError extends Error {
     name = 'TurnCancelledError';
     constructor(message = 'Turn cancelled.') {
@@ -12,10 +15,12 @@ export class ChatTurnFailedError extends Error {
     name = 'ChatTurnFailedError';
     category;
     retryable;
-    constructor(message, category = 'unknown_error', retryable = false) {
-        super(message);
+    traceId;
+    constructor(message, category = 'unknown_error', retryable = false, traceId = '') {
+        super(traceId ? `${message}\nTrace ID: ${traceId}` : message);
         this.category = category;
         this.retryable = retryable;
+        this.traceId = traceId;
     }
 }
 export function isTurnCancelledError(error) {
@@ -60,6 +65,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 : ''))
@@ -139,17 +149,48 @@ function publicStatusMessage(data) {
         return `Running ${toolName} locally...`;
     return null;
 }
-async function postToolResult({ config, turnId, event, result, session, fetchImpl, }) {
+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),
     };
+    const trace = createTraceContext(traceId);
     const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/chat/turn/${encodeURIComponent(turnId)}/tool-result`, {
         method: 'POST',
         headers: {
             authorization: `Bearer ${config.token}`,
             'content-type': 'application/json',
+            ...trace.headers,
         },
         body: JSON.stringify(payload),
     });
@@ -157,10 +198,10 @@ async function postToolResult({ config, turnId, event, result, session, fetchImp
         return;
     }
     if (!response.ok) {
-        throw await readErrorResponse(response);
+        throw await readErrorResponse(response, trace.traceId);
     }
 }
-async function executeAndPostToolResult({ config, projectIndex, session, event, input, fetchImpl, signal, }) {
+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) {
         throw new Error('Server emitted an invalid tool-call event.');
@@ -177,8 +218,9 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
         }
     }
     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();
         }
@@ -189,13 +231,14 @@ async function executeAndPostToolResult({ config, projectIndex, session, event,
             result: rawResult,
             session,
             fetchImpl,
+            traceId,
         });
     }
     finally {
         session.turnState.id = previousTurnId;
     }
 }
-async function consumeTurnStream({ response, config, projectIndex, session, input, fetchImpl, signal, }) {
+async function consumeTurnStream({ response, config, projectIndex, session, input, fetchImpl, signal, traceId, }) {
     if (!response.body) {
         throw new Error('Server returned an empty chat stream.');
     }
@@ -224,6 +267,7 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
                 input,
                 fetchImpl,
                 signal,
+                traceId,
             });
             return;
         }
@@ -243,7 +287,7 @@ async function consumeTurnStream({ response, config, projectIndex, session, inpu
             if (event.event === 'cancelled') {
                 throw new TurnCancelledError(message);
             }
-            throw new ChatTurnFailedError(message, typeof event.data?.category === 'string' ? event.data.category : 'unknown_error', Boolean(event.data?.retryable));
+            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) {
@@ -278,17 +322,31 @@ 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,
-        imageAttachments,
+        input: requestInputBase,
+        backgroundJobUpdate: backgroundJobUpdate || undefined,
+        clientEnvironment: collectClientEnvironment({ env: session.env }),
+        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();
     }
@@ -302,21 +360,23 @@ export async function sendServerUserMessage({ config, projectIndex, session, inp
                 accept: 'text/event-stream',
                 authorization: `Bearer ${config.token}`,
                 'content-type': 'application/json',
+                ...trace.headers,
             },
             body: JSON.stringify(request),
             signal,
         });
         if (!response.ok) {
-            throw await readErrorResponse(response);
+            throw await readErrorResponse(response, trace.traceId);
         }
         const result = await consumeTurnStream({
             response,
             config,
             projectIndex,
             session,
-            input,
+            input: requestInputBase,
             fetchImpl,
             signal,
+            traceId: trace.traceId,
         });
         applySessionSnapshot(session, result.snapshot, { preserveAgentMode: true });
         return {
@@ -328,16 +388,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

@@ -1,4 +1,78 @@
+import { randomUUID } from 'node:crypto';
 const DEFAULT_SERVER_URL = 'https://thegit.ai';
+export const TRACE_ID_HEADER = 'x-thegitai-trace-id';
+export const CLIENT_HEADER = 'x-thegitai-client';
+export const CLIENT_PLATFORM_HEADER = 'x-thegitai-client-platform';
+export class ServerApiError extends Error {
+    status;
+    traceId;
+    constructor(message, status, traceId) {
+        super(traceId ? `${message}\nTrace ID: ${traceId}` : message);
+        this.name = 'ServerApiError';
+        this.status = status;
+        this.traceId = traceId;
+    }
+}
+export function createTraceId() {
+    return `tr_${randomUUID().replace(/-/g, '')}`;
+}
+export function createTraceContext(traceId = createTraceId()) {
+    return {
+        traceId,
+        headers: {
+            [TRACE_ID_HEADER]: traceId,
+            [CLIENT_HEADER]: 'cli',
+            [CLIENT_PLATFORM_HEADER]: `${process.platform}/${process.arch}`,
+        },
+    };
+}
+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()
@@ -22,23 +96,26 @@ export async function readJsonResponse(response) {
 export function failureMessage(data, status) {
     return String(data?.error?.message ?? data?.message ?? `Request failed with ${status}`);
 }
-export async function readErrorResponse(response) {
+export async function readErrorResponse(response, traceId = response.headers.get(TRACE_ID_HEADER) ?? '') {
     const data = await readJsonResponse(response);
-    return new Error(failureMessage(data, response.status));
+    return new ServerApiError(failureMessage(data, response.status), response.status, traceId);
 }
-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,
         headers: {
             authorization: `Bearer ${config.token}`,
+            ...trace.headers,
             ...headers,
             ...(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 Error(failureMessage(data, response.status));
+        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
     }
     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 { failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
+import { REQUEST_TIMEOUT_MS, ServerApiError, createTraceContext, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } from './http.js';
 function sanitizeModelInfo(raw) {
     if (!raw || typeof raw !== 'object') {
         return null;
@@ -45,6 +45,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,24 +59,27 @@ export function writeCachedServerModels(cache, env = process.env) {
     });
 }
 export async function fetchServerModels({ config, fetchImpl = globalThis.fetch, }) {
-    const response = await fetchImpl(`${normalizeServerUrl(config.serverUrl)}/v1/models`, {
-        headers: {
-            authorization: `Bearer ${config.token}`,
-        },
+    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);
+        }
+        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 Error(failureMessage(data, response.status));
-    }
-    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

@@ -37,6 +37,15 @@ export const BINARY_ARTIFACT_EXTENSIONS = createArtifactNameSet([
     '.bz2',
     '.7z',
     '.pdf',
+    '.doc',
+    '.docx',
+    '.docm',
+    '.dot',
+    '.dotx',
+    '.dotm',
+    '.xls',
+    '.xlsx',
+    '.xlsm',
     '.exe',
     '.dll',
     '.so',
@@ -145,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,
@@ -152,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) {