chrome-devtools-mcp-for-extension 0.22.6 → 0.23.1

package/build/src/McpContext.js

@@ -275,12 +275,18 @@ export class McpContext {
         this.#dialog = dialog;
     };
     setSelectedPageIdx(idx) {
-        const oldPage = this.getSelectedPage();
-        oldPage.off('dialog', this.#dialogHandler);
+        // Remove dialog handler from old page if exists
+        const oldPage = this.#pages[this.#selectedPageIdx];
+        if (oldPage && !oldPage.isClosed()) {
+            oldPage.off('dialog', this.#dialogHandler);
+        }
         this.#selectedPageIdx = idx;
-        const newPage = this.getSelectedPage();
-        newPage.on('dialog', this.#dialogHandler);
-        this.#updateSelectedPageTimeouts();
+        // Add dialog handler to new page if exists
+        const newPage = this.#pages[idx];
+        if (newPage && !newPage.isClosed()) {
+            newPage.on('dialog', this.#dialogHandler);
+            this.#updateSelectedPageTimeouts();
+        }
     }
     #updateSelectedPageTimeouts() {
         const page = this.getSelectedPage();

package/build/src/main.js

@@ -46,17 +46,13 @@ import { Mutex } from './Mutex.js';
 import { resolveRoots } from './roots-manager.js';
 import { setProjectRoot } from './project-root-state.js';
 import { setupGraceful } from './graceful.js';
-import * as bookmarkTools from './tools/bookmarks.js';
 import * as chatgptWebTools from './tools/chatgpt-web.js';
-import * as deepResearchChatGPTTools from './tools/deep_research_chatgpt.js';
 import * as consoleTools from './tools/console.js';
-import * as diagnoseUiTools from './tools/diagnose-ui.js';
 import * as emulationTools from './tools/emulation.js';
-import * as extensionTools from './tools/extensions.js';
 import * as geminiWebTools from './tools/gemini-web.js';
-import * as inputTools from './tools/input.js';
+import { click, fill, fillForm } from './tools/input.js';
 import * as networkTools from './tools/network.js';
-import * as pagesTools from './tools/pages.js';
+import { pages, navigate } from './tools/pages.js';
 import * as performanceTools from './tools/performance.js';
 import * as screenshotTools from './tools/screenshot.js';
 import * as scriptTools from './tools/script.js';
@@ -242,17 +238,16 @@ function registerTool(tool) {
     });
 }
 const tools = [
-    ...Object.values(bookmarkTools),
     ...Object.values(chatgptWebTools),
-    ...Object.values(deepResearchChatGPTTools),
     ...Object.values(geminiWebTools),
     ...Object.values(consoleTools),
-    ...Object.values(diagnoseUiTools),
     ...Object.values(emulationTools),
-    ...Object.values(extensionTools),
-    ...Object.values(inputTools),
+    click,
+    fill,
+    fillForm,
     ...Object.values(networkTools),
-    ...Object.values(pagesTools),
+    pages,
+    navigate,
     ...Object.values(performanceTools),
     ...Object.values(screenshotTools),
     ...Object.values(scriptTools),

package/build/src/tools/chatgpt-web.js

@@ -454,15 +454,9 @@ export const askChatGPTWeb = defineTool({
                         const progressText = progressElements
                             .map((el) => el.textContent)
                             .join(' ');
-                        // Check if DeepResearch is still running
-                        const buttons = Array.from(document.querySelectorAll('button'));
-                        const isRunning = buttons.some((btn) => {
-                            const text = btn.textContent || '';
-                            const aria = btn.getAttribute('aria-label') || '';
-                            return (text.includes('停止') ||
-                                text.includes('リサーチを停止') ||
-                                aria.includes('停止'));
-                        });
+                        // Check if DeepResearch is still running - use stop-button data-testid
+                        const stopButton = document.querySelector('button[data-testid="stop-button"]');
+                        const isRunning = !!stopButton;
                         if (!isRunning) {
                             // Research completed - get the report
                             const assistantMessages = document.querySelectorAll('[data-message-author-role="assistant"]');
@@ -482,16 +476,10 @@ export const askChatGPTWeb = defineTool({
                             currentText: progressText.substring(0, 200),
                         };
                     }
-                    // Normal streaming detection
-                    const buttons = Array.from(document.querySelectorAll('button'));
-                    const isStreaming = buttons.some((btn) => {
-                        const text = btn.textContent || '';
-                        const aria = btn.getAttribute('aria-label') || '';
-                        return (text.includes('ストリーミングの停止') ||
-                            text.includes('停止') ||
-                            aria.includes('ストリーミングの停止') ||
-                            aria.includes('停止'));
-                    });
+                    // Normal streaming detection - check for stop button by data-testid
+                    // When ChatGPT is generating, send-button becomes stop-button
+                    const stopButton = document.querySelector('button[data-testid="stop-button"]');
+                    const isStreaming = !!stopButton;
                     if (!isStreaming) {
                         // Get final response
                         const assistantMessages = document.querySelectorAll('[data-message-author-role="assistant"]');

package/build/src/tools/gemini-web.js

@@ -209,6 +209,8 @@ export const askGeminiWeb = defineTool({
             // Navigate directly to target URL (skip intermediate navigation)
             response.appendResponseLine('Geminiに接続中...');
             await navigateWithRetry(page, targetUrl, { waitUntil: 'networkidle2' });
+            // Wait for Gemini SPA to fully render (networkidle2 is not enough for SPAs)
+            await new Promise(resolve => setTimeout(resolve, 1000));
             // Check login only once after navigation
             const needsLogin = await isLoginRequired(page);
             if (needsLogin) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-devtools-mcp-for-extension",
-  "version": "0.22.6",
+  "version": "0.23.1",
   "description": "MCP server for Chrome extension development with Web Store automation. Fork of chrome-devtools-mcp with extension-specific tools.",
   "type": "module",
   "bin": "./scripts/cli.mjs",

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/Linkifier.js

@@ -1,34 +0,0 @@
-// Copyright 2019 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-export class Linkifier {
-    static async linkify(object, options) {
-        if (!object) {
-            throw new Error('Can\'t linkify ' + object);
-        }
-        const linkifierRegistration = getApplicableRegisteredlinkifiers(object)[0];
-        if (!linkifierRegistration) {
-            throw new Error('No linkifiers registered for object ' + object);
-        }
-        const linkifier = await linkifierRegistration.loadLinkifier();
-        return linkifier.linkify(object, options);
-    }
-}
-const registeredLinkifiers = [];
-export function registerLinkifier(registration) {
-    registeredLinkifiers.push(registration);
-}
-export function getApplicableRegisteredlinkifiers(object) {
-    return registeredLinkifiers.filter(isLinkifierApplicableToContextTypes);
-    function isLinkifierApplicableToContextTypes(linkifierRegistration) {
-        if (!linkifierRegistration.contextTypes) {
-            return true;
-        }
-        for (const contextType of linkifierRegistration.contextTypes()) {
-            if (object instanceof contextType) {
-                return true;
-            }
-        }
-        return false;
-    }
-}

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/QueryParamHandler.js

@@ -1,4 +0,0 @@
-// Copyright 2019 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-export {};

package/build/node_modules/chrome-devtools-frontend/front_end/core/common/Worker.js

@@ -1,44 +0,0 @@
-// Copyright 2014 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-export class WorkerWrapper {
-    #workerPromise;
-    #disposed;
-    constructor(workerLocation) {
-        this.#workerPromise = new Promise(fulfill => {
-            const worker = new Worker(workerLocation, { type: 'module' });
-            worker.onmessage = (event) => {
-                console.assert(event.data === 'workerReady');
-                worker.onmessage = null;
-                fulfill(worker);
-            };
-        });
-    }
-    static fromURL(url) {
-        return new WorkerWrapper(url);
-    }
-    postMessage(message, transfer) {
-        void this.#workerPromise.then(worker => {
-            if (!this.#disposed) {
-                worker.postMessage(message, transfer ?? []);
-            }
-        });
-    }
-    dispose() {
-        this.#disposed = true;
-        void this.#workerPromise.then(worker => worker.terminate());
-    }
-    terminate() {
-        this.dispose();
-    }
-    set onmessage(listener) {
-        void this.#workerPromise.then(worker => {
-            worker.onmessage = listener;
-        });
-    }
-    set onerror(listener) {
-        void this.#workerPromise.then(worker => {
-            worker.onerror = listener;
-        });
-    }
-}

package/build/node_modules/chrome-devtools-frontend/front_end/core/platform/DOMUtilities.js

@@ -1,122 +0,0 @@
-// Copyright 2022 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-/**
- * `document.activeElement` will not enter shadow roots to find the element
- * that has focus; use this method if you need to traverse through any shadow
- * roots to find the actual, specific focused element.
- */
-export function deepActiveElement(doc) {
-    let activeElement = doc.activeElement;
-    while (activeElement?.shadowRoot?.activeElement) {
-        activeElement = activeElement.shadowRoot.activeElement;
-    }
-    return activeElement;
-}
-export function getEnclosingShadowRootForNode(node) {
-    let parentNode = node.parentNodeOrShadowHost();
-    while (parentNode) {
-        if (parentNode instanceof ShadowRoot) {
-            return parentNode;
-        }
-        parentNode = parentNode.parentNodeOrShadowHost();
-    }
-    return null;
-}
-export function rangeOfWord(rootNode, offset, stopCharacters, stayWithinNode, direction) {
-    let startNode;
-    let startOffset = 0;
-    let endNode;
-    let endOffset = 0;
-    if (!stayWithinNode) {
-        stayWithinNode = rootNode;
-    }
-    if (!direction || direction === 'backward' || direction === 'both') {
-        let node = rootNode;
-        while (node) {
-            if (node === stayWithinNode) {
-                if (!startNode) {
-                    startNode = stayWithinNode;
-                }
-                break;
-            }
-            if (node.nodeType === Node.TEXT_NODE && node.nodeValue !== null) {
-                const start = (node === rootNode ? (offset - 1) : (node.nodeValue.length - 1));
-                for (let i = start; i >= 0; --i) {
-                    if (stopCharacters.indexOf(node.nodeValue[i]) !== -1) {
-                        startNode = node;
-                        startOffset = i + 1;
-                        break;
-                    }
-                }
-            }
-            if (startNode) {
-                break;
-            }
-            node = node.traversePreviousNode(stayWithinNode);
-        }
-        if (!startNode) {
-            startNode = stayWithinNode;
-            startOffset = 0;
-        }
-    }
-    else {
-        startNode = rootNode;
-        startOffset = offset;
-    }
-    if (!direction || direction === 'forward' || direction === 'both') {
-        let node = rootNode;
-        while (node) {
-            if (node === stayWithinNode) {
-                if (!endNode) {
-                    endNode = stayWithinNode;
-                }
-                break;
-            }
-            if (node.nodeType === Node.TEXT_NODE && node.nodeValue !== null) {
-                const start = (node === rootNode ? offset : 0);
-                for (let i = start; i < node.nodeValue.length; ++i) {
-                    if (stopCharacters.indexOf(node.nodeValue[i]) !== -1) {
-                        endNode = node;
-                        endOffset = i;
-                        break;
-                    }
-                }
-            }
-            if (endNode) {
-                break;
-            }
-            node = node.traverseNextNode(stayWithinNode);
-        }
-        if (!endNode) {
-            endNode = stayWithinNode;
-            endOffset = stayWithinNode.nodeType === Node.TEXT_NODE ? stayWithinNode.nodeValue?.length || 0 :
-                stayWithinNode.childNodes.length;
-        }
-    }
-    else {
-        endNode = rootNode;
-        endOffset = offset;
-    }
-    if (!rootNode.ownerDocument) {
-        throw new Error('No `ownerDocument` found for rootNode');
-    }
-    const result = rootNode.ownerDocument.createRange();
-    result.setStart(startNode, startOffset);
-    result.setEnd(endNode, endOffset);
-    return result;
-}
-/**
- * Appends the list of `styles` as individual `<style>` elements to the
- * given `node`.
- *
- * @param node the `Node` to append the `<style>` elements to.
- * @param styles an optional list of styles to append to the `node`.
- */
-export function appendStyle(node, ...styles) {
-    for (const cssText of styles) {
-        const style = (node.ownerDocument ?? document).createElement('style');
-        style.textContent = cssText;
-        node.appendChild(style);
-    }
-}

package/build/node_modules/chrome-devtools-frontend/front_end/core/protocol_client/NodeURL.js

@@ -1,31 +0,0 @@
-// Copyright 2018 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-import * as Common from '../common/common.js';
-import * as Host from '../host/host.js';
-export class NodeURL {
-    static patch(object) {
-        process(object, '');
-        function process(object, path) {
-            if (object.url && NodeURL.isPlatformPath(object.url, Host.Platform.isWin())) {
-                // object.url can be of both types: RawPathString and UrlString
-                object.url = Common.ParsedURL.ParsedURL.rawPathToUrlString(object.url);
-            }
-            for (const entry of Object.entries(object)) {
-                const key = entry[0];
-                const value = entry[1];
-                const entryPath = path + '.' + key;
-                if (entryPath !== '.result.result.value' && value !== null && typeof value === 'object') {
-                    process(value, entryPath);
-                }
-            }
-        }
-    }
-    static isPlatformPath(fileSystemPath, isWindows) {
-        if (isWindows) {
-            const re = /^([a-z]:[\/\\]|\\\\)/i;
-            return re.test(fileSystemPath);
-        }
-        return fileSystemPath.length ? fileSystemPath[0] === '/' : false;
-    }
-}

package/build/node_modules/chrome-devtools-frontend/front_end/models/source_map_scopes/ScopeTreeCache.js

@@ -1,32 +0,0 @@
-// Copyright 2023 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-import * as Formatter from '../formatter/formatter.js';
-import * as TextUtils from '../text_utils/text_utils.js';
-/** If a script failed to parse, we stash null in order to prevent unnecessary re-parsing */
-const scopeTrees = new WeakMap();
-/**
- * Computes and caches the scope tree for `script`.
- *
- * We use {@link SDK.Script.Script} as a key to uniquely identify scripts.
- * {@link SDK.Script.Script} boils down to "target" + "script ID". This
- * duplicates work in case of identitical script running on multiple targets
- * (e.g. workers).
- */
-export function scopeTreeForScript(script) {
-    let promise = scopeTrees.get(script);
-    if (promise === undefined) {
-        promise = script.requestContentData().then(content => {
-            if (TextUtils.ContentData.ContentData.isError(content)) {
-                return null;
-            }
-            const sourceType = script.isModule ? 'module' : 'script';
-            return Formatter.FormatterWorkerPool.formatterWorkerPool()
-                .javaScriptScopeTree(content.text, sourceType)
-                .catch(() => null);
-        });
-        scopeTrees.set(script, promise);
-    }
-    // We intentionally return `null` here if the script already failed to parse once.
-    return promise;
-}

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/lantern/testing/MetricTestUtils.js

@@ -1,46 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-// Unsure why this lint is failing, given `lantern/metrics/SpeedIndex.test.ts` does the same
-// and is fine. Maybe `*.test.*` files are excluded from this rule?
-// eslint-disable-next-line rulesdir/es-modules-import
-import * as TraceLoader from '../../../../testing/TraceLoader.js';
-import * as Trace from '../../trace.js';
-import * as Lantern from '../lantern.js';
-function toLanternTrace(traceEvents) {
-    return {
-        traceEvents: traceEvents,
-    };
-}
-async function runTraceProcessor(context, trace) {
-    TraceLoader.TraceLoader.setTestTimeout(context);
-    const processor = Trace.Processor.TraceProcessor.createWithAllHandlers();
-    await processor.parse(trace.traceEvents, { isCPUProfile: false, isFreshRecording: true });
-    if (!processor.data) {
-        throw new Error('No data');
-    }
-    return processor.data;
-}
-async function getComputationDataFromFixture(context, { trace, settings, url }) {
-    settings = settings ?? {};
-    if (!settings.throttlingMethod) {
-        settings.throttlingMethod = 'simulate';
-    }
-    const data = await runTraceProcessor(context, trace);
-    const requests = Trace.LanternComputationData.createNetworkRequests(trace, data);
-    const networkAnalysis = Lantern.Core.NetworkAnalyzer.analyze(requests);
-    if (!networkAnalysis) {
-        throw new Error('no networkAnalysis');
-    }
-    const frameId = data.Meta.mainFrameId;
-    const navigationId = data.Meta.mainFrameNavigations[0].args.data?.navigationId;
-    if (!navigationId) {
-        throw new Error('no navigation id found');
-    }
-    return {
-        simulator: Lantern.Simulation.Simulator.createSimulator({ ...settings, networkAnalysis }),
-        graph: Trace.LanternComputationData.createGraph(requests, trace, data, url),
-        processedNavigation: Trace.LanternComputationData.createProcessedNavigation(data, frameId, navigationId),
-    };
-}
-export { getComputationDataFromFixture, runTraceProcessor as runTrace, toLanternTrace, };

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/lantern/testing/testing.js

@@ -1,4 +0,0 @@
-// Copyright 2024 The Chromium Authors
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-export * from './MetricTestUtils.js';

package/build/src/profile-manager.js

@@ -1,150 +0,0 @@
-/**
- * Profile Manager for Chrome DevTools MCP
- *
- * This module manages dedicated Chrome profiles that use symlinks to share
- * Extensions and Bookmarks from the system Chrome profile while maintaining
- * isolated Cookies, Login Data, and Preferences.
- */
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-/**
- * Detect system Chrome profile for a specific channel
- */
-function detectSystemChromeProfile(channel) {
-    const home = os.homedir();
-    const chromePaths = {
-        stable: path.join(home, 'Library/Application Support/Google/Chrome'),
-        beta: path.join(home, 'Library/Application Support/Google/Chrome Beta'),
-        canary: path.join(home, 'Library/Application Support/Google/Chrome Canary'),
-        dev: path.join(home, 'Library/Application Support/Google/Chrome Dev'),
-    };
-    const targetChannel = channel || 'stable';
-    const chromePath = chromePaths[targetChannel];
-    if (chromePath && fs.existsSync(chromePath)) {
-        return { path: chromePath, channel: targetChannel };
-    }
-    return null;
-}
-/**
- * Detect any available system Chrome profile
- */
-function detectAnySystemChromeProfile() {
-    const channels = ['stable', 'beta', 'dev', 'canary'];
-    for (const channel of channels) {
-        const profile = detectSystemChromeProfile(channel);
-        if (profile) {
-            return profile;
-        }
-    }
-    return null;
-}
-/**
- * Get the last used profile directory name from Local State
- */
-function getLastUsedProfile(userDataDir) {
-    const localStatePath = path.join(userDataDir, 'Local State');
-    try {
-        const localStateContent = fs.readFileSync(localStatePath, 'utf-8');
-        const localState = JSON.parse(localStateContent);
-        const lastUsed = localState?.profile?.last_used;
-        if (lastUsed && typeof lastUsed === 'string') {
-            return lastUsed;
-        }
-    }
-    catch (error) {
-        // Ignore errors, will use default
-    }
-    return 'Default';
-}
-/**
- * Create or update a symlink safely
- *
- * @param target - The target path that the symlink should point to
- * @param linkPath - The path where the symlink should be created
- */
-function createSymlinkSafe(target, linkPath) {
-    // Check if target exists
-    if (!fs.existsSync(target)) {
-        console.error(`⚠️  Symlink target does not exist: ${target}`);
-        return;
-    }
-    // If link already exists and points to the correct target, skip
-    if (fs.existsSync(linkPath)) {
-        try {
-            const currentTarget = fs.readlinkSync(linkPath);
-            if (currentTarget === target) {
-                // Already correctly linked
-                return;
-            }
-            // Remove old symlink
-            fs.unlinkSync(linkPath);
-        }
-        catch (error) {
-            // Not a symlink, remove the file/directory
-            if (fs.lstatSync(linkPath).isDirectory()) {
-                fs.rmSync(linkPath, { recursive: true, force: true });
-            }
-            else {
-                fs.unlinkSync(linkPath);
-            }
-        }
-    }
-    // Create new symlink
-    fs.symlinkSync(target, linkPath, 'dir');
-    console.error(`🔗 Created symlink: ${path.basename(linkPath)} -> ${target}`);
-}
-/**
- * Setup a dedicated Chrome profile with symlinks to system profile
- *
- * This function:
- * 1. Detects the system Chrome profile
- * 2. Creates a dedicated profile directory
- * 3. Creates symlinks for Extensions and Bookmarks
- * 4. Returns the dedicated profile information
- *
- * @param channel - Chrome channel to use (stable, beta, canary, dev)
- * @returns Dedicated profile information
- */
-export async function setupDedicatedProfile(channel) {
-    // Detect system Chrome profile
-    const systemProfile = detectSystemChromeProfile(channel) || detectAnySystemChromeProfile();
-    if (!systemProfile) {
-        throw new Error('No system Chrome profile found. Please install Chrome and run it at least once.');
-    }
-    // Get the last used profile directory
-    const profileDirectory = getLastUsedProfile(systemProfile.path);
-    const systemProfileDir = path.join(systemProfile.path, profileDirectory);
-    // Create dedicated profile directory
-    const dedicatedUserDataDir = path.join(os.homedir(), '.cache', 'chrome-devtools-mcp', 'chrome-profile-dedicated');
-    await fs.promises.mkdir(dedicatedUserDataDir, { recursive: true });
-    const dedicatedProfileDir = path.join(dedicatedUserDataDir, profileDirectory);
-    await fs.promises.mkdir(dedicatedProfileDir, { recursive: true });
-    console.error('📁 Dedicated Profile Setup:');
-    console.error(`   System Profile: ${systemProfileDir}`);
-    console.error(`   Dedicated Profile: ${dedicatedProfileDir}`);
-    console.error(`   Profile Directory: ${profileDirectory}`);
-    // Create symlinks for shared resources
-    const symlinkTargets = [
-        { name: 'Extensions', required: false },
-        { name: 'Bookmarks', required: false },
-    ];
-    for (const { name, required } of symlinkTargets) {
-        const targetPath = path.join(systemProfileDir, name);
-        const linkPath = path.join(dedicatedProfileDir, name);
-        if (fs.existsSync(targetPath)) {
-            createSymlinkSafe(targetPath, linkPath);
-        }
-        else if (required) {
-            console.error(`⚠️  Required item not found: ${name}`);
-        }
-    }
-    console.error('✅ Dedicated profile setup complete');
-    console.error('   First launch will require Google login (login state is not shared)');
-    return {
-        userDataDir: dedicatedUserDataDir,
-        profileDirectory,
-        systemProfilePath: systemProfileDir,
-        channel: systemProfile.channel,
-    };
-}

package/build/src/tools/dom-utils.js

@@ -1,182 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * Wait for DOM changes to settle using MutationObserver.
- * This is more reliable than polling for streaming AI responses.
- *
- * Based on Gemini's recommendation:
- * - Use MutationObserver to detect when DOM stops changing
- * - Consider generation complete when no changes for `silenceDuration` ms
- * - Combine with additional checks (e.g., stop button disappearance)
- */
-export async function waitForDomSilence(page, options = {}) {
-    const { silenceDuration = 2000, timeout = 300000, observeSelector = 'body', additionalCheck, } = options;
-    return page.evaluate(({ silenceDuration, timeout, observeSelector, additionalCheck }) => {
-        return new Promise((resolve) => {
-            const target = document.querySelector(observeSelector);
-            if (!target) {
-                resolve({ completed: false });
-                return;
-            }
-            let silenceTimeout;
-            let overallTimeout;
-            const observer = new MutationObserver(() => {
-                // Reset silence timer on any DOM change
-                clearTimeout(silenceTimeout);
-                silenceTimeout = setTimeout(() => {
-                    // DOM has been silent for silenceDuration
-                    // Run additional check if provided
-                    if (additionalCheck) {
-                        try {
-                            const checkFn = new Function('return (' + additionalCheck + ')()');
-                            if (!checkFn()) {
-                                // Additional check failed, keep waiting
-                                return;
-                            }
-                        }
-                        catch {
-                            // Check failed, consider complete anyway
-                        }
-                    }
-                    cleanup();
-                    resolve({ completed: true });
-                }, silenceDuration);
-            });
-            const cleanup = () => {
-                clearTimeout(silenceTimeout);
-                clearTimeout(overallTimeout);
-                observer.disconnect();
-            };
-            // Start overall timeout
-            overallTimeout = setTimeout(() => {
-                cleanup();
-                resolve({ completed: false, timedOut: true });
-            }, timeout);
-            // Start observing
-            observer.observe(target, {
-                childList: true,
-                subtree: true,
-                characterData: true,
-                attributes: true,
-            });
-            // Initial silence timer
-            silenceTimeout = setTimeout(() => {
-                if (additionalCheck) {
-                    try {
-                        const checkFn = new Function('return (' + additionalCheck + ')()');
-                        if (!checkFn()) {
-                            return;
-                        }
-                    }
-                    catch {
-                        // Check failed
-                    }
-                }
-                cleanup();
-                resolve({ completed: true });
-            }, silenceDuration);
-        });
-    }, { silenceDuration, timeout, observeSelector, additionalCheck });
-}
-/**
- * Multi-fallback selector strategy.
- * Try multiple selectors in order of preference until one matches.
- */
-export async function findElementWithFallback(page, selectors, options = {}) {
-    const { timeout = 5000 } = options;
-    for (const selector of selectors) {
-        try {
-            const element = await page.waitForSelector(selector, {
-                timeout: Math.min(1000, timeout / selectors.length),
-                visible: options.visible,
-            });
-            if (element) {
-                return { found: true, selector };
-            }
-        }
-        catch {
-            // Continue to next selector
-        }
-    }
-    return { found: false };
-}
-/**
- * Combined completion detection for ChatGPT/Gemini.
- * Uses MutationObserver + stop button check for robust detection.
- */
-export async function waitForAIResponseComplete(page, options = {}) {
-    const { stopSelectors = [], completeSelectors = [], responseSelector = 'body', silenceDuration = 2000, timeout = 300000, } = options;
-    const startTime = Date.now();
-    // Build additional check function as string (to be evaluated in browser)
-    const additionalCheckFn = `
-    function() {
-      // Check if still generating (stop button visible)
-      const stopSelectors = ${JSON.stringify(stopSelectors)};
-      for (const sel of stopSelectors) {
-        if (document.querySelector(sel)) {
-          return false; // Still generating
-        }
-      }
-
-      // Check for completion indicators
-      const completeSelectors = ${JSON.stringify(completeSelectors)};
-      if (completeSelectors.length > 0) {
-        for (const sel of completeSelectors) {
-          if (document.querySelector(sel)) {
-            return true; // Explicitly complete
-          }
-        }
-      }
-
-      return true; // No stop button, consider complete
-    }
-  `;
-    const result = await waitForDomSilence(page, {
-        silenceDuration,
-        timeout,
-        observeSelector: responseSelector,
-        additionalCheck: additionalCheckFn,
-    });
-    // Get final response text
-    let responseText = '';
-    if (result.completed) {
-        responseText = await page.evaluate((selector) => {
-            const el = document.querySelector(selector);
-            return el?.textContent || '';
-        }, responseSelector);
-    }
-    return {
-        completed: result.completed,
-        timedOut: result.timedOut,
-        responseText,
-    };
-}
-/**
- * Type text using clipboard injection for faster input.
- * Much faster than page.type() for long text.
- */
-export async function typeViaClipboard(page, text, targetSelector) {
-    try {
-        // Focus the target element
-        await page.click(targetSelector);
-        // Use clipboard to paste text (faster than typing)
-        await page.evaluate(async (text) => {
-            // Write to clipboard
-            await navigator.clipboard.writeText(text);
-        }, text);
-        // Paste using keyboard shortcut
-        const isMac = (await page.evaluate(() => navigator.platform.includes('Mac'))) || false;
-        const modifier = isMac ? 'Meta' : 'Control';
-        await page.keyboard.down(modifier);
-        await page.keyboard.press('KeyV');
-        await page.keyboard.up(modifier);
-        return true;
-    }
-    catch {
-        // Fallback to regular typing if clipboard fails
-        return false;
-    }
-}