chrome-ai-bridge 1.0.0

package/build/src/startup-check.js

@@ -0,0 +1,147 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CHATGPT_CONFIG } from './config.js';
+import { isLoginRequired } from './login-helper.js';
+/**
+ * UI elements to check during health verification
+ */
+const UI_ELEMENTS = [
+    {
+        name: 'Deep Research Toggle',
+        selector: '[role="menuitemradio"]', // Deep Research menu item
+    },
+    {
+        name: 'Composer Textarea',
+        selector: 'textarea, .ProseMirror[contenteditable="true"]', // ChatGPT input area
+    },
+    {
+        name: 'Send Button',
+        selector: 'button[data-testid="send-button"]', // Send message button
+    },
+];
+/**
+ * Check if UI element exists using accessibility tree
+ */
+async function checkElementExists(page, element) {
+    try {
+        // First try direct DOM query
+        const domCheck = await page.evaluate(selector => {
+            return document.querySelector(selector) !== null;
+        }, element.selector);
+        if (domCheck) {
+            return true;
+        }
+        // Fallback: Check accessibility tree
+        const axTree = await page.accessibility.snapshot();
+        if (!axTree) {
+            return false;
+        }
+        // Search for element by name in AX tree
+        function searchAxTree(node) {
+            if (node.name?.includes(element.name)) {
+                return true;
+            }
+            if (node.children) {
+                for (const child of node.children) {
+                    if (searchAxTree(child)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        return searchAxTree(axTree);
+    }
+    catch (error) {
+        console.error(`Error checking ${element.name}:`, error);
+        return false;
+    }
+}
+/**
+ * Verify ChatGPT UI health on startup
+ */
+export async function verifyUIHealth(browser) {
+    console.error('\n🔍 UI Health Check: Starting...');
+    let page;
+    try {
+        // Get or create a page
+        const pages = await browser.pages();
+        page = pages[0] || (await browser.newPage());
+        // Navigate to ChatGPT with short timeout
+        console.error('   Navigating to ChatGPT...');
+        await page.goto(CHATGPT_CONFIG.DEFAULT_URL, {
+            waitUntil: 'networkidle2',
+            timeout: 30000,
+        });
+        // Wait for page to be ready
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        // Check login status (but don't wait for login to avoid timeout)
+        console.error('   Checking login status...');
+        const needsLogin = await isLoginRequired(page);
+        if (needsLogin) {
+            console.error('⚠️  ChatGPT login required');
+            console.error('   💡 Login will be prompted when you use ChatGPT tools');
+            console.error('   Skipping UI verification - will verify after login');
+            return;
+        }
+        console.error('✅ Already logged in');
+        // Check each UI element
+        const results = [];
+        for (const element of UI_ELEMENTS) {
+            const found = await checkElementExists(page, element);
+            results.push({ element, found });
+            if (found) {
+                console.error(`✅ ${element.name}: Found`);
+            }
+            else {
+                const status = element.optional ? '⚠️' : '❌';
+                console.error(`${status} ${element.name}: NOT FOUND`);
+            }
+        }
+        // Summary
+        const missingElements = results.filter(r => !r.found && !r.element.optional);
+        if (missingElements.length > 0) {
+            console.error('\n⚠️  UI Health Check Warning:');
+            console.error('   Some UI elements were not found. ChatGPT UI may have changed.');
+            console.error('   Missing elements:');
+            missingElements.forEach(r => {
+                console.error(`     - ${r.element.name}`);
+            });
+            console.error('\n💡 Suggestion: Run diagnostics to investigate:');
+            console.error('   npm run diagnose:ui');
+        }
+        else {
+            console.error('\n✅ UI Health Check: All elements found');
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`\n❌ UI Health Check Failed: ${errorMessage}`);
+        console.error('   This is a warning only - MCP server will continue to start');
+        console.error('   ChatGPT functionality may be limited');
+    }
+    finally {
+        // Don't close the page - let the server reuse it
+        console.error('');
+    }
+}
+/**
+ * Run UI health check with timeout protection
+ */
+export async function runStartupCheck(browser) {
+    const timeoutMs = 35000; // 35 seconds total timeout
+    try {
+        await Promise.race([
+            verifyUIHealth(browser),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('UI health check timeout')), timeoutMs)),
+        ]);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`⚠️  Startup check timeout or error: ${errorMessage}`);
+        console.error('   Continuing with server startup...');
+    }
+}

package/build/src/system-profile.js

@@ -0,0 +1,181 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * Get platform-specific Chrome user data directory paths
+ */
+function getChromeUserDataPaths() {
+    const homeDir = os.homedir();
+    const platform = os.platform();
+    const platformPaths = {
+        darwin: {
+            stable: path.join(homeDir, 'Library', 'Application Support', 'Google', 'Chrome'),
+            canary: path.join(homeDir, 'Library', 'Application Support', 'Google', 'Chrome Canary'),
+            beta: path.join(homeDir, 'Library', 'Application Support', 'Google', 'Chrome Beta'),
+            dev: path.join(homeDir, 'Library', 'Application Support', 'Google', 'Chrome Dev'),
+        },
+        win32: {
+            stable: path.join(homeDir, 'AppData', 'Local', 'Google', 'Chrome', 'User Data'),
+            canary: path.join(homeDir, 'AppData', 'Local', 'Google', 'Chrome SxS', 'User Data'),
+            beta: path.join(homeDir, 'AppData', 'Local', 'Google', 'Chrome Beta', 'User Data'),
+            dev: path.join(homeDir, 'AppData', 'Local', 'Google', 'Chrome Dev', 'User Data'),
+        },
+        linux: {
+            stable: path.join(homeDir, '.config', 'google-chrome'),
+            canary: path.join(homeDir, '.config', 'google-chrome-unstable'),
+            beta: path.join(homeDir, '.config', 'google-chrome-beta'),
+            dev: path.join(homeDir, '.config', 'google-chrome-dev'),
+        },
+    };
+    return platformPaths[platform] || {};
+}
+/**
+ * Check if Chrome profile directory exists and is valid
+ */
+function validateChromeProfile(profilePath) {
+    try {
+        if (!fs.existsSync(profilePath)) {
+            return false;
+        }
+        const stats = fs.statSync(profilePath);
+        if (!stats.isDirectory()) {
+            return false;
+        }
+        // Check for essential Chrome profile files
+        const essentialFiles = [
+            'Default', // Default profile directory
+            'Local State', // Chrome local state file
+        ];
+        for (const file of essentialFiles) {
+            const filePath = path.join(profilePath, file);
+            if (!fs.existsSync(filePath)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Detect system Chrome profile for the specified channel
+ */
+export function detectSystemChromeProfile(channel = 'stable') {
+    const platform = os.platform();
+    const chromePaths = getChromeUserDataPaths();
+    if (!chromePaths[channel]) {
+        return null;
+    }
+    const profilePath = chromePaths[channel];
+    const exists = validateChromeProfile(profilePath);
+    if (exists) {
+        return {
+            path: profilePath,
+            exists: true,
+            platform,
+            channel,
+        };
+    }
+    return null;
+}
+/**
+ * Detect any available system Chrome profile with fallback priority
+ */
+export function detectAnySystemChromeProfile() {
+    const platform = os.platform();
+    const chromePaths = getChromeUserDataPaths();
+    // Priority order: stable > beta > dev > canary
+    const channelPriority = ['stable', 'beta', 'dev', 'canary'];
+    for (const channel of channelPriority) {
+        const profilePath = chromePaths[channel];
+        if (profilePath) {
+            const exists = validateChromeProfile(profilePath);
+            if (exists) {
+                return {
+                    path: profilePath,
+                    exists: true,
+                    platform,
+                    channel,
+                };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Get all available system Chrome profiles
+ */
+export function getAllSystemChromeProfiles() {
+    const platform = os.platform();
+    const chromePaths = getChromeUserDataPaths();
+    const profiles = [];
+    for (const [channel, profilePath] of Object.entries(chromePaths)) {
+        if (profilePath) {
+            const exists = validateChromeProfile(profilePath);
+            profiles.push({
+                path: profilePath,
+                exists,
+                platform,
+                channel,
+            });
+        }
+    }
+    return profiles;
+}
+/**
+ * Get the default profile path within a Chrome user data directory
+ */
+export function getDefaultProfilePath(userDataDir) {
+    return path.join(userDataDir, 'Default');
+}
+/**
+ * Check if we're running in a sandboxed environment where system profile detection might fail
+ */
+export function isSandboxedEnvironment() {
+    const platform = os.platform();
+    // Check for common sandbox indicators
+    if (platform === 'darwin') {
+        // macOS Seatbelt indicators
+        const sandboxIndicators = [
+            process.env.APP_SANDBOX_CONTAINER_ID,
+            process.env.TMPDIR?.includes('TemporaryItems'),
+        ];
+        return sandboxIndicators.some(indicator => !!indicator);
+    }
+    if (platform === 'linux') {
+        // Linux container indicators
+        const containerIndicators = [
+            fs.existsSync('/.dockerenv'),
+            process.env.container,
+            process.env.KUBERNETES_SERVICE_HOST,
+        ];
+        return containerIndicators.some(indicator => !!indicator);
+    }
+    return false;
+}
+/**
+ * Log system profile detection information for debugging
+ */
+export function logSystemProfileInfo() {
+    const platform = os.platform();
+    const profiles = getAllSystemChromeProfiles();
+    const sandboxed = isSandboxedEnvironment();
+    console.error(`System Chrome Profile Detection:`);
+    console.error(`  Platform: ${platform}`);
+    console.error(`  Sandboxed Environment: ${sandboxed}`);
+    console.error(`  Available Profiles:`);
+    if (profiles.length === 0) {
+        console.error(`    None detected`);
+    }
+    else {
+        profiles.forEach((profile, index) => {
+            console.error(`    ${index + 1}. ${profile.channel}: ${profile.path} (${profile.exists ? 'exists' : 'not found'})`);
+        });
+    }
+}

package/build/src/tools/ToolDefinition.js

@@ -0,0 +1,9 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export function defineTool(definition) {
+    return definition;
+}
+export const CLOSE_PAGE_ERROR = 'The last open page cannot be closed. It is fine to keep it open.';

package/build/src/tools/bookmarks.js

@@ -0,0 +1,170 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { z } from 'zod';
+import { CHATGPT_CONFIG } from '../config.js';
+import { ToolCategories } from './categories.js';
+import { defineTool } from './ToolDefinition.js';
+// Default development bookmarks
+function getDefaultBookmarks() {
+    return {
+        dashboard: 'https://chrome.google.com/webstore/devconsole',
+        new_item: 'https://chrome.google.com/webstore/devconsole/register',
+        analytics: 'https://chrome.google.com/webstore/devconsole/analytics',
+        payments: 'https://chrome.google.com/webstore/devconsole/payments',
+        support: 'https://support.google.com/chrome_webstore/contact/developer_support',
+        extensions: 'chrome://extensions/',
+        extensions_dev: 'chrome://extensions/?id=',
+        policy: 'https://developer.chrome.com/docs/webstore/program-policies/',
+        docs: 'https://developer.chrome.com/docs/extensions/',
+        localhost: 'http://localhost:3000',
+        localhost8080: 'http://localhost:8080',
+        chatgpt: CHATGPT_CONFIG.DEFAULT_URL,
+    };
+}
+/**
+ * Consolidated bookmarks tool.
+ * Combines: list_bookmarks, navigate_bookmark
+ */
+export const bookmarks = defineTool({
+    name: 'bookmarks',
+    description: 'Bookmarks: list or navigate to URL.',
+    annotations: {
+        category: ToolCategories.NAVIGATION_AUTOMATION,
+        readOnlyHint: false,
+    },
+    schema: {
+        op: z.enum(['list', 'navigate']).describe('Operation'),
+        name: z.string().optional().describe('Bookmark name (for navigate)'),
+    },
+    handler: async (request, response, context) => {
+        const { op, name } = request.params;
+        const allBookmarks = getDefaultBookmarks();
+        if (op === 'list') {
+            const bookmarkNames = Object.keys(allBookmarks);
+            if (bookmarkNames.length === 0) {
+                response.appendResponseLine('No bookmarks configured.');
+                return;
+            }
+            response.appendResponseLine('Available bookmarks:');
+            bookmarkNames.forEach(n => {
+                response.appendResponseLine(`  ${n}: ${allBookmarks[n]}`);
+            });
+            return;
+        }
+        // op === 'navigate'
+        if (!name) {
+            throw new Error('name required for navigate');
+        }
+        if (!allBookmarks[name]) {
+            response.appendResponseLine(`Bookmark "${name}" not found.`);
+            response.appendResponseLine('Available: ' + Object.keys(allBookmarks).join(', '));
+            return;
+        }
+        const url = allBookmarks[name];
+        const page = context.getSelectedPage();
+        await context.waitForEventsAfterAction(async () => {
+            await page.goto(url, { waitUntil: 'networkidle0' });
+            response.appendResponseLine(`Navigated to "${name}": ${url}`);
+        });
+    },
+});
+/**
+ * Open extension by ID.
+ */
+export const openExtensionById = defineTool({
+    name: 'open_extension_by_id',
+    description: 'Open extension page by ID.',
+    annotations: {
+        category: ToolCategories.EXTENSION_DEVELOPMENT,
+        readOnlyHint: false,
+    },
+    schema: {
+        extensionId: z.string().describe('Extension ID'),
+        page: z
+            .enum(['details', 'options'])
+            .default('details')
+            .describe('Page type'),
+    },
+    handler: async (request, response, context) => {
+        const { extensionId, page: extensionPage } = request.params;
+        const pageContext = context.getSelectedPage();
+        const url = extensionPage === 'details'
+            ? `chrome://extensions/?id=${extensionId}`
+            : `chrome-extension://${extensionId}/options.html`;
+        await context.waitForEventsAfterAction(async () => {
+            try {
+                await pageContext.goto(url, { waitUntil: 'networkidle0' });
+                response.appendResponseLine(`Opened ${extensionPage} for ${extensionId}`);
+            }
+            catch (error) {
+                response.appendResponseLine(`Failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        });
+    },
+});
+/**
+ * Open Web Store dashboard.
+ */
+export const openWebstoreDashboard = defineTool({
+    name: 'open_webstore_dashboard',
+    description: 'Open Chrome Web Store developer dashboard.',
+    annotations: {
+        category: ToolCategories.EXTENSION_DEVELOPMENT,
+        readOnlyHint: false,
+    },
+    schema: {},
+    handler: async (_request, response, context) => {
+        const page = context.getSelectedPage();
+        const url = 'https://chrome.google.com/webstore/devconsole';
+        await context.waitForEventsAfterAction(async () => {
+            await page.goto(url, { waitUntil: 'networkidle0' });
+            response.appendResponseLine('Opened Web Store Dashboard');
+        });
+    },
+});
+/**
+ * Open extension docs.
+ */
+export const openExtensionDocs = defineTool({
+    name: 'open_extension_docs',
+    description: 'Open Chrome Extensions documentation.',
+    annotations: {
+        category: ToolCategories.EXTENSION_DEVELOPMENT,
+        readOnlyHint: false,
+    },
+    schema: {
+        section: z
+            .enum([
+            'overview',
+            'getting-started',
+            'api',
+            'manifest',
+            'examples',
+            'best-practices',
+        ])
+            .optional()
+            .describe('Doc section'),
+    },
+    handler: async (request, response, context) => {
+        const { section } = request.params;
+        const page = context.getSelectedPage();
+        const sectionUrls = {
+            overview: 'https://developer.chrome.com/docs/extensions/',
+            'getting-started': 'https://developer.chrome.com/docs/extensions/get-started/',
+            api: 'https://developer.chrome.com/docs/extensions/reference/',
+            manifest: 'https://developer.chrome.com/docs/extensions/reference/manifest',
+            examples: 'https://github.com/GoogleChrome/chrome-extensions-samples',
+            'best-practices': 'https://developer.chrome.com/docs/extensions/develop/migrate',
+        };
+        const url = section
+            ? sectionUrls[section]
+            : 'https://developer.chrome.com/docs/extensions/';
+        await context.waitForEventsAfterAction(async () => {
+            await page.goto(url, { waitUntil: 'networkidle0' });
+            response.appendResponseLine(`Opened ${section || 'main'} docs`);
+        });
+    },
+});

package/build/src/tools/categories.js

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export var ToolCategories;
+(function (ToolCategories) {
+    ToolCategories["INPUT_AUTOMATION"] = "Input automation";
+    ToolCategories["NAVIGATION_AUTOMATION"] = "Navigation automation";
+    ToolCategories["EMULATION"] = "Emulation";
+    ToolCategories["PERFORMANCE"] = "Performance";
+    ToolCategories["NETWORK"] = "Network";
+    ToolCategories["DEBUGGING"] = "Debugging";
+    ToolCategories["EXTENSION_DEVELOPMENT"] = "Extension development";
+})(ToolCategories || (ToolCategories = {}));