@thegitai/cli 1.0.0-preview.38 → 1.0.0-preview.39

package/dist/src/browser/native-host.js

@@ -0,0 +1,209 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { EXTENSION_IDS, NATIVE_HOST_NAME } from './protocol.js';
+function browserConfigRoots(env, platform) {
+    const home = env.HOME ?? os.homedir();
+    if (platform === 'win32') {
+        const local = env.LOCALAPPDATA ?? path.join(home, 'AppData', 'Local');
+        return [
+            path.join(local, 'Google', 'Chrome', 'User Data'),
+            path.join(local, 'Google', 'Chrome Beta', 'User Data'),
+            path.join(local, 'Chromium', 'User Data'),
+            path.join(local, 'Microsoft', 'Edge', 'User Data'),
+            path.join(local, 'BraveSoftware', 'Brave-Browser', 'User Data'),
+            path.join(local, 'Vivaldi', 'User Data'),
+        ];
+    }
+    if (platform === 'darwin') {
+        const support = path.join(home, 'Library', 'Application Support');
+        return [
+            path.join(support, 'Google', 'Chrome'),
+            path.join(support, 'Google', 'Chrome Beta'),
+            path.join(support, 'Chromium'),
+            path.join(support, 'Microsoft Edge'),
+            path.join(support, 'BraveSoftware', 'Brave-Browser'),
+            path.join(support, 'Vivaldi'),
+            path.join(support, 'Arc', 'User Data'),
+        ];
+    }
+    const configHome = env.XDG_CONFIG_HOME ?? path.join(home, '.config');
+    return [
+        path.join(configHome, 'google-chrome'),
+        path.join(configHome, 'google-chrome-beta'),
+        path.join(configHome, 'chromium'),
+        path.join(configHome, 'microsoft-edge'),
+        path.join(configHome, 'BraveSoftware', 'Brave-Browser'),
+        path.join(configHome, 'vivaldi'),
+    ];
+}
+function thegitaiHome(env, platform = process.platform) {
+    if (platform === 'win32') {
+        const local = env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+        return env.THEGITAI_HOME ?? path.join(local, 'thegitai');
+    }
+    return env.THEGITAI_HOME ?? path.join(env.HOME ?? os.homedir(), '.thegitai');
+}
+function writeLauncher(env, hostScript, platform = process.platform) {
+    const dir = thegitaiHome(env, platform);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    if (platform === 'win32') {
+        const launcherPath = path.join(dir, 'browser-bridge-host.bat');
+        const contents = [
+            '@echo off',
+            `"${process.execPath}" "${hostScript}" %*`,
+            '',
+        ].join('\r\n');
+        const existingBat = fs.existsSync(launcherPath)
+            ? fs.readFileSync(launcherPath, 'utf8')
+            : null;
+        if (existingBat === contents)
+            return { launcherPath, changed: false };
+        fs.writeFileSync(launcherPath, contents);
+        return { launcherPath, changed: true };
+    }
+    const launcherPath = path.join(dir, 'browser-bridge-host.sh');
+    const quote = (value) => "'" + value.replaceAll("'", "'\\''") + "'";
+    const contents = `#!/bin/sh\nexec ${quote(process.execPath)} ${quote(hostScript)} "$@"\n`;
+    const existing = fs.existsSync(launcherPath) ? fs.readFileSync(launcherPath, 'utf8') : null;
+    if (existing === contents) {
+        try {
+            fs.chmodSync(launcherPath, 0o700);
+        }
+        catch {
+        }
+        return { launcherPath, changed: false };
+    }
+    fs.writeFileSync(launcherPath, contents, { mode: 0o700 });
+    fs.chmodSync(launcherPath, 0o700);
+    return { launcherPath, changed: true };
+}
+function resolveHostScript() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    return path.resolve(here, '..', '..', 'bin', 'browser-host.js');
+}
+export function registerNativeHost({ env = process.env, platform = process.platform, hostScript = resolveHostScript(), } = {}) {
+    const errors = [];
+    const manifests = [];
+    let changed = false;
+    const { launcherPath, changed: launcherChanged } = writeLauncher(env, hostScript, platform);
+    changed = launcherChanged;
+    const manifest = {
+        name: NATIVE_HOST_NAME,
+        description: 'TheGitAI browser bridge',
+        path: launcherPath,
+        type: 'stdio',
+        allowed_origins: EXTENSION_IDS.map((id) => `chrome-extension://${id}/`),
+    };
+    const serialized = `${JSON.stringify(manifest, null, 2)}\n`;
+    if (platform === 'win32') {
+        return registerWindowsNativeHost({ env, serialized, launcherPath, changed });
+    }
+    for (const root of browserConfigRoots(env, platform)) {
+        if (!fs.existsSync(root))
+            continue;
+        const dir = path.join(root, 'NativeMessagingHosts');
+        const file = path.join(dir, `${NATIVE_HOST_NAME}.json`);
+        try {
+            fs.mkdirSync(dir, { recursive: true });
+            const existing = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : null;
+            if (existing !== serialized) {
+                fs.writeFileSync(file, serialized, { mode: 0o600 });
+                changed = true;
+            }
+            manifests.push(file);
+        }
+        catch (error) {
+            errors.push(`${file}: ${error?.message ?? error}`);
+        }
+    }
+    return { manifests, launcherPath, changed, errors };
+}
+const WINDOWS_REGISTRY_ROOTS = [
+    { userData: 'Google\\Chrome', key: 'Software\\Google\\Chrome' },
+    { userData: 'Google\\Chrome Beta', key: 'Software\\Google\\Chrome Beta' },
+    { userData: 'Chromium', key: 'Software\\Chromium' },
+    { userData: 'Microsoft\\Edge', key: 'Software\\Microsoft\\Edge' },
+    { userData: 'BraveSoftware\\Brave-Browser', key: 'Software\\BraveSoftware\\Brave-Browser' },
+    { userData: 'Vivaldi', key: 'Software\\Vivaldi' },
+];
+function registerWindowsNativeHost({ env, serialized, launcherPath, changed, }) {
+    const errors = [];
+    const manifests = [];
+    let dirty = changed;
+    const manifestPath = path.join(thegitaiHome(env, 'win32'), `${NATIVE_HOST_NAME}.json`);
+    try {
+        fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+        const existing = fs.existsSync(manifestPath)
+            ? fs.readFileSync(manifestPath, 'utf8')
+            : null;
+        if (existing !== serialized) {
+            fs.writeFileSync(manifestPath, serialized);
+            dirty = true;
+        }
+        manifests.push(manifestPath);
+    }
+    catch (error) {
+        errors.push(`${manifestPath}: ${error?.message ?? error}`);
+        return { manifests, launcherPath, changed: dirty, errors };
+    }
+    const local = env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+    for (const browser of WINDOWS_REGISTRY_ROOTS) {
+        if (!fs.existsSync(path.join(local, browser.userData, 'User Data')))
+            continue;
+        const key = `HKCU\\${browser.key}\\NativeMessagingHosts\\${NATIVE_HOST_NAME}`;
+        try {
+            const current = readRegistryDefault(key);
+            if (current === manifestPath)
+                continue;
+            execFileSync('reg.exe', ['add', key, '/ve', '/t', 'REG_SZ', '/d', manifestPath, '/f'], { timeout: 5000, stdio: ['ignore', 'ignore', 'pipe'] });
+            dirty = true;
+        }
+        catch (error) {
+            errors.push(`${key}: ${error?.message ?? error}`);
+        }
+    }
+    return { manifests, launcherPath, changed: dirty, errors };
+}
+function readRegistryDefault(key) {
+    try {
+        const output = execFileSync('reg.exe', ['query', key, '/ve'], {
+            encoding: 'utf8',
+            timeout: 5000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const match = /\(Default\)\s+REG_SZ\s+(.+?)\s*$/m.exec(output);
+        return match ? match[1] : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function chromiumProcessRunning(platform = process.platform) {
+    if (platform === 'win32') {
+        try {
+            const output = execFileSync('tasklist.exe', ['/fo', 'csv', '/nh'], {
+                encoding: 'utf8',
+                timeout: 4000,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            return /"(chrome|chromium|msedge|brave|vivaldi)\.exe"/i.test(output);
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        const output = execFileSync('ps', ['-eo', 'comm='], {
+            encoding: 'utf8',
+            timeout: 2000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return /(google[- ]?chrome|chromium|brave|msedge|microsoft edge|vivaldi)/i.test(output);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/browser/protocol.js

@@ -0,0 +1,46 @@
+import os from 'node:os';
+import path from 'node:path';
+export const BROWSER_PROTOCOL_VERSION = 1;
+export const NATIVE_HOST_NAME = 'ai.thegit.browser_bridge';
+export const EXTENSION_IDS = [
+    'neleeiihdnddldafklledbkembkfagol',
+    'jipbjphlelfilkhdjkfdficafjhgjfmk',
+];
+export function browserRuntimeDir(env = process.env, platform = process.platform) {
+    if (platform === 'win32') {
+        const local = env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+        return path.join(env.THEGITAI_HOME ?? path.join(local, 'thegitai'), 'browser');
+    }
+    const runtime = env.XDG_RUNTIME_DIR;
+    if (runtime && path.isAbsolute(runtime)) {
+        return path.join(runtime, 'thegitai', 'browser');
+    }
+    return path.join(env.THEGITAI_HOME ?? path.join(os.homedir(), '.thegitai'), 'browser');
+}
+const WINDOWS_PIPE_PREFIX = '\\\\.\\pipe\\';
+export function sessionSocketPath(dir, sessionKey, platform = process.platform) {
+    if (platform === 'win32') {
+        return `${WINDOWS_PIPE_PREFIX}thegitai-browser-${sessionKey}`;
+    }
+    return path.join(dir, `s-${sessionKey}.sock`);
+}
+export function socketIsFile(platform = process.platform) {
+    return platform !== 'win32';
+}
+export function sessionKeyFromRecordFile(fileName) {
+    const match = /^s-(.+)\.json$/.exec(fileName);
+    return match ? match[1] : null;
+}
+export function sessionRecordPath(dir, sessionKey) {
+    return path.join(dir, `s-${sessionKey}.json`);
+}
+export function protocolMismatchMessage(theirs) {
+    const version = Number(theirs);
+    if (!Number.isInteger(version)) {
+        return 'The TheGitAI extension did not report a protocol version. Update both TheGitAI and the extension.';
+    }
+    if (version < BROWSER_PROTOCOL_VERSION) {
+        return `The TheGitAI extension speaks browser protocol v${version}; this CLI speaks v${BROWSER_PROTOCOL_VERSION}. Update the extension from the Chrome Web Store.`;
+    }
+    return `The TheGitAI extension speaks browser protocol v${version}; this CLI speaks v${BROWSER_PROTOCOL_VERSION}. Update TheGitAI: npm i -g @thegitai/cli`;
+}

package/dist/src/browser/session-bridge.js

@@ -0,0 +1,104 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getClientStateDir } from '../client-state.js';
+import { pruneStaleSessions, startBrowserBridge, } from './bridge.js';
+import { chromiumProcessRunning } from './native-host.js';
+let bridge = null;
+let recentEvents = [];
+const processKey = `${process.pid.toString(36)}${crypto.randomBytes(3).toString('hex')}`;
+export function ensureBrowserBridge(options) {
+    if (bridge)
+        return bridge;
+    const env = options.env ?? process.env;
+    pruneStaleSessions(env);
+    bridge = startBrowserBridge({
+        sessionKey: processKey,
+        label: path.basename(options.cwd) || 'TheGitAI',
+        cwd: options.cwd,
+        env,
+    });
+    bridge.onEvent((event, data) => {
+        if (event === 'connected')
+            rememberBrowserExtensionSeen(env);
+        recentEvents.push({ event, data, at: Date.now() });
+        if (recentEvents.length > 50)
+            recentEvents.splice(0, recentEvents.length - 50);
+    });
+    return bridge;
+}
+function browserExtensionMarkerPath(env) {
+    return path.join(getClientStateDir(env), 'browser-extension-seen');
+}
+function rememberBrowserExtensionSeen(env) {
+    try {
+        const marker = browserExtensionMarkerPath(env);
+        if (fs.existsSync(marker))
+            return;
+        fs.mkdirSync(path.dirname(marker), { recursive: true });
+        fs.writeFileSync(marker, `${new Date().toISOString()}\n`);
+    }
+    catch {
+    }
+}
+export function browserExtensionSeen(env = process.env) {
+    try {
+        return fs.existsSync(browserExtensionMarkerPath(env));
+    }
+    catch {
+        return true;
+    }
+}
+export function startBrowserDiscoveryInBackground(options) {
+    setImmediate(() => {
+        try {
+            ensureBrowserBridge(options);
+        }
+        catch {
+        }
+    });
+}
+export function currentBrowserBridge() {
+    return bridge;
+}
+export function releaseBrowserAfterTurn() {
+    const active = bridge;
+    if (!active?.status().connected)
+        return;
+    void active
+        .request('release', {}, { timeoutMs: 5000 })
+        .catch(() => {
+    });
+}
+export function closeBrowserBridge() {
+    bridge?.close();
+    bridge = null;
+    recentEvents = [];
+}
+export function drainBrowserEvents() {
+    const events = recentEvents.map(({ event, data }) => ({ event, data }));
+    recentEvents = [];
+    return events;
+}
+export function browserAvailability(options) {
+    const active = ensureBrowserBridge(options);
+    const status = active.status();
+    if (status.connected) {
+        return {
+            connected: true,
+            browsers: status.browsers,
+            selected: status.selected,
+        };
+    }
+    const hint = status.registrationErrors.length
+        ? `TheGitAI could not register its browser bridge with Chrome: ${status.registrationErrors[0]}`
+        : chromiumProcessRunning()
+            ? 'Chrome is running but the TheGitAI extension has not connected. Install or enable the extension, then reload it from chrome://extensions.'
+            : 'Chrome does not appear to be running. Open Chrome with the TheGitAI extension installed.';
+    return {
+        connected: false,
+        browsers: [],
+        selected: null,
+        hint,
+    };
+}

package/dist/src/client-environment.js

@@ -2,6 +2,7 @@ import { accessSync, constants, readFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { ensureSessionScratchDir } from './scratch-dir.js';
+import { browserExtensionSeen } from './browser/session-bridge.js';
 const PACKAGE_MANAGER_CANDIDATES = [
     'apt',
     'apt-get',
@@ -125,5 +126,6 @@ export function collectClientEnvironment(options = {}) {
         ...linuxDistro,
         packageManagers: detectPackageManagers(env, platform, executableExists),
         scratchDir: options.scratchDir ?? ensureSessionScratchDir(),
+        browserExtensionSeen: options.browserExtensionSeen ?? browserExtensionSeen(env),
     };
 }

package/dist/src/permissions.js

@@ -1,7 +1,7 @@
 import { getUnquotedShellText } from './agent-mode.js';
-export const PERMISSION_BUCKETS = ['create', 'edit', 'delete', 'run'];
+export const PERMISSION_BUCKETS = ['create', 'edit', 'delete', 'run', 'browse'];
 export function createSessionGrants() {
-    return { buckets: [], commandPrefixes: [] };
+    return { buckets: [], commandPrefixes: [], origins: [] };
 }
 export function bucketActionLabel(bucket) {
     if (bucket === 'create')
@@ -10,8 +10,37 @@ export function bucketActionLabel(bucket) {
         return 'edit files';
     if (bucket === 'delete')
         return 'delete files';
+    if (bucket === 'browse')
+        return 'act on any website';
     return 'run commands';
 }
+export function originForUrl(url) {
+    const raw = String(url ?? '').trim();
+    if (!raw)
+        return null;
+    try {
+        const parsed = new URL(/^[a-z][a-z0-9+.-]*:/i.test(raw) ? raw : `https://${raw}`);
+        if (parsed.protocol === 'about:' || parsed.protocol === 'chrome:')
+            return null;
+        return parsed.origin;
+    }
+    catch {
+        return null;
+    }
+}
+export function isOriginGranted(grants, origin) {
+    if (!grants || !origin)
+        return false;
+    return grants.origins?.includes(origin) === true;
+}
+export function grantOrigin(grants, origin) {
+    const normalized = String(origin ?? '').trim();
+    if (!normalized)
+        return;
+    const origins = grants.origins ??= [];
+    if (!origins.includes(normalized))
+        origins.push(normalized);
+}
 const NO_PREFIX_GRANT_BINARIES = new Set([
     'rm',
     'rmdir',
@@ -164,7 +193,7 @@ export function grantCommandPrefix(grants, prefix) {
         grants.commandPrefixes.push(normalized);
     }
 }
-export function buildPermissionOptions(bucket, command) {
+export function buildPermissionOptions(bucket, command, origin) {
     const options = [
         { label: 'Approve once', decision: { kind: 'once' } },
     ];
@@ -175,6 +204,12 @@ export function buildPermissionOptions(bucket, command) {
             decision: { kind: 'always-prefix', prefix },
         });
     }
+    if (bucket === 'browse' && origin) {
+        options.push({
+            label: `Allow this site for the session: ${origin}`,
+            decision: { kind: 'always-origin', origin },
+        });
+    }
     options.push({
         label: `Always allow: ${bucketActionLabel(bucket)}`,
         decision: { kind: 'always-bucket' },
@@ -192,6 +227,9 @@ function declinedSubject(bucket) {
     if (bucket === 'delete') {
         return { noun: 'file deletion', effect: 'Nothing was deleted' };
     }
+    if (bucket === 'browse') {
+        return { noun: 'browser action', effect: 'The page was not touched' };
+    }
     return { noun: 'edit', effect: 'Nothing was changed' };
 }
 function declinedResponse(bucket, toolName, extra) {
@@ -219,6 +257,10 @@ export async function ensurePermission(context, request, toolName, extra = {}) {
         isCommandGranted(context.grants, request.command)) {
         return null;
     }
+    if (request.bucket === 'browse' &&
+        isOriginGranted(context.grants, request.origin ?? null)) {
+        return null;
+    }
     if (!context.requestPermission) {
         return {
             ok: false,
@@ -226,7 +268,7 @@ export async function ensurePermission(context, request, toolName, extra = {}) {
             error: `requestPermission is required when autoYes is false (${toolName})`,
         };
     }
-    const options = buildPermissionOptions(request.bucket, request.command);
+    const options = buildPermissionOptions(request.bucket, request.command, request.origin);
     const decision = await context.requestPermission({ ...request, options });
     if (decision.kind === 'deny') {
         return declinedResponse(request.bucket, toolName, extra);
@@ -238,6 +280,9 @@ export async function ensurePermission(context, request, toolName, extra = {}) {
         else if (decision.kind === 'always-prefix') {
             grantCommandPrefix(context.grants, decision.prefix);
         }
+        else if (decision.kind === 'always-origin') {
+            grantOrigin(context.grants, decision.origin);
+        }
     }
     return null;
 }

package/dist/src/session.js

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { normalizeAgentMode, } from './agent-mode.js';
 import { createSessionGrants, } from './permissions.js';
 import { createSessionSafetyState, } from './session-safety.js';
+import { closeBrowserBridge } from './browser/session-bridge.js';
 import { clampInteger } from './utils.js';
 const DEFAULT_MAX_TOOL_STEPS = 32;
 function defaultStatus(message) {
@@ -32,7 +33,7 @@ function preserveProviderSelection(serverState) {
         : null;
     return providerSelection ? { providerSelection } : {};
 }
-export function createSession({ rootDir, autoYes = false, agentMode, modelId, maxToolSteps = DEFAULT_MAX_TOOL_STEPS, requestPermission = null, requestSudoPassword = null, requestUserInput = null, onStatus = null, onContextLog = null, onToolEvent = null, env = process.env, sessionId = createSessionId(), sessionName = null, history = [], serverState = null, editJournal = [], stickyFilePaths = [], editCounter = 0, safety = createSessionSafetyState(), }) {
+export function createSession({ rootDir, autoYes = false, agentMode, modelId, maxToolSteps = DEFAULT_MAX_TOOL_STEPS, maxToolStepsWasExplicit = false, requestPermission = null, requestSudoPassword = null, requestUserInput = null, onStatus = null, onContextLog = null, onToolEvent = null, env = process.env, sessionId = createSessionId(), sessionName = null, history = [], serverState = null, editJournal = [], stickyFilePaths = [], editCounter = 0, safety = createSessionSafetyState(), }) {
     const createdAt = new Date().toISOString();
     const initialAgentMode = normalizeAgentMode(agentMode ?? (autoYes ? 'auto-accept' : 'default'));
     return {
@@ -41,6 +42,7 @@ export function createSession({ rootDir, autoYes = false, agentMode, modelId, ma
         autoYes: initialAgentMode === 'auto-accept',
         agentMode: initialAgentMode,
         maxToolSteps: clampInteger(maxToolSteps, DEFAULT_MAX_TOOL_STEPS, 128),
+        maxToolStepsWasExplicit: maxToolStepsWasExplicit === true,
         onStatus: onStatus ?? defaultStatus,
         onContextLog: onContextLog ?? defaultContextLog,
         onToolEvent,
@@ -97,7 +99,9 @@ export function clearConversation(session) {
         safety: createSessionSafetyState(),
     };
 }
-export async function disposeSession(_session) { }
+export async function disposeSession(_session) {
+    closeBrowserBridge();
+}
 export function switchModel(session, modelId) {
     session.modelId = Number(modelId);
     return { id: session.modelId };

package/dist/src/tool-executor.js

@@ -244,6 +244,7 @@ export async function executeLocalToolCall(session, call) {
             rootDir: session.rootDir,
             sessionId: session.sessionId,
             autoYes: session.autoYes,
+            agentMode: session.agentMode,
             grants: session.grants,
             requestPermission: session.requestPermission,
             requestSudoPassword: session.requestSudoPassword,