@thegitai/cli 1.0.0-preview.5 → 1.0.0-preview.51

package/dist/bin/browser-host.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+import { execFileSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { decodeFrames, encodeFrame, fragmentPayload, MAX_FRAME_BYTES } from '../src/browser/framing.js';
+import { BROWSER_PROTOCOL_VERSION, browserRuntimeDir, sessionKeyFromRecordFile, sessionSocketPath, socketIsFile, } from '../src/browser/protocol.js';
+const SCAN_INTERVAL_MS = 1000;
+const NUL = String.fromCharCode(0);
+const sessions = new Map();
+const runtimeDir = browserRuntimeDir(process.env);
+let extensionVersion = '';
+let extensionProfileId = '';
+let extensionPlatform = '';
+function log(message) {
+    process.stderr.write(`[thegitai-browser-host] ${message}\n`);
+}
+function writeToExtension(frame) {
+    const payload = Buffer.from(JSON.stringify(frame), 'utf8');
+    if (payload.length > MAX_FRAME_BYTES) {
+        for (const fragment of fragmentPayload(payload, crypto.randomUUID())) {
+            writeToExtension(fragment);
+        }
+        return;
+    }
+    process.stdout.write(encodeFrame(payload));
+}
+let inbound = Buffer.alloc(0);
+process.stdin.on('data', (chunk) => {
+    inbound = Buffer.concat([inbound, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, 'utf8')]);
+    const { frames, rest, unparseable } = decodeFrames(inbound);
+    inbound = rest;
+    for (let i = 0; i < unparseable; i += 1) {
+        log('discarded an unparseable frame from the extension');
+    }
+    for (const frame of frames)
+        handleExtensionFrame(frame);
+});
+process.stdin.on('end', () => {
+    for (const link of sessions.values())
+        link.socket.destroy();
+    process.exit(0);
+});
+function describeParentBrowser() {
+    const cmdline = process.platform === 'win32' ? windowsParentCommandLine() : unixParentCommandLine();
+    return describeFromCommandLine(cmdline);
+}
+function windowsParentCommandLine() {
+    const PASS_THROUGH = /^(cmd|conhost|powershell|pwsh|node)\.exe$/i;
+    try {
+        const rows = execFileSync('powershell.exe', [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            'Get-CimInstance Win32_Process | ForEach-Object {' +
+                ' "{0}`t{1}`t{2}`t{3}" -f $_.ProcessId, $_.ParentProcessId, $_.Name, $_.CommandLine }',
+        ], {
+            encoding: 'utf8',
+            timeout: 15000,
+            maxBuffer: 8 * 1024 * 1024,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const byPid = new Map();
+        for (const line of rows.split(/\r?\n/)) {
+            const [pid, parent, name, ...rest] = line.split('\t');
+            const id = Number(pid);
+            if (!Number.isInteger(id))
+                continue;
+            byPid.set(id, {
+                parent: Number(parent),
+                name: String(name ?? ''),
+                command: rest.join('\t'),
+            });
+        }
+        let current = byPid.get(process.ppid);
+        for (let hop = 0; hop < 4 && current && PASS_THROUGH.test(current.name); hop += 1) {
+            current = byPid.get(current.parent);
+        }
+        if (!current?.command)
+            return [];
+        return (current.command.match(/"[^"]*"|\S+/g) ?? []).map((token) => token.startsWith('"') && token.endsWith('"') ? token.slice(1, -1) : token);
+    }
+    catch {
+        return [];
+    }
+}
+function unixParentCommandLine() {
+    try {
+        return fs.readFileSync(`/proc/${process.ppid}/cmdline`, 'utf8').split(NUL);
+    }
+    catch {
+        return [];
+    }
+}
+function describeFromCommandLine(cmdline) {
+    try {
+        if (cmdline.length === 0)
+            throw new Error('no command line');
+        const brand = path
+            .basename(cmdline[0] ?? '')
+            .replace(/\.exe$/i, '')
+            .replace(/[-_](browser|stable|beta|dev|unstable|bin)$/i, '')
+            .replace(/[-_]+/g, ' ')
+            .replace(/\b[a-z]/g, (letter) => letter.toUpperCase())
+            .trim() || 'Chrome';
+        const profileArg = cmdline.find((part) => part.startsWith('--profile-directory='));
+        const userDataArg = cmdline.find((part) => part.startsWith('--user-data-dir='));
+        const profile = profileArg ? profileArg.slice('--profile-directory='.length) : 'Default';
+        const suffix = userDataArg
+            ? ` (${path.basename(userDataArg.slice('--user-data-dir='.length))})`
+            : '';
+        return { browser: brand, profile: `${profile}${suffix}` };
+    }
+    catch {
+        return { browser: 'Chrome', profile: 'Default' };
+    }
+}
+const parent = describeParentBrowser();
+function browserKey() {
+    const seed = extensionProfileId || `${parent.browser} ${parent.profile}`;
+    return crypto.createHash('sha256').update(seed).digest('hex').slice(0, 12);
+}
+function identity() {
+    return {
+        key: browserKey(),
+        browser: parent.browser,
+        profile: parent.profile !== 'Default' || !extensionProfileId
+            ? parent.profile
+            : `profile ${extensionProfileId.slice(0, 6)}`,
+        platform: extensionPlatform || process.platform,
+        extensionVersion,
+    };
+}
+function handleExtensionFrame(frame) {
+    if (frame?.t === 'hello') {
+        extensionVersion = String(frame.extensionVersion ?? '');
+        extensionProfileId = String(frame.profileId ?? '');
+        extensionPlatform = String(frame.platform ?? '');
+        writeToExtension({ t: 'hello', protocol: BROWSER_PROTOCOL_VERSION });
+        publishSessions();
+        for (const link of sessions.values())
+            sendHello(link);
+        return;
+    }
+    if (frame?.t === 'res' || frame?.t === 'event') {
+        const target = frame.session ? sessions.get(frame.session) : null;
+        const { session: _routed, ...rest } = frame;
+        if (target) {
+            writeToSession(target, rest);
+            return;
+        }
+        if (frame.t === 'event') {
+            for (const link of sessions.values())
+                writeToSession(link, rest);
+        }
+    }
+}
+function writeToSession(link, frame) {
+    try {
+        link.socket.write(`${JSON.stringify(frame)}\n`);
+    }
+    catch {
+    }
+}
+function sendHello(link) {
+    writeToSession(link, { t: 'hello', protocol: BROWSER_PROTOCOL_VERSION, browser: identity() });
+}
+function publishSessions() {
+    writeToExtension({
+        t: 'sessions',
+        sessions: [...sessions.values()].map((link) => ({
+            session: link.key,
+            label: link.record.label,
+            cwd: link.record.cwd,
+        })),
+    });
+}
+function connectToSession(record, socketPath) {
+    if (sessions.has(record.session))
+        return;
+    const socket = net.createConnection(socketPath);
+    socket.setNoDelay(true);
+    const link = { key: record.session, socket, record };
+    socket.on('connect', () => {
+        sessions.set(record.session, link);
+        sendHello(link);
+        publishSessions();
+        log(`attached to session ${record.session} (${record.cwd})`);
+    });
+    let buffer = '';
+    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;
+            }
+            writeToExtension({ ...frame, session: record.session });
+        }
+    });
+    const drop = () => {
+        if (sessions.get(record.session) === link) {
+            sessions.delete(record.session);
+            publishSessions();
+        }
+        socket.destroy();
+    };
+    socket.on('close', drop);
+    socket.on('error', () => {
+        drop();
+    });
+}
+function scanForSessions() {
+    let entries;
+    try {
+        entries = fs.readdirSync(runtimeDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const sessionKey = sessionKeyFromRecordFile(entry);
+        if (!sessionKey)
+            continue;
+        const recordPath = path.join(runtimeDir, entry);
+        let record;
+        try {
+            record = JSON.parse(fs.readFileSync(recordPath, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        if (record.protocol !== BROWSER_PROTOCOL_VERSION)
+            continue;
+        try {
+            process.kill(record.pid, 0);
+        }
+        catch (error) {
+            if (error?.code !== 'EPERM') {
+                try {
+                    fs.unlinkSync(recordPath);
+                    if (socketIsFile())
+                        fs.unlinkSync(sessionSocketPath(runtimeDir, sessionKey));
+                }
+                catch {
+                }
+                continue;
+            }
+        }
+        connectToSession(record, sessionSocketPath(runtimeDir, sessionKey));
+    }
+}
+setInterval(scanForSessions, SCAN_INTERVAL_MS);
+scanForSessions();
+log(`started for ${parent.browser} / ${parent.profile}`);

package/dist/src/agent-mode.js

@@ -1,19 +1,24 @@
 export const AGENT_MODES = ['default', 'auto-accept', 'plan'];
 const PLAN_MODE_TOOL_NAMES = new Set([
-    'search_code',
     'list_files',
     'list_directories',
     'read_file',
     'grep_code',
-    'find_symbol',
-    'list_symbols',
-    'hover_symbol',
-    'signature_help',
     'read_document',
     'analyze_image',
     'run_command',
     'shell_job_output',
     'update_todos',
+    'browser',
+    'browser_tabs',
+    'browser_read_page',
+    'browser_get_page_text',
+    'browser_find',
+    'browser_console',
+    'browser_downloads',
+    'browser_network',
+    'browser_screenshot',
+    'browser_batch',
 ]);
 const PLAN_MODE_RUN_COMMAND_NAMES = new Set([
     'pwd',
@@ -46,7 +51,7 @@ export function nextAgentMode(mode) {
 export function agentModeAllowsTool(mode, toolName) {
     return mode !== 'plan' || PLAN_MODE_TOOL_NAMES.has(toolName);
 }
-function getUnquotedShellText(command) {
+export function getUnquotedShellText(command) {
     let quote = null;
     let escaped = false;
     let text = '';
@@ -140,8 +145,28 @@ export function buildPlanModeToolBlockedResult(toolName, action = 'Plan mode is
 }
 export function agentModeLabel(mode) {
     if (mode === 'auto-accept')
-        return 'Auto-Accept';
+        return 'Bypass all permissions';
     if (mode === 'plan')
         return 'Plan · read-only';
+    return 'Default · Ask for Approval';
+}
+export function agentModeLabelTiers(mode) {
+    return [agentModeLabel(mode)];
+}
+export function agentModeShortLabel(mode) {
+    if (mode === 'auto-accept')
+        return 'Bypass';
+    if (mode === 'plan')
+        return 'Plan';
     return 'Default';
 }
+export function agentModeColor(mode) {
+    if (mode === 'auto-accept')
+        return 'red';
+    if (mode === 'plan')
+        return 'yellow';
+    return 'cyan';
+}
+export function agentModeCycleSequence() {
+    return AGENT_MODES.map(agentModeShortLabel).join(' → ');
+}

package/dist/src/api/auth.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
 import { getClientStateDir } from '../client-state.js';
-import { ServerApiError, authorizedJson, createTraceContext, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } from './http.js';
+import { ServerApiError, authorizedJson, createTraceContext, failureCode, failureMessage, normalizeServerUrl, readJsonResponse, retryTransient, } from './http.js';
 export function getAuthConfigPath(env = process.env) {
     const configured = String(env.THEGITAI_AUTH_CONFIG ?? '').trim();
     if (configured) {
@@ -50,20 +50,26 @@ 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.');
     }
+    const latestVersion = data.release?.latestVersion;
     return {
         customer: data.customer,
         debugUi: {
             showSessionId: data.debugUi?.showSessionId === true,
         },
+        ...(typeof latestVersion === 'string' && latestVersion
+            ? { release: { latestVersion } }
+            : {}),
         ...(data.usage ? { usage: data.usage } : {}),
     };
 }
@@ -78,6 +84,6 @@ export async function logoutFromServer({ config, fetchImpl = globalThis.fetch, }
     });
     if (!response.ok && response.status !== 401) {
         const data = (await readJsonResponse(response));
-        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId);
+        throw new ServerApiError(failureMessage(data, response.status), response.status, trace.traceId, failureCode(data));
     }
 }

package/dist/src/api/browser-login.js

@@ -1,17 +1,28 @@
+import { execSync } from 'node:child_process';
 import crypto from 'node:crypto';
+import { readFileSync } from 'node:fs';
 import http from 'node:http';
 import os from 'node:os';
 import { openUrl } from '../core/open-url.js';
-import { ServerApiError, createTraceContext, failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
-const DEFAULT_WEBSITE_URL = 'https://thegit.ai';
-const DEFAULT_SERVER_URL = 'https://thegit.ai';
-const DEFAULT_TIMEOUT_MS = 5 * 60 * 1000;
+import { ServerApiError, createTraceContext, failureCode, failureMessage, normalizeServerUrl, readJsonResponse, } from './http.js';
+import { DEFAULT_THEGITAI_HOST } from './default-host.js';
+import { isAbortError } from '../utils.js';
+const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
 function shutDownServer(server) {
     server.closeAllConnections?.();
     server.close();
 }
+export class SignInCancelledError extends Error {
+    constructor() {
+        super('Sign-in cancelled.');
+        this.name = 'SignInCancelledError';
+    }
+}
+export function isSignInCancelled(error) {
+    return error instanceof SignInCancelledError;
+}
 export function resolveWebsiteUrl() {
-    return DEFAULT_WEBSITE_URL.replace(/\/+$/, '');
+    return DEFAULT_THEGITAI_HOST.replace(/\/+$/, '');
 }
 function defaultDeviceName() {
     try {
@@ -21,6 +32,73 @@ function defaultDeviceName() {
         return os.hostname();
     }
 }
+function readLinuxOsPrettyName() {
+    try {
+        const content = readFileSync('/etc/os-release', 'utf8');
+        return content.match(/^PRETTY_NAME="?([^"\n]*)"?$/m)?.[1]?.trim() ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+function macArchLabel() {
+    try {
+        if (process.arch === 'arm64')
+            return 'Apple Silicon';
+        if (os.cpus().some((cpu) => cpu.model.includes('Apple'))) {
+            return 'Apple Silicon';
+        }
+    }
+    catch {
+    }
+    return 'Intel';
+}
+export function describeOperatingSystem() {
+    try {
+        if (process.platform === 'linux') {
+            const base = readLinuxOsPrettyName() || `Linux ${os.release()}`;
+            return process.arch === 'arm64' ? `${base}, ARM64` : base;
+        }
+        if (process.platform === 'darwin') {
+            let version = '';
+            try {
+                version = execSync('sw_vers -productVersion', {
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                })
+                    .toString()
+                    .trim();
+            }
+            catch {
+            }
+            return `${version ? `macOS ${version}` : 'macOS'}, ${macArchLabel()}`;
+        }
+        if (process.platform === 'win32') {
+            let label = '';
+            try {
+                label = os.version();
+            }
+            catch {
+            }
+            const build = Number(os.release().split('.')[2] ?? '0');
+            if (build >= 22000)
+                label = label.replace(/Windows 10/i, 'Windows 11');
+            const base = label || `Windows ${os.release()}`;
+            return process.arch === 'arm64' ? `${base}, ARM64` : base;
+        }
+        return `${process.platform} ${os.release()}`;
+    }
+    catch {
+        return process.platform;
+    }
+}
+export function withOperatingSystemInfo(name) {
+    const trimmed = name.trim();
+    const osLabel = describeOperatingSystem();
+    const combined = osLabel && !trimmed.includes(osLabel)
+        ? `${trimmed} (${osLabel})`
+        : trimmed;
+    return combined.slice(0, 180);
+}
 export function generatePkce() {
     const verifier = crypto.randomBytes(32).toString('base64url');
     const challenge = crypto
@@ -33,12 +111,8 @@ function buildAuthUrl(websiteUrl, params) {
     const url = new URL(`${websiteUrl}/cli-auth`);
     url.searchParams.set('code_challenge', params.codeChallenge);
     url.searchParams.set('device_name', params.deviceName);
-    if (params.redirectUri)
-        url.searchParams.set('redirect_uri', params.redirectUri);
-    if (params.state)
-        url.searchParams.set('state', params.state);
-    if (params.paste)
-        url.searchParams.set('mode', 'paste');
+    url.searchParams.set('redirect_uri', params.redirectUri);
+    url.searchParams.set('state', params.state);
     return url.toString();
 }
 const RESULT_PAGE = (heading, detail) => `<!doctype html><html><head><meta charset="utf-8"><title>TheGitAI CLI</title>` +
@@ -56,7 +130,7 @@ async function exchangeCodeForToken({ serverUrl, code, codeVerifier, fetchImpl,
     });
     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 token = String(data?.token ?? '').trim();
     const customer = data?.customer;
@@ -71,36 +145,38 @@ async function exchangeCodeForToken({ serverUrl, code, codeVerifier, fetchImpl,
         customer,
     };
 }
+async function readPastedResult({ promptCode, signal, serverUrl, codeVerifier, fetchImpl, onPasteRejected, }) {
+    while (!signal.aborted) {
+        const code = (await promptCode(signal)).trim();
+        if (code) {
+            try {
+                return await exchangeCodeForToken({ serverUrl, code, codeVerifier, fetchImpl });
+            }
+            catch (error) {
+                if (signal.aborted)
+                    break;
+                onPasteRejected?.(error.message);
+            }
+        }
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    return await new Promise(() => { });
+}
 export async function loginViaBrowser(options) {
-    const serverUrl = normalizeServerUrl(options.serverUrl ?? DEFAULT_SERVER_URL);
+    const serverUrl = normalizeServerUrl(options.serverUrl ?? DEFAULT_THEGITAI_HOST);
     const websiteUrl = resolveWebsiteUrl();
     const fetchImpl = options.fetchImpl ?? globalThis.fetch;
     const openBrowser = options.openBrowser ?? openUrl;
     const onUrl = options.onUrl ?? (() => { });
-    const deviceName = options.deviceName ?? defaultDeviceName();
+    const deviceName = withOperatingSystemInfo(options.deviceName ?? defaultDeviceName());
     const { verifier, challenge } = generatePkce();
-    if (options.noBrowser) {
-        const authUrl = buildAuthUrl(websiteUrl, {
-            codeChallenge: challenge,
-            deviceName,
-            paste: true,
-        });
-        onUrl(authUrl);
-        if (!options.promptCode) {
-            throw new Error('No way to read the authorization code in this context.');
-        }
-        const code = (await options.promptCode()).trim();
-        if (!code) {
-            throw new Error('No authorization code was entered.');
-        }
-        return exchangeCodeForToken({ serverUrl, code, codeVerifier: verifier, fetchImpl });
-    }
     const state = crypto.randomBytes(16).toString('base64url');
     const server = http.createServer();
+    let timer;
     const codePromise = new Promise((resolve, reject) => {
-        const timer = setTimeout(() => {
+        timer = setTimeout(() => {
             shutDownServer(server);
-            reject(new Error('Timed out waiting for the browser login to complete.'));
+            reject(new Error('Sign-in timed out. Authorization codes last 10 minutes — run `ai` again to start over.'));
         }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
         server.on('request', (req, res) => {
             const requestUrl = new URL(req.url ?? '/', 'http://127.0.0.1');
@@ -113,7 +189,7 @@ export async function loginViaBrowser(options) {
             const returnedState = requestUrl.searchParams.get('state') ?? '';
             if (!code || returnedState !== state) {
                 res.writeHead(400, { 'content-type': 'text/html', connection: 'close' });
-                res.end(RESULT_PAGE('Login failed', 'The request could not be verified. Please run ai login again.'));
+                res.end(RESULT_PAGE('Login failed', 'The request could not be verified. Please run `ai` again.'));
                 clearTimeout(timer);
                 shutDownServer(server);
                 reject(new Error('The login callback could not be verified.'));
@@ -143,8 +219,44 @@ export async function loginViaBrowser(options) {
         state,
     });
     onUrl(authUrl);
-    await openBrowser(authUrl).catch(() => false);
-    options.onWaiting?.();
-    const code = await codePromise;
-    return exchangeCodeForToken({ serverUrl, code, codeVerifier: verifier, fetchImpl });
+    const opened = await openBrowser(authUrl).catch(() => false);
+    options.onBrowserOpen?.(opened);
+    let raceSettled = false;
+    const untilSettled = (promise) => promise.catch((error) => {
+        if (raceSettled)
+            return new Promise(() => { });
+        throw error;
+    });
+    const pasteAbort = new AbortController();
+    const routes = [
+        untilSettled(codePromise.then((code) => exchangeCodeForToken({ serverUrl, code, codeVerifier: verifier, fetchImpl }))),
+    ];
+    if (options.promptCode) {
+        const pasted = readPastedResult({
+            promptCode: options.promptCode,
+            signal: pasteAbort.signal,
+            serverUrl,
+            codeVerifier: verifier,
+            fetchImpl,
+            onPasteRejected: options.onPasteRejected,
+        }).catch((error) => {
+            if (!raceSettled && isAbortError(error))
+                throw new SignInCancelledError();
+            if (!raceSettled) {
+                return new Promise(() => { });
+            }
+            throw error;
+        });
+        routes.push(untilSettled(pasted));
+    }
+    try {
+        return await Promise.race(routes);
+    }
+    finally {
+        raceSettled = true;
+        pasteAbort.abort();
+        if (timer)
+            clearTimeout(timer);
+        shutDownServer(server);
+    }
 }