@thegitai/cli 1.0.0-preview.4 → 1.0.0-preview.41

package/dist/src/api/http.js

@@ -1,16 +1,18 @@
 import { randomUUID } from 'node:crypto';
-const DEFAULT_SERVER_URL = 'https://thegit.ai';
+import { DEFAULT_THEGITAI_HOST } from './default-host.js';
 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) {
+    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() {
@@ -27,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',
@@ -58,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 {
@@ -68,13 +80,15 @@ 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));
         }
     }
 }
 export function normalizeServerUrl(serverUrl) {
-    const normalized = String(serverUrl || DEFAULT_SERVER_URL)
+    const normalized = String(serverUrl || DEFAULT_THEGITAI_HOST)
         .trim()
         .replace(/\/+$/, '');
     if (!/^https?:\/\//i.test(normalized)) {
@@ -82,6 +96,99 @@ export function normalizeServerUrl(serverUrl) {
     }
     return normalized;
 }
+const MAX_NON_JSON_BODY_CHARS = 200;
+const GATEWAY_STATUS_MESSAGES = {
+    502: 'Could not reach the TheGitAI server (bad gateway).',
+    503: 'The TheGitAI server is temporarily unavailable.',
+    504: 'The TheGitAI server did not respond in time (gateway timeout).',
+    520: 'The connection to the TheGitAI server failed (edge error 520).',
+    521: 'The TheGitAI server is not accepting connections (edge error 521).',
+    522: 'The connection to the TheGitAI server timed out (edge error 522).',
+    523: 'The TheGitAI server is unreachable (edge error 523).',
+    524: 'The TheGitAI server did not respond in time (edge error 524).',
+};
+function truncateByCodePoint(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const points = Array.from(text);
+    if (points.length <= maxChars)
+        return text;
+    return `${points.slice(0, maxChars).join('').trimEnd()}…`;
+}
+export function nonJsonErrorMessage(body, status) {
+    const rayId = /Cloudflare Ray ID:\s*(?:<[^>]*>\s*)*([0-9a-f]{8,})/i.exec(body)?.[1];
+    const gateway = GATEWAY_STATUS_MESSAGES[status];
+    const summary = truncateByCodePoint(body
+        .replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, ' ')
+        .replace(/<[^>]*>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim(), MAX_NON_JSON_BODY_CHARS);
+    const base = gateway ?? (summary || `Request failed with ${status}`);
+    return rayId ? `${base} (Cloudflare Ray ID: ${rayId})` : base;
+}
+const TRANSPORT_CODES = new Set([
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'ECONNABORTED',
+    'EPIPE',
+    'ETIMEDOUT',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+    'EPROTO',
+    'ERR_STREAM_PREMATURE_CLOSE',
+]);
+const TRANSPORT_PHRASES = [
+    [/\bsocket hang up\b/i, 'socket hang up'],
+    [/\bother side closed\b/i, 'other side closed'],
+    [/\bpremature close\b/i, 'premature close'],
+    [/\bterminated\b/i, 'terminated'],
+    [/\bfetch failed\b/i, 'fetch failed'],
+    [/\bnetwork timeout\b/i, 'network timeout'],
+    [/\bnetwork error\b/i, 'network error'],
+    [/\bheaders timeout\b/i, 'headers timeout'],
+    [/\bbody timeout\b/i, 'body timeout'],
+];
+export function transportFailureDetail(error) {
+    if (error instanceof ServerApiError)
+        return null;
+    const parts = [];
+    const seen = new Set();
+    const queue = [error];
+    while (queue.length && seen.size < 24) {
+        const current = queue.shift();
+        if (!current || typeof current !== 'object' || seen.has(current))
+            continue;
+        seen.add(current);
+        const code = String(current.code ?? '');
+        if (TRANSPORT_CODES.has(code) || /^UND_ERR_[A-Z_]+$/.test(code)) {
+            if (!parts.includes(code))
+                parts.push(code);
+        }
+        const message = String(current.message ?? '');
+        for (const [pattern, label] of TRANSPORT_PHRASES) {
+            if (pattern.test(message) && !parts.includes(label))
+                parts.push(label);
+        }
+        if (current.cause)
+            queue.push(current.cause);
+        const nested = current.errors;
+        if (Array.isArray(nested))
+            queue.push(...nested);
+    }
+    return parts.length ? parts.slice(0, 3).join(' <- ') : null;
+}
+function isTransportFailure(error) {
+    return transportFailureDetail(error) !== null;
+}
+export function gatewayFailureCategory(error) {
+    if (isTransportFailure(error))
+        return 'connection_error';
+    if (!(error instanceof ServerApiError))
+        return null;
+    return error.status in GATEWAY_STATUS_MESSAGES ? 'gateway_error' : null;
+}
 export async function readJsonResponse(response) {
     const text = await response.text();
     if (!text.trim())
@@ -90,15 +197,28 @@ export async function readJsonResponse(response) {
         return JSON.parse(text);
     }
     catch {
-        return { error: { message: text } };
+        return {
+            error: { message: nonJsonErrorMessage(text, response.status) },
+        };
     }
 }
 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 48 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, timeoutMs = REQUEST_TIMEOUT_MS, }) {
     const trace = createTraceContext();
@@ -115,7 +235,7 @@ export async function authorizedJson({ config, path, method = 'GET', body = null
     });
     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 { 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, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } 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;
@@ -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,11 +80,11 @@ 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) {
-            throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
+            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)
@@ -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));
@@ -113,6 +122,16 @@ export function validateServerModel(modelId, serverModels) {
     }
     return requested;
 }
+export function resolveResumedSessionModel(storedModelId, serverModels) {
+    if (serverModels.models.some((model) => model.id === storedModelId)) {
+        return { modelId: storedModelId, fellBack: false };
+    }
+    const fallbackId = serverModels.models[0]?.id;
+    return {
+        modelId: fallbackId ?? storedModelId,
+        fellBack: fallbackId != null,
+    };
+}
 export function updateSelectedModelCache({ config, selectedModelId, serverModels, env = process.env, }) {
     writeCachedServerModels({
         serverUrl: normalizeServerUrl(config.serverUrl),

package/dist/src/background-jobs.js

@@ -1,6 +1,6 @@
 import chalk from './colors.js';
 import { spawn } from 'child_process';
-import { buildCommandEnv, commandUsesSudo, sanitizeCommandText, terminateChild, } from './executor.js';
+import { buildCommandEnv, commandUsesSudo, resolveCommandShell, sanitizeCommandText, terminateChild, } from './executor.js';
 import { isTuiMode } from './runtime-mode.js';
 import { redactConnectionStringCredentials } from './secret-preview.js';
 const MAX_RUNNING_JOBS = 8;
@@ -196,7 +196,7 @@ export async function startBackgroundJob(command, cwd, { startupWaitMs, sessionI
     const id = `bg_${++jobCounter}`;
     const child = spawn(command, {
         cwd,
-        shell: true,
+        shell: resolveCommandShell(),
         detached: process.platform !== 'win32',
         stdio: ['pipe', 'pipe', 'pipe'],
         env: buildCommandEnv(cwd),
@@ -265,6 +265,7 @@ export function getJobOutputTail(id, maxLines) {
     if (!record || !belongsToSession(record) || maxLines <= 0)
         return [];
     const lines = sanitizeJobText(record, record.buffer)
+        .replace(/\r\n?/g, '\n')
         .split('\n')
         .filter((line) => line.trim().length > 0);
     return lines.slice(-maxLines);
@@ -277,6 +278,7 @@ export function getJobOutputPreview(id, maxTailLines) {
         ? sanitizeJobText(record, record.firstOutputLine).trim()
         : '';
     return {
+        droppedChars: Math.max(record.totalCaptured - record.buffer.length, 0),
         firstLine,
         tailLines: getJobOutputTail(id, maxTailLines),
     };

package/dist/src/browser/bridge.js

@@ -0,0 +1,232 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { registerNativeHost } from './native-host.js';
+import { BROWSER_PROTOCOL_VERSION, browserRuntimeDir, protocolMismatchMessage, sessionKeyFromRecordFile, sessionRecordPath, sessionSocketPath, socketIsFile, } from './protocol.js';
+const DEFAULT_TIMEOUT_MS = 30000;
+export class BrowserBridgeError extends Error {
+    code;
+    constructor(message, code = 'browser_error') {
+        super(message);
+        this.name = 'BrowserBridgeError';
+        this.code = code;
+    }
+}
+function safeUnlink(target) {
+    try {
+        fs.unlinkSync(target);
+    }
+    catch {
+    }
+}
+export function startBrowserBridge({ sessionKey, label, cwd, env = process.env, }) {
+    const dir = browserRuntimeDir(env);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const socketPath = sessionSocketPath(dir, sessionKey);
+    const recordPath = sessionRecordPath(dir, sessionKey);
+    if (socketIsFile())
+        safeUnlink(socketPath);
+    const browsers = new Map();
+    const listeners = new Set();
+    let selected = null;
+    let closed = false;
+    const registration = registerNativeHost({ env });
+    const server = net.createServer((socket) => {
+        socket.setNoDelay(true);
+        let buffer = '';
+        let key = null;
+        socket.on('data', (chunk) => {
+            buffer += chunk.toString('utf8');
+            let newline = buffer.indexOf('\n');
+            while (newline !== -1) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                newline = buffer.indexOf('\n');
+                if (!line.trim())
+                    continue;
+                let frame;
+                try {
+                    frame = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (frame.t === 'hello') {
+                    if (frame.protocol !== BROWSER_PROTOCOL_VERSION) {
+                        const message = protocolMismatchMessage(frame.protocol);
+                        for (const listener of listeners)
+                            listener('protocol_mismatch', { message });
+                        socket.destroy();
+                        return;
+                    }
+                    const announced = frame.browser?.key ?? crypto.randomUUID();
+                    const existing = key ? browsers.get(key) : null;
+                    if (existing) {
+                        if (announced !== key) {
+                            browsers.delete(key);
+                            browsers.set(announced, existing);
+                            if (selected === key)
+                                selected = announced;
+                        }
+                        existing.identity = frame.browser;
+                        existing.socket = socket;
+                    }
+                    else {
+                        browsers.set(announced, {
+                            identity: frame.browser,
+                            socket,
+                            pending: new Map(),
+                        });
+                        if (!selected)
+                            selected = announced;
+                    }
+                    key = announced;
+                    for (const listener of listeners) {
+                        listener('connected', { browser: frame.browser });
+                    }
+                    continue;
+                }
+                const browser = key ? browsers.get(key) : null;
+                if (!browser)
+                    continue;
+                if (frame.t === 'res') {
+                    const pending = browser.pending.get(frame.id);
+                    if (!pending)
+                        continue;
+                    browser.pending.delete(frame.id);
+                    clearTimeout(pending.timer);
+                    if (frame.ok)
+                        pending.resolve(frame.result);
+                    else
+                        pending.reject(new BrowserBridgeError(frame.error ?? 'Browser operation failed.', frame.code ?? 'browser_error'));
+                    continue;
+                }
+                if (frame.t === 'event') {
+                    for (const listener of listeners)
+                        listener(frame.event, frame.data ?? {});
+                }
+            }
+        });
+        const drop = () => {
+            if (!key)
+                return;
+            const browser = browsers.get(key);
+            browsers.delete(key);
+            if (selected === key)
+                selected = browsers.keys().next().value ?? null;
+            for (const pending of browser?.pending.values() ?? []) {
+                clearTimeout(pending.timer);
+                pending.reject(new BrowserBridgeError(`The browser disconnected while ${pending.op} was in flight, so its outcome is unknown. Check the page before doing anything that could repeat.`, 'disconnected'));
+            }
+            for (const listener of listeners)
+                listener('disconnected', { browser: key });
+        };
+        socket.on('close', drop);
+        socket.on('error', drop);
+    });
+    server.listen(socketPath, () => {
+        try {
+            fs.chmodSync(socketPath, 0o600);
+        }
+        catch {
+        }
+        const announcement = {
+            protocol: BROWSER_PROTOCOL_VERSION,
+            session: sessionKey,
+            pid: process.pid,
+            label,
+            cwd,
+            startedAt: new Date().toISOString(),
+        };
+        try {
+            fs.writeFileSync(recordPath, `${JSON.stringify(announcement)}\n`, { mode: 0o600 });
+        }
+        catch {
+        }
+    });
+    server.on('error', () => {
+    });
+    const close = () => {
+        if (closed)
+            return;
+        closed = true;
+        for (const browser of browsers.values())
+            browser.socket.destroy();
+        browsers.clear();
+        server.close();
+        safeUnlink(socketPath);
+        safeUnlink(recordPath);
+    };
+    process.once('exit', close);
+    return {
+        sessionKey,
+        status() {
+            return {
+                connected: browsers.size > 0,
+                browsers: [...browsers.values()].map((browser) => browser.identity),
+                selected,
+                socketPath,
+                registrationErrors: registration.errors,
+            };
+        },
+        selectBrowser(key) {
+            if (browsers.has(key))
+                selected = key;
+        },
+        onEvent(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        request(op, args = {}, options = {}) {
+            const target = selected ? browsers.get(selected) : null;
+            if (!target) {
+                return Promise.reject(new BrowserBridgeError('No browser is connected to this session.', 'not_connected'));
+            }
+            const id = crypto.randomUUID();
+            const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    target.pending.delete(id);
+                    reject(new BrowserBridgeError(`The browser did not answer ${op} within ${Math.round(timeoutMs / 1000)}s, so its outcome is unknown. Look at the page before repeating anything that changes state.`, 'timeout'));
+                }, timeoutMs);
+                target.pending.set(id, { resolve, reject, timer, op });
+                target.socket.write(`${JSON.stringify({ t: 'req', id, op, args })}\n`, (error) => {
+                    if (!error)
+                        return;
+                    target.pending.delete(id);
+                    clearTimeout(timer);
+                    reject(new BrowserBridgeError(`Could not reach the browser: ${error.message}`, 'write_failed'));
+                });
+            });
+        },
+        close,
+    };
+}
+export function pruneStaleSessions(env = process.env) {
+    const dir = browserRuntimeDir(env);
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const key = sessionKeyFromRecordFile(entry);
+        if (!key)
+            continue;
+        const file = path.join(dir, entry);
+        try {
+            const record = JSON.parse(fs.readFileSync(file, 'utf8'));
+            process.kill(record.pid, 0);
+        }
+        catch (error) {
+            if (error?.code === 'EPERM')
+                continue;
+            safeUnlink(file);
+            if (socketIsFile())
+                safeUnlink(sessionSocketPath(dir, key));
+        }
+    }
+}

package/dist/src/browser/framing.js

@@ -0,0 +1,42 @@
+export const MAX_FRAME_BYTES = 900 * 1024;
+export const FRAGMENT_BYTES = 512 * 1024;
+export function encodeFrame(payload) {
+    const header = Buffer.alloc(4);
+    header.writeUInt32LE(payload.length, 0);
+    return Buffer.concat([header, payload]);
+}
+export function fragmentPayload(payload, id) {
+    const total = Math.ceil(payload.length / FRAGMENT_BYTES);
+    const frames = [];
+    for (let part = 0; part < total; part += 1) {
+        frames.push({
+            t: 'fragment',
+            id,
+            part,
+            total,
+            data: payload.subarray(part * FRAGMENT_BYTES, (part + 1) * FRAGMENT_BYTES).toString('base64'),
+        });
+    }
+    return frames;
+}
+export function decodeFrames(inbound) {
+    const frames = [];
+    let rest = inbound;
+    let unparseable = 0;
+    for (;;) {
+        if (rest.length < 4)
+            break;
+        const length = rest.readUInt32LE(0);
+        if (rest.length < 4 + length)
+            break;
+        const body = rest.subarray(4, 4 + length);
+        rest = rest.subarray(4 + length);
+        try {
+            frames.push(JSON.parse(body.toString('utf8')));
+        }
+        catch {
+            unparseable += 1;
+        }
+    }
+    return { frames, rest, unparseable };
+}