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

package/dist/src/browser/bridge.js

@@ -0,0 +1,262 @@
+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 rejectDisconnectedRequests(browser) {
+    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'));
+    }
+    browser.pending.clear();
+}
+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 sockets = new Set();
+    const listeners = new Set();
+    let selected = null;
+    let everConnected = false;
+    let closed = false;
+    const registration = registerNativeHost({ env });
+    const server = net.createServer((socket) => {
+        socket.setNoDelay(true);
+        sockets.add(socket);
+        let buffer = '';
+        let key = null;
+        socket.on('data', (chunk) => {
+            if (socket.destroyed)
+                return;
+            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;
+                    const displaced = browsers.get(announced);
+                    if (displaced && displaced.socket !== socket) {
+                        displaced.socket.destroy();
+                        rejectDisconnectedRequests(displaced);
+                    }
+                    if (existing?.socket === socket) {
+                        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;
+                    everConnected = true;
+                    for (const listener of listeners) {
+                        listener('connected', { browser: frame.browser });
+                    }
+                    continue;
+                }
+                const browser = key ? browsers.get(key) : null;
+                if (!browser || browser.socket !== socket)
+                    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 = () => {
+            sockets.delete(socket);
+            if (!key)
+                return;
+            const browser = browsers.get(key);
+            if (!browser || browser.socket !== socket)
+                return;
+            browsers.delete(key);
+            if (selected === key)
+                selected = browsers.keys().next().value ?? null;
+            rejectDisconnectedRequests(browser);
+            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())
+            rejectDisconnectedRequests(browser);
+        for (const socket of sockets)
+            socket.destroy();
+        sockets.clear();
+        browsers.clear();
+        server.close();
+        safeUnlink(socketPath);
+        safeUnlink(recordPath);
+    };
+    process.once('exit', close);
+    return {
+        sessionKey,
+        status() {
+            return {
+                connected: browsers.size > 0,
+                everConnected,
+                browsers: [...browsers.values()].map((browser) => browser.identity),
+                selected,
+                socketPath,
+                registrationErrors: registration.errors,
+            };
+        },
+        resync() {
+            if (closed || browsers.size > 0 || sockets.size === 0)
+                return false;
+            for (const socket of sockets)
+                socket.destroy();
+            sockets.clear();
+            return true;
+        },
+        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 };
+}

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

@@ -0,0 +1,219 @@
+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 output.split('\n').some((line) => isBrowserProcessName(line));
+    }
+    catch {
+        return false;
+    }
+}
+const BROWSER_PROCESS_NAME = /^(google[ -]?chrome|chrome|chromium|brave|msedge|microsoft[ -]?edge|vivaldi)/i;
+const NOT_A_BROWSER_PROCESS = /crashpad|crashhandler|native|sandbox|driver|updater?\b/i;
+export function isBrowserProcessName(psLine) {
+    const name = psLine.trim().split('/').pop()?.trim() ?? '';
+    if (!name)
+        return false;
+    if (NOT_A_BROWSER_PROCESS.test(name))
+        return false;
+    return BROWSER_PROCESS_NAME.test(name);
+}

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`;
+}