chrome-ai-bridge 1.0.0

package/build/src/cli.js

@@ -0,0 +1,120 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+export const cliOptions = {
+    browserUrl: {
+        type: 'string',
+        description: 'Connect to a running Chrome instance using port forwarding. For more details see: https://developer.chrome.com/docs/devtools/remote-debugging/local-server.',
+        alias: 'u',
+        coerce: (url) => {
+            new URL(url);
+            return url;
+        },
+    },
+    headless: {
+        type: 'boolean',
+        description: 'Whether to run in headless (no UI) mode.',
+        default: false,
+    },
+    executablePath: {
+        type: 'string',
+        description: 'Path to custom Chrome executable.',
+        conflicts: 'browserUrl',
+        alias: 'e',
+    },
+    isolated: {
+        type: 'boolean',
+        description: 'If specified, creates a temporary user-data-dir that is automatically cleaned up after the browser is closed.',
+        default: false,
+    },
+    customDevtools: {
+        type: 'string',
+        description: 'Path to custom DevTools.',
+        hidden: true,
+        conflicts: 'browserUrl',
+        alias: 'd',
+    },
+    channel: {
+        type: 'string',
+        description: 'Specify a different Chrome channel that should be used. The default is the stable channel version.',
+        choices: ['stable', 'canary', 'beta', 'dev'],
+        conflicts: ['browserUrl', 'executablePath'],
+    },
+    loadExtension: {
+        type: 'string',
+        description: 'Load an unpacked Chrome extension from the specified directory path.',
+        conflicts: 'browserUrl',
+    },
+    loadExtensionsDir: {
+        type: 'string',
+        description: 'Load all unpacked Chrome extensions from the specified directory. Each subdirectory with manifest.json will be loaded as an extension.',
+        conflicts: 'browserUrl',
+    },
+    loadSystemExtensions: {
+        type: 'boolean',
+        description: 'Automatically discover and load extensions installed in the system Chrome profile. This includes extensions from Chrome Web Store and sideloaded extensions.',
+        default: false,
+        conflicts: 'browserUrl',
+    },
+    chromeProfile: {
+        type: 'string',
+        description: 'Specify Chrome profile name (e.g., "Default", "Profile 1", "Profile 2"). If not specified, uses last_used from Local State. Only effective when --loadSystemExtensions is true.',
+        conflicts: 'browserUrl',
+    },
+    userDataDir: {
+        type: 'string',
+        description: 'Specify a custom user data directory for Chrome to use instead of the default. Auto-detected if not specified.',
+        conflicts: 'browserUrl',
+    },
+    logFile: {
+        type: 'string',
+        describe: 'Path to a file to write debug logs to. Set the env variable `DEBUG` to `*` to enable verbose logs. Useful for submitting bug reports.',
+    },
+    projectRoot: {
+        type: 'string',
+        description: 'Explicitly specify the project root directory for profile isolation. Overrides MCP roots/list. Useful when roots/list is not available.',
+        conflicts: 'browserUrl',
+    },
+};
+export function parseArguments(version, argv = process.argv) {
+    const yargsInstance = yargs(hideBin(argv))
+        .scriptName('npx chrome-ai-bridge@latest')
+        .options(cliOptions)
+        .check(args => {
+        // Auto-configuration for zero-config setup
+        if (!args.channel && !args.browserUrl && !args.executablePath) {
+            args.channel = 'stable';
+        }
+        return true;
+    })
+        .example([
+        ['$0', 'Zero-config startup: auto-detects profile and bookmarks'],
+        [
+            '$0 --browserUrl http://127.0.0.1:9222',
+            'Connect to an existing browser instance',
+        ],
+        ['$0 --channel beta', 'Use Chrome Beta installed on this system'],
+        ['$0 --channel canary', 'Use Chrome Canary installed on this system'],
+        ['$0 --channel dev', 'Use Chrome Dev installed on this system'],
+        ['$0 --channel stable', 'Use stable Chrome installed on this system'],
+        [
+            '$0 --loadSystemExtensions',
+            'Auto-discover and load system Chrome extensions',
+        ],
+        [
+            '$0 --loadExtensionsDir ./extensions --loadSystemExtensions',
+            'Load both development and system extensions',
+        ],
+        ['$0 --logFile /tmp/log.txt', 'Save logs to a file'],
+        ['$0 --help', 'Print CLI options'],
+    ]);
+    return yargsInstance
+        .wrap(Math.min(120, yargsInstance.terminalWidth()))
+        .help()
+        .version(version)
+        .parseSync();
+}

package/build/src/client-detector.js

@@ -0,0 +1,93 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { spawnSync } from 'node:child_process';
+import os from 'node:os';
+/**
+ * Detect MCP client type from parent process
+ * Returns client ID like "claude-code", "codex", "cursor", or "default"
+ */
+export function detectClientType() {
+    const ppid = process.ppid;
+    if (!ppid) {
+        return 'default';
+    }
+    try {
+        const platform = os.platform();
+        if (platform === 'darwin' || platform === 'linux') {
+            // macOS and Linux: use ps command
+            const result = spawnSync('ps', ['-p', String(ppid), '-o', 'comm='], {
+                encoding: 'utf8',
+                timeout: 500,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            if (result.status === 0 && result.stdout) {
+                const processName = result.stdout.trim().toLowerCase();
+                return mapProcessNameToClient(processName);
+            }
+        }
+        else if (platform === 'win32') {
+            // Windows: use wmic command
+            const result = spawnSync('wmic', ['process', 'where', `ProcessId=${ppid}`, 'get', 'Name', '/value'], {
+                encoding: 'utf8',
+                timeout: 500,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            if (result.status === 0 && result.stdout) {
+                const match = result.stdout.match(/Name=(.+)/i);
+                if (match) {
+                    const processName = match[1].trim().toLowerCase();
+                    return mapProcessNameToClient(processName);
+                }
+            }
+        }
+    }
+    catch (error) {
+        console.error(`[client-detector] Failed to detect client: ${error}`);
+    }
+    return 'default';
+}
+/**
+ * Map process name to MCP client ID
+ */
+function mapProcessNameToClient(processName) {
+    // Remove .exe extension (Windows)
+    const name = processName.replace(/\.exe$/i, '');
+    // Known MCP clients
+    if (name.includes('claude')) {
+        return 'claude-code';
+    }
+    if (name.includes('codex')) {
+        return 'codex';
+    }
+    if (name.includes('cursor')) {
+        return 'cursor';
+    }
+    if (name.includes('copilot')) {
+        return 'copilot';
+    }
+    if (name.includes('cline')) {
+        return 'cline';
+    }
+    if (name.includes('continue')) {
+        return 'continue';
+    }
+    if (name.includes('aider')) {
+        return 'aider';
+    }
+    if (name.includes('windsurf')) {
+        return 'windsurf';
+    }
+    // VSCode (could be any MCP client extension)
+    if (name.includes('code') || name.includes('vscode')) {
+        return 'vscode';
+    }
+    // Generic node process (fallback to default)
+    if (name.includes('node')) {
+        return 'default';
+    }
+    // Unknown process - use sanitized process name
+    return name.slice(0, 20); // Max 20 chars
+}

package/build/src/config.js

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Global configuration for chrome-ai-bridge
+ */
+/**
+ * ChatGPT configuration
+ */
+export const CHATGPT_CONFIG = {
+    /**
+     * Default ChatGPT URL with gpt-5-thinking model
+     */
+    DEFAULT_URL: 'https://chatgpt.com/?model=gpt-5-thinking',
+    /**
+     * Base URL for ChatGPT (without query params)
+     */
+    BASE_URL: 'https://chatgpt.com/',
+    /**
+     * Default model parameter
+     */
+    DEFAULT_MODEL: 'gpt-5-thinking',
+};
+/**
+ * Gemini configuration
+ */
+export const GEMINI_CONFIG = {
+    /**
+     * Default Gemini URL
+     */
+    DEFAULT_URL: 'https://gemini.google.com/',
+    /**
+     * Base URL for Gemini
+     */
+    BASE_URL: 'https://gemini.google.com/',
+};

package/build/src/formatters/consoleFormatter.js

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logLevels = {
+    log: 'Log',
+    info: 'Info',
+    warning: 'Warning',
+    error: 'Error',
+    exception: 'Exception',
+    assert: 'Assert',
+};
+export async function formatConsoleEvent(event) {
+    // Check if the event object has the .type() method, which is unique to ConsoleMessage
+    if ('type' in event) {
+        return await formatConsoleMessage(event);
+    }
+    return `Error: ${event.message}`;
+}
+async function formatConsoleMessage(msg) {
+    const logLevel = logLevels[msg.type()];
+    const args = msg.args();
+    if (logLevel === 'Error') {
+        let message = `${logLevel}> `;
+        if (msg.text() === 'JSHandle@error') {
+            const errorHandle = args[0];
+            message += await errorHandle
+                .evaluate(error => {
+                return error.toString();
+            })
+                .catch(() => {
+                return 'Error occured';
+            });
+            void errorHandle.dispose().catch();
+            const formattedArgs = await formatArgs(args.slice(1));
+            if (formattedArgs) {
+                message += ` ${formattedArgs}`;
+            }
+        }
+        else {
+            message += msg.text();
+            const formattedArgs = await formatArgs(args);
+            if (formattedArgs) {
+                message += ` ${formattedArgs}`;
+            }
+            for (const frame of msg.stackTrace()) {
+                message += '\n' + formatStackFrame(frame);
+            }
+        }
+        return message;
+    }
+    const formattedArgs = await formatArgs(args);
+    const text = msg.text();
+    return `${logLevel}> ${formatStackFrame(msg.location())}: ${text} ${formattedArgs}`.trim();
+}
+async function formatArgs(args) {
+    const argValues = await Promise.all(args.map(arg => arg.jsonValue().catch(() => {
+        // Ignore errors
+    })));
+    return argValues
+        .map(value => {
+        return typeof value === 'object' ? JSON.stringify(value) : String(value);
+    })
+        .join(' ');
+}
+function formatStackFrame(stackFrame) {
+    if (!stackFrame?.url) {
+        return '<unknown>';
+    }
+    const filename = stackFrame.url.replace(/^.*\//, '');
+    return `${filename}:${stackFrame.lineNumber}:${stackFrame.columnNumber}`;
+}

package/build/src/formatters/extensionsPageFormatter.js

@@ -0,0 +1,184 @@
+/**
+ * Format chrome://extensions page with structured output
+ */
+export function formatExtensionsPage(root, developmentExtensionPaths) {
+    const groups = groupExtensions(root, developmentExtensionPaths);
+    let result = '# Chrome Extensions Page\n\n';
+    // Developer mode section
+    const devModeSwitch = findDeveloperModeSwitch(root);
+    if (devModeSwitch) {
+        const isChecked = devModeSwitch.checked === true;
+        result += `## Developer Mode: ${isChecked ? 'ON ✓' : 'OFF ✗'}\n`;
+        result += `  uid=${devModeSwitch.id} switch "${devModeSwitch.name || devModeSwitch.description || 'Developer mode'}" ${isChecked ? '[checked]' : '[unchecked]'}\n\n`;
+    }
+    // Development extensions first
+    const devGroups = groups.filter(g => g.isDevelopment);
+    const systemGroups = groups.filter(g => !g.isDevelopment);
+    if (devGroups.length > 0) {
+        result += `## 🔧 Development Extensions (Your Project)\n\n`;
+        for (const group of devGroups) {
+            result += formatExtensionGroup(group);
+        }
+    }
+    if (systemGroups.length > 0) {
+        result += `## 📦 System Extensions\n\n`;
+        for (const group of systemGroups) {
+            result += formatExtensionGroup(group);
+        }
+    }
+    return result;
+}
+function formatExtensionGroup(group) {
+    let result = '';
+    // Header with status indicators
+    const statusIcon = group.enabled ? '✓' : '✗';
+    const errorIcon = group.errors.length > 0 ? ' ⚠️ HAS ERRORS' : '';
+    const devIcon = group.isDevelopment ? ' ⭐' : '';
+    result += `### Extension: "${group.name}" v${group.version} [${group.enabled ? 'ENABLED' : 'DISABLED'}]${statusIcon}${devIcon}${errorIcon}\n`;
+    if (group.location) {
+        result += `  Location: ${group.location}\n`;
+    }
+    // Find and label key buttons
+    const buttons = {
+        details: findButton(group.nodes, ['Details', 'View', 'Show details']),
+        remove: findButton(group.nodes, ['Remove', 'Delete', 'Uninstall']),
+        reload: findButton(group.nodes, ['Reload', 'Refresh']),
+        errors: findButton(group.nodes, ['Errors', 'Error', 'View errors']),
+        enabled: findSwitch(group.nodes, ['Enabled', 'Enable']),
+    };
+    // Display buttons with clear labels
+    if (buttons.details) {
+        result += `  uid=${buttons.details.id} button "Details"\n`;
+    }
+    if (buttons.remove) {
+        result += `  uid=${buttons.remove.id} button "Remove"\n`;
+    }
+    if (buttons.reload) {
+        result += `  uid=${buttons.reload.id} button "Reload" ${group.isDevelopment ? '← USE THIS TO RELOAD YOUR EXTENSION' : ''}\n`;
+    }
+    if (buttons.errors) {
+        result += `  uid=${buttons.errors.id} button "Errors" [clickable]\n`;
+    }
+    if (buttons.enabled) {
+        const isChecked = buttons.enabled.checked === true;
+        result += `  uid=${buttons.enabled.id} switch "Enabled" ${isChecked ? '[checked]' : '[unchecked]'}\n`;
+    }
+    // Display errors if any
+    if (group.errors.length > 0) {
+        result += `\n  ⚠️ Errors:\n`;
+        for (const error of group.errors) {
+            result += `    - ${error}\n`;
+        }
+    }
+    result += '\n';
+    return result;
+}
+function groupExtensions(root, developmentPaths) {
+    const groups = [];
+    // Find extension cards (typically have role="article" or contain extension name as heading)
+    const findExtensionCards = (node) => {
+        // Look for extension name patterns
+        if (node.role === 'heading' &&
+            node.level === 3 &&
+            node.name &&
+            !node.name.includes('Chrome Web Store')) {
+            // This is likely an extension name
+            const extensionName = node.name;
+            // Find sibling nodes that belong to this extension
+            const siblings = [];
+            let version = '';
+            const enabled = true;
+            let location = '';
+            const errors = [];
+            // Collect related nodes (buttons, switches, text)
+            const collectNodes = (n, depth = 0) => {
+                if (depth > 5)
+                    return; // Limit depth
+                siblings.push(n);
+                // Extract version
+                if (n.role === 'text' && n.name && /^v?\d+\.\d+/.test(n.name)) {
+                    version = n.name;
+                }
+                // Extract location for development extensions
+                if (n.role === 'text' &&
+                    n.name &&
+                    (n.name.includes('/') || n.name.includes('\\'))) {
+                    location = n.name;
+                }
+                // Extract errors
+                if ((n.role === 'text' || n.role === 'paragraph') &&
+                    n.name &&
+                    (n.name.toLowerCase().includes('error') ||
+                        n.name.toLowerCase().includes('failed') ||
+                        n.name.toLowerCase().includes('warning'))) {
+                    errors.push(n.name);
+                }
+                for (const child of n.children) {
+                    collectNodes(child, depth + 1);
+                }
+            };
+            // Collect from parent's children
+            collectNodes(node);
+            // Determine if it's a development extension
+            const isDevelopment = developmentPaths.some(path => location.includes(path) ||
+                extensionName.toLowerCase().includes('development'));
+            groups.push({
+                name: extensionName,
+                version: version || '0.0.0',
+                enabled,
+                isDevelopment,
+                location: location || undefined,
+                nodes: siblings,
+                errors,
+            });
+        }
+        for (const child of node.children) {
+            findExtensionCards(child);
+        }
+    };
+    findExtensionCards(root);
+    return groups;
+}
+function findButton(nodes, keywords) {
+    for (const node of nodes) {
+        if (node.role === 'button') {
+            const text = node.name || node.description || node.roledescription || '';
+            for (const keyword of keywords) {
+                if (text.toLowerCase().includes(keyword.toLowerCase())) {
+                    return node;
+                }
+            }
+        }
+    }
+    return null;
+}
+function findSwitch(nodes, keywords) {
+    for (const node of nodes) {
+        if (node.role === 'switch') {
+            const text = node.name || node.description || node.roledescription || '';
+            for (const keyword of keywords) {
+                if (text.toLowerCase().includes(keyword.toLowerCase())) {
+                    return node;
+                }
+            }
+        }
+    }
+    return null;
+}
+function findDeveloperModeSwitch(root) {
+    const search = (node) => {
+        if (node.role === 'switch') {
+            const text = node.name || node.description || node.roledescription || '';
+            if (text.toLowerCase().includes('developer')) {
+                return node;
+            }
+        }
+        for (const child of node.children) {
+            const found = search(child);
+            if (found)
+                return found;
+        }
+        return null;
+    };
+    return search(root);
+}

package/build/src/formatters/networkFormatter.js

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export function getShortDescriptionForRequest(request) {
+    return `${request.url()} ${request.method()} ${getStatusFromRequest(request)}`;
+}
+export function getStatusFromRequest(request) {
+    const httpResponse = request.response();
+    const failure = request.failure();
+    let status;
+    if (httpResponse) {
+        const responseStatus = httpResponse.status();
+        status =
+            responseStatus >= 200 && responseStatus <= 299
+                ? `[success - ${responseStatus}]`
+                : `[failed - ${responseStatus}]`;
+    }
+    else if (failure) {
+        status = `[failed - ${failure.errorText}]`;
+    }
+    else {
+        status = '[pending]';
+    }
+    return status;
+}
+export function getFormattedHeaderValue(headers) {
+    const response = [];
+    for (const [name, value] of Object.entries(headers)) {
+        response.push(`- ${name}:${value}`);
+    }
+    return response;
+}

package/build/src/formatters/snapshotFormatter.js

@@ -0,0 +1,80 @@
+export function formatA11ySnapshot(serializedAXNodeRoot, depth = 0) {
+    let result = '';
+    const attributes = getAttributes(serializedAXNodeRoot);
+    const line = ' '.repeat(depth * 2) + attributes.join(' ') + '\n';
+    result += line;
+    for (const child of serializedAXNodeRoot.children) {
+        result += formatA11ySnapshot(child, depth + 1);
+    }
+    return result;
+}
+function getAttributes(serializedAXNodeRoot) {
+    // Prefer description for buttons/switches with empty names
+    const displayLabel = serializedAXNodeRoot.name ||
+        serializedAXNodeRoot.description ||
+        serializedAXNodeRoot.roledescription ||
+        '';
+    const attributes = [
+        `uid=${serializedAXNodeRoot.id}`,
+        serializedAXNodeRoot.role,
+        `"${displayLabel}"`,
+    ];
+    // Value properties
+    const valueProperties = [
+        'value',
+        'valuetext',
+        'valuemin',
+        'valuemax',
+        'level',
+        'autocomplete',
+        'haspopup',
+        'invalid',
+        'orientation',
+        'description',
+        'keyshortcuts',
+        'roledescription',
+    ];
+    for (const property of valueProperties) {
+        if (property in serializedAXNodeRoot &&
+            serializedAXNodeRoot[property] !== undefined) {
+            attributes.push(`${property}="${serializedAXNodeRoot[property]}"`);
+        }
+    }
+    // Boolean properties that also have an 'able' attribute
+    const booleanPropertyMap = {
+        disabled: 'disableable',
+        expanded: 'expandable',
+        focused: 'focusable',
+        selected: 'selectable',
+    };
+    for (const [property, ableAttribute] of Object.entries(booleanPropertyMap)) {
+        if (property in serializedAXNodeRoot) {
+            attributes.push(ableAttribute);
+            if (serializedAXNodeRoot[property]) {
+                attributes.push(property);
+            }
+        }
+    }
+    const booleanProperties = [
+        'modal',
+        'multiline',
+        'readonly',
+        'required',
+        'multiselectable',
+    ];
+    for (const property of booleanProperties) {
+        if (property in serializedAXNodeRoot && serializedAXNodeRoot[property]) {
+            attributes.push(property);
+        }
+    }
+    // Mixed boolean/string attributes
+    for (const property of ['pressed', 'checked']) {
+        if (property in serializedAXNodeRoot) {
+            attributes.push(property);
+            if (serializedAXNodeRoot[property]) {
+                attributes.push(`${property}="${serializedAXNodeRoot[property]}"`);
+            }
+        }
+    }
+    return attributes;
+}