chrome-ai-bridge 1.0.0

package/build/src/roots-manager.js

@@ -0,0 +1,253 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Roots Manager
+ *
+ * Manages MCP roots (project directories) and generates stable profile keys.
+ * Implements the MCP Roots protocol for project-scoped Chrome profiles.
+ */
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { detectProjectName } from './project-detector.js';
+import { resolveStableIdentity } from './stable-identity.js';
+/**
+ * Fetch roots from MCP client using roots/list protocol
+ */
+export async function fetchRootsFromClient(server) {
+    const clientCaps = server.getClientCapabilities();
+    if (!clientCaps?.roots) {
+        console.error('[roots] Client does not support roots capability');
+        return null;
+    }
+    try {
+        console.error('[roots] Requesting roots/list from client...');
+        const result = await server.listRoots({}, { timeout: 5000 });
+        console.error(`[roots] Received ${result.roots.length} roots from client`);
+        return result;
+    }
+    catch (error) {
+        console.error(`[roots] Failed to fetch roots from client: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Generate stable profile key from roots and client info
+ * Format: projectName_hash (e.g., "my-app_2ca5dbf5")
+ *
+ * @param rootsUris - Array of root URIs (used for fallback hash if stableIdentityHash not provided)
+ * @param clientName - Client name (e.g., "claude-code")
+ * @param clientVersion - Client version (not used in hash for stability)
+ * @param projectName - Human-readable project name
+ * @param stableIdentityHash - Optional stable identity hash (from git remote, etc.)
+ */
+export function generateProfileKey(rootsUris, clientName, clientVersion, projectName, stableIdentityHash) {
+    let hash;
+    if (stableIdentityHash) {
+        // Use stable identity hash (preferred - survives directory moves)
+        hash = stableIdentityHash;
+    }
+    else {
+        // Fallback: URI-based hash
+        const sortedUris = [...rootsUris].sort();
+        const keyMaterial = JSON.stringify({
+            roots: sortedUris,
+            client: clientName,
+        });
+        hash = createHash('sha256').update(keyMaterial).digest('hex').slice(0, 8);
+    }
+    // Include project name for clarity (if available)
+    if (projectName) {
+        const sanitized = projectName.replace(/[^a-z0-9_-]/gi, '-').toLowerCase();
+        return `${sanitized}_${hash}`;
+    }
+    return hash;
+}
+/**
+ * Extract project name from roots URIs
+ * Uses detectProjectName() to read package.json name (preferred)
+ * Falls back to directory name if package.json not found
+ */
+export function extractProjectName(roots) {
+    if (roots.length === 0) {
+        return 'unknown';
+    }
+    // Prefer explicit name if provided by MCP client
+    const firstRoot = roots[0];
+    if (firstRoot.name) {
+        return sanitizeProjectName(firstRoot.name);
+    }
+    // Extract from file:// URI using detectProjectName (reads package.json)
+    try {
+        const url = new URL(firstRoot.uri);
+        if (url.protocol === 'file:') {
+            // Convert URI to file path
+            const rootPath = fileURLToPath(url);
+            // Resolve realpath for symlink handling
+            let realPath;
+            try {
+                realPath = fs.realpathSync(rootPath);
+            }
+            catch {
+                realPath = rootPath; // Use original if realpath fails
+            }
+            // Use detectProjectName to read package.json name
+            const name = detectProjectName(realPath);
+            return sanitizeProjectName(name);
+        }
+    }
+    catch {
+        // Fall through to default
+    }
+    return 'unknown';
+}
+/**
+ * Sanitize project name for use in file paths
+ */
+function sanitizeProjectName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9-_]/g, '-');
+}
+/**
+ * Get stable identity hash from a root path
+ * Returns undefined if stable identity cannot be resolved
+ */
+function getStableIdentityHash(rootPath) {
+    try {
+        const identity = resolveStableIdentity(rootPath);
+        // Only use stable identity for high-confidence sources (git-based)
+        if (identity.confidence === 'high' ||
+            identity.source === 'MCP_PROFILE_ID') {
+            return identity.id;
+        }
+    }
+    catch {
+        // Fall through to URI-based hash
+    }
+    return undefined;
+}
+/**
+ * Get root path from URI
+ */
+function getRootPathFromUri(uri) {
+    try {
+        const url = new URL(uri);
+        if (url.protocol === 'file:') {
+            const rootPath = fileURLToPath(url);
+            try {
+                return fs.realpathSync(rootPath);
+            }
+            catch {
+                return rootPath;
+            }
+        }
+    }
+    catch {
+        // Ignore
+    }
+    return undefined;
+}
+/**
+ * Resolve roots information from MCP client or fallbacks
+ */
+export async function resolveRoots(server, fallbackOptions) {
+    const clientInfo = server.getClientVersion();
+    const clientName = clientInfo?.name || 'unknown-client';
+    const clientVersion = clientInfo?.version || '0.0.0';
+    // 1) Try roots/list from client (preferred)
+    const rootsResult = await fetchRootsFromClient(server);
+    if (rootsResult && rootsResult.roots.length > 0) {
+        const rootsUris = rootsResult.roots.map(r => r.uri);
+        const projectName = extractProjectName(rootsResult.roots);
+        // Get stable identity hash from first root
+        const rootPath = getRootPathFromUri(rootsUris[0]);
+        const stableHash = rootPath ? getStableIdentityHash(rootPath) : undefined;
+        const profileKey = generateProfileKey(rootsUris, clientName, clientVersion, projectName, stableHash);
+        console.error(`[roots] Resolved via roots/list: key=${profileKey}, project=${projectName}, client=${clientName}, stableId=${stableHash || 'none'}`);
+        return {
+            profileKey,
+            projectName,
+            rootsUris,
+            clientName,
+            clientVersion,
+            source: 'roots/list',
+        };
+    }
+    // 2) Fallback: CLI argument --project-root
+    if (fallbackOptions.cliProjectRoot) {
+        const uri = pathToFileUri(fallbackOptions.cliProjectRoot);
+        const projectName = extractProjectName([{ uri }]);
+        // Get stable identity hash
+        const stableHash = getStableIdentityHash(fallbackOptions.cliProjectRoot);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName, stableHash);
+        console.error(`[roots] Resolved via --project-root: key=${profileKey}, project=${projectName}, stableId=${stableHash || 'none'}`);
+        return {
+            profileKey,
+            projectName,
+            rootsUris: [uri],
+            clientName,
+            clientVersion,
+            source: '--project-root',
+        };
+    }
+    // 3) Fallback: Environment variable MCP_PROJECT_ROOT
+    if (fallbackOptions.envProjectRoot) {
+        const uri = pathToFileUri(fallbackOptions.envProjectRoot);
+        const projectName = extractProjectName([{ uri }]);
+        // Get stable identity hash
+        const stableHash = getStableIdentityHash(fallbackOptions.envProjectRoot);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName, stableHash);
+        console.error(`[roots] Resolved via MCP_PROJECT_ROOT: key=${profileKey}, project=${projectName}, stableId=${stableHash || 'none'}`);
+        return {
+            profileKey,
+            projectName,
+            rootsUris: [uri],
+            clientName,
+            clientVersion,
+            source: 'MCP_PROJECT_ROOT',
+        };
+    }
+    // 4) Fallback: AUTO (cwd-based, last resort)
+    if (fallbackOptions.autoCwd) {
+        const uri = pathToFileUri(fallbackOptions.autoCwd);
+        const projectName = extractProjectName([{ uri }]);
+        // Get stable identity hash
+        const stableHash = getStableIdentityHash(fallbackOptions.autoCwd);
+        const profileKey = generateProfileKey([uri], clientName, clientVersion, projectName, stableHash);
+        console.error(`[roots] Resolved via AUTO (cwd): key=${profileKey}, project=${projectName}, stableId=${stableHash || 'none'}`);
+        return {
+            profileKey,
+            projectName,
+            rootsUris: [uri],
+            clientName,
+            clientVersion,
+            source: 'AUTO',
+        };
+    }
+    // Absolute fallback
+    const fallbackUri = 'file:///unknown';
+    const fallbackProjectName = 'unknown';
+    const profileKey = generateProfileKey([fallbackUri], clientName, clientVersion, fallbackProjectName);
+    console.error('[roots] WARNING: No roots available, using fallback');
+    return {
+        profileKey,
+        projectName: fallbackProjectName,
+        rootsUris: [fallbackUri],
+        clientName,
+        clientVersion,
+        source: 'AUTO',
+    };
+}
+/**
+ * Convert absolute file path to file:// URI
+ */
+function pathToFileUri(absPath) {
+    // Normalize path and convert to file:// URI
+    const normalized = absPath.replace(/\\/g, '/');
+    const withoutLeadingSlash = normalized.startsWith('/')
+        ? normalized
+        : '/' + normalized;
+    return `file://${withoutLeadingSlash}`;
+}

package/build/src/selectors/chatgpt.json

@@ -0,0 +1,61 @@
+{
+  "version": "2025-10",
+  "lastUpdated": "2025-10-03",
+  "description": "ChatGPT Web UI selectors for browser automation",
+  "elements": {
+    "newChatLink": {
+      "css": "a[href='/']",
+      "description": "新しいチャット作成リンク"
+    },
+    "tempChatToggle": {
+      "ax": {
+        "role": "button",
+        "nameContains": "一時チャットをオフにする"
+      },
+      "description": "一時チャットON/OFFトグルボタン"
+    },
+    "addFileButton": {
+      "ax": {
+        "role": "button",
+        "ariaLabel": "ファイルの追加"
+      },
+      "description": "ファイル追加（ツールメニューを開く）ボタン"
+    },
+    "composerTextarea": {
+      "css": "textarea[placeholder]",
+      "description": "メッセージ入力テキストエリア"
+    },
+    "prosemirrorEditor": {
+      "css": ".ProseMirror[contenteditable='true']",
+      "description": "ProseMirrorエディタ"
+    },
+    "sendButton": {
+      "css": "button[data-testid='send-button']",
+      "description": "送信ボタン"
+    },
+    "userMessage": {
+      "css": "[data-message-author-role='user']",
+      "description": "ユーザーメッセージ"
+    },
+    "assistantMessage": {
+      "css": "[data-message-author-role='assistant']",
+      "description": "アシスタントメッセージ"
+    },
+    "stopButton": {
+      "text": ["停止", "ストリーミングの停止"],
+      "ax": {
+        "ariaLabel": ["停止", "ストリーミングの停止"]
+      },
+      "description": "ストリーミング停止ボタン"
+    },
+    "thinkingTimeButton": {
+      "ax": {
+        "ariaLabelContains": "思考時間"
+      },
+      "description": "思考時間表示ボタン"
+    }
+  },
+  "placeholders": {
+    "normalMode": "Message ChatGPT"
+  }
+}

package/build/src/selectors/gemini.json

@@ -0,0 +1,24 @@
+{
+  "version": "1.0.0",
+  "lastUpdated": "2025-11-27",
+  "description": "Selectors for Gemini web interface",
+  "elements": {
+    "editor": {
+      "css": "div[contenteditable='true']",
+      "description": "Main input editor"
+    },
+    "sendButton": {
+      "ax": {
+        "ariaLabel": "送信"
+      },
+      "description": "Send message button"
+    },
+    "response": {
+      "css": "model-response",
+      "description": "Response container"
+    }
+  },
+  "placeholders": {
+    "normalMode": "プロンプトを入力"
+  }
+}

package/build/src/selectors/loader.js

@@ -0,0 +1,128 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+let cachedSelectors = null;
+/**
+ * Load ChatGPT selectors from JSON file
+ */
+export function loadSelectors() {
+    if (cachedSelectors) {
+        return cachedSelectors;
+    }
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const selectorsPath = path.join(__dirname, 'chatgpt.json');
+    try {
+        const data = fs.readFileSync(selectorsPath, 'utf-8');
+        cachedSelectors = JSON.parse(data);
+        return cachedSelectors;
+    }
+    catch (error) {
+        throw new Error(`Failed to load selectors from ${selectorsPath}: ${error}`);
+    }
+}
+/**
+ * Get a specific selector definition
+ */
+export function getSelector(elementName) {
+    const selectors = loadSelectors();
+    const selector = selectors.elements[elementName];
+    if (!selector) {
+        throw new Error(`Selector not found: ${elementName}`);
+    }
+    return selector;
+}
+/**
+ * Generate page.evaluate() compatible selector function for text matching
+ */
+export function generateTextMatcher(selector, tagName = 'button') {
+    const textPatterns = Array.isArray(selector.text)
+        ? selector.text
+        : [selector.text];
+    return `
+    Array.from(document.querySelectorAll('${tagName}')).find(el => {
+      const text = el.textContent || '';
+      return ${textPatterns.map(t => `text.includes('${t}')`).join(' || ')};
+    })
+  `;
+}
+/**
+ * Generate page.evaluate() compatible selector function for accessibility matching
+ */
+export function generateAxMatcher(selector, tagName = 'button') {
+    if (!selector.ax) {
+        throw new Error('Accessibility selector not defined');
+    }
+    const conditions = [];
+    if (selector.ax.ariaLabel) {
+        const labels = Array.isArray(selector.ax.ariaLabel)
+            ? selector.ax.ariaLabel
+            : [selector.ax.ariaLabel];
+        conditions.push(labels.map(label => `aria.includes('${label}')`).join(' || '));
+    }
+    if (selector.ax.ariaLabelContains) {
+        conditions.push(`aria.includes('${selector.ax.ariaLabelContains}')`);
+    }
+    if (selector.ax.nameContains) {
+        conditions.push(`aria.includes('${selector.ax.nameContains}')`);
+    }
+    return `
+    Array.from(document.querySelectorAll('${tagName}')).find(el => {
+      const aria = el.getAttribute('aria-label') || '';
+      return ${conditions.join(' || ')};
+    })
+  `;
+}
+/**
+ * Check if placeholder matches expected patterns
+ */
+export function checkPlaceholder(placeholder) {
+    const selectors = loadSelectors();
+    if (selectors.placeholders?.normalMode) {
+        return placeholder.includes(selectors.placeholders.normalMode);
+    }
+    return false;
+}
+/**
+ * Clear cached selectors (useful for testing or hot-reload)
+ */
+export function clearCache() {
+    cachedSelectors = null;
+    cachedGeminiSelectors = null;
+}
+let cachedGeminiSelectors = null;
+/**
+ * Load Gemini selectors from JSON file
+ */
+export function loadGeminiSelectors() {
+    if (cachedGeminiSelectors) {
+        return cachedGeminiSelectors;
+    }
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const selectorsPath = path.join(__dirname, 'gemini.json');
+    try {
+        const data = fs.readFileSync(selectorsPath, 'utf-8');
+        cachedGeminiSelectors = JSON.parse(data);
+        return cachedGeminiSelectors;
+    }
+    catch (error) {
+        throw new Error(`Failed to load selectors from ${selectorsPath}: ${error}`);
+    }
+}
+/**
+ * Get a specific Gemini selector definition
+ */
+export function getGeminiSelector(elementName) {
+    const selectors = loadGeminiSelectors();
+    const selector = selectors.elements[elementName];
+    if (!selector) {
+        throw new Error(`Selector not found: ${elementName}`);
+    }
+    return selector;
+}

package/build/src/stable-identity.js

@@ -0,0 +1,193 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// src/stable-identity.ts
+// Stable project identity detection for profile persistence across directory moves
+// Priority: MCP_PROFILE_ID > git remote origin > git first commit > package.json name > directory fallback
+import { spawnSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * Resolve stable project identity in priority order.
+ * This identity remains stable even when the project directory is moved.
+ */
+export function resolveStableIdentity(projectRoot, env = process.env) {
+    // 1. Check explicit env var (highest priority)
+    const explicitId = env.MCP_PROFILE_ID?.trim();
+    if (explicitId) {
+        return {
+            id: sanitizeIdentity(explicitId),
+            source: 'MCP_PROFILE_ID',
+            raw: explicitId,
+            confidence: 'high',
+        };
+    }
+    // 2. Try git remote origin URL (stable across moves)
+    const remoteName = env.MCP_GIT_REMOTE || 'origin';
+    const remoteUrl = getGitRemoteOrigin(projectRoot, remoteName);
+    if (remoteUrl) {
+        const normalized = normalizeGitUrl(remoteUrl);
+        return {
+            id: shortHash(normalized),
+            source: 'git-remote-origin',
+            raw: remoteUrl,
+            confidence: 'high',
+        };
+    }
+    // 3. Try git first commit hash (stable, works offline)
+    const firstCommit = getGitFirstCommit(projectRoot);
+    if (firstCommit) {
+        return {
+            id: firstCommit.slice(0, 8), // Use first 8 chars of commit hash directly
+            source: 'git-first-commit',
+            raw: firstCommit,
+            confidence: 'high',
+        };
+    }
+    // 4. Try package.json name (semi-stable, may conflict)
+    const packageName = getPackageName(projectRoot);
+    if (packageName) {
+        return {
+            id: shortHash(packageName),
+            source: 'package-name',
+            raw: packageName,
+            confidence: 'medium', // May conflict if same name in different projects
+        };
+    }
+    // 5. Fallback to directory-based (legacy behavior)
+    const realPath = realpathSafe(projectRoot);
+    return {
+        id: shortHash(realPath),
+        source: 'directory-fallback',
+        raw: realPath,
+        confidence: 'low',
+    };
+}
+/**
+ * Get legacy identity hash (realpath-based) for migration detection.
+ */
+export function getLegacyIdentityHash(projectRoot) {
+    const realPath = realpathSafe(projectRoot);
+    return shortHash(realPath);
+}
+// --- Git Utilities ---
+/**
+ * Get git remote origin URL.
+ * Returns null if not a git repo or no remote configured.
+ */
+function getGitRemoteOrigin(cwd, remoteName = 'origin') {
+    try {
+        const result = spawnSync('git', ['remote', 'get-url', remoteName], {
+            cwd,
+            timeout: 500,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        });
+        if (result.status === 0 && result.stdout) {
+            const url = result.stdout.trim();
+            return url || null;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
+/**
+ * Get hash of the first commit in git history.
+ * This is stable even when project is moved.
+ */
+function getGitFirstCommit(cwd) {
+    try {
+        const result = spawnSync('git', ['rev-list', '--max-parents=0', 'HEAD'], {
+            cwd,
+            timeout: 500,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        });
+        if (result.status === 0 && result.stdout) {
+            // May have multiple roots for merged repos, use first
+            const commits = result.stdout.trim().split('\n');
+            return commits[0] || null;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
+/**
+ * Normalize git URL for consistent hashing.
+ * Handles: SSH, HTTPS, with/without .git suffix
+ *
+ * Examples:
+ *   git@github.com:user/repo.git -> github.com/user/repo
+ *   https://github.com/user/repo.git -> github.com/user/repo
+ *   ssh://git@github.com/user/repo -> github.com/user/repo
+ */
+export function normalizeGitUrl(url) {
+    let normalized = url.trim();
+    // Remove ssh:// prefix
+    normalized = normalized.replace(/^ssh:\/\//, '');
+    // Remove git@ prefix
+    normalized = normalized.replace(/^git@/, '');
+    // Remove https:// or http:// prefix
+    normalized = normalized.replace(/^https?:\/\//, '');
+    // Replace : with / (SSH style urls like github.com:user/repo)
+    normalized = normalized.replace(/:(?!\/)/, '/');
+    // Remove .git suffix
+    normalized = normalized.replace(/\.git$/, '');
+    // Lowercase for consistency
+    normalized = normalized.toLowerCase();
+    return normalized;
+}
+// --- Package.json Utilities ---
+/**
+ * Get package name from package.json.
+ */
+function getPackageName(projectRoot) {
+    const pjPath = path.join(projectRoot, 'package.json');
+    try {
+        if (fs.existsSync(pjPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pjPath, 'utf8'));
+            if (pkg && typeof pkg.name === 'string' && pkg.name.trim()) {
+                return pkg.name.trim();
+            }
+        }
+    }
+    catch {
+        /* ignore parse errors */
+    }
+    return null;
+}
+// --- Hash Utilities ---
+function shortHash(s) {
+    try {
+        return crypto.createHash('sha256').update(s).digest('hex').slice(0, 8);
+    }
+    catch {
+        return '00000000';
+    }
+}
+function sanitizeIdentity(s) {
+    // Allow alphanumeric, dash, underscore only
+    const sanitized = s.toLowerCase().replace(/[^a-z0-9-_]/g, '-');
+    // Truncate to reasonable length (32 chars max)
+    return sanitized.slice(0, 32) || 'profile';
+}
+function realpathSafe(p) {
+    try {
+        const rp = fs.realpathSync.native
+            ? fs.realpathSync.native(p)
+            : fs.realpathSync(p);
+        return rp;
+    }
+    catch {
+        return path.normalize(p);
+    }
+}