@machina.ai/cell-cli-core 1.36.0-rc1 → 1.38.1-rc2

package/dist/src/agents/browser/browserManager.js

@@ -26,12 +26,28 @@ import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { injectAutomationOverlay } from './automationOverlay.js';
+import { logBrowserAgentConnection } from '../../telemetry/loggers.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // Default browser profile directory name within ~/.cell-cli/
 const BROWSER_PROFILE_DIR = 'cli-browser-profile';
+/**
+ * Typed error for domain restriction violations.
+ * Thrown when a navigation tool targets a domain not in allowedDomains.
+ * Caught by mcpToolWrapper to terminate the agent immediately.
+ */
+export class DomainNotAllowedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DomainNotAllowedError';
+    }
+}
 // Default timeout for MCP operations
 const MCP_TIMEOUT_MS = 60_000;
+// Maximum reconnection attempts before giving up
+const MAX_RECONNECT_RETRIES = 3;
+// Base delay (ms) for exponential backoff between reconnection attempts
+const RECONNECT_BASE_DELAY_MS = 500;
 /**
  * Tools that can cause a full-page navigation (explicitly or implicitly).
  *
@@ -63,10 +79,138 @@ const POTENTIALLY_NAVIGATING_TOOLS = new Set([
  */
 export class BrowserManager {
     config;
+    // --- Static singleton management ---
+    static instances = new Map();
+    /**
+     * Maximum number of parallel browser instances allowed in isolated mode.
+     * Prevents unbounded resource consumption from concurrent browser_agent calls.
+     */
+    static MAX_PARALLEL_INSTANCES = 5;
+    /**
+     * Returns the cache key for a given config.
+     * Uses `sessionMode:profilePath` so different profiles get separate instances.
+     */
+    static getInstanceKey(config) {
+        const browserConfig = config.getBrowserAgentConfig();
+        const sessionMode = browserConfig.customConfig.sessionMode ?? 'persistent';
+        const profilePath = browserConfig.customConfig.profilePath ?? 'default';
+        return `${sessionMode}:${profilePath}`;
+    }
+    /**
+     * Returns an existing BrowserManager for the current config's session mode
+     * and profile, or creates a new one.
+     *
+     * Concurrency rules:
+     * - **persistent / existing mode**: Only one instance is allowed at a time.
+     *   If the instance is already in-use, an error is thrown instructing the
+     *   caller to run browser tasks sequentially.
+     * - **isolated mode**: Parallel instances are allowed up to
+     *   MAX_PARALLEL_INSTANCES. Each isolated instance gets its own temp profile.
+     */
+    static getInstance(config) {
+        const key = BrowserManager.getInstanceKey(config);
+        const sessionMode = config.getBrowserAgentConfig().customConfig.sessionMode ?? 'persistent';
+        let instance = BrowserManager.instances.get(key);
+        if (!instance) {
+            instance = new BrowserManager(config);
+            BrowserManager.instances.set(key, instance);
+            debugLogger.log(`Created new BrowserManager singleton (key: ${key})`);
+        }
+        else if (instance.inUse) {
+            // Persistent and existing modes share a browser profile directory.
+            // Chrome prevents multiple instances from using the same profile, so
+            // concurrent usage would cause "profile locked" errors.
+            if (sessionMode === 'persistent' || sessionMode === 'existing') {
+                throw new Error(`Cannot launch a concurrent browser agent in "${sessionMode}" session mode. ` +
+                    `The browser instance is already in use by another task. ` +
+                    `Please run browser tasks sequentially, or switch to "isolated" session mode for concurrent browser usage.`);
+            }
+            // Isolated mode: allow parallel instances up to the limit.
+            let inUseCount = 1; // primary is already in-use
+            let suffix = 1;
+            let parallelKey = `${key}:${suffix}`;
+            let parallel = BrowserManager.instances.get(parallelKey);
+            while (parallel?.inUse) {
+                inUseCount++;
+                if (inUseCount >= BrowserManager.MAX_PARALLEL_INSTANCES) {
+                    throw new Error(`Maximum number of parallel browser instances (${BrowserManager.MAX_PARALLEL_INSTANCES}) reached. ` +
+                        `Please wait for an existing browser task to complete before starting a new one.`);
+                }
+                suffix++;
+                parallelKey = `${key}:${suffix}`;
+                parallel = BrowserManager.instances.get(parallelKey);
+            }
+            if (!parallel) {
+                parallel = new BrowserManager(config);
+                BrowserManager.instances.set(parallelKey, parallel);
+                debugLogger.log(`Created parallel BrowserManager (key: ${parallelKey})`);
+            }
+            else {
+                debugLogger.log(`Reusing released parallel BrowserManager (key: ${parallelKey})`);
+            }
+            instance = parallel;
+        }
+        else {
+            debugLogger.log(`Reusing existing BrowserManager singleton (key: ${key})`);
+        }
+        return instance;
+    }
+    /**
+     * Closes all cached BrowserManager instances and clears the cache.
+     * Called on /clear commands and CLI exit.
+     */
+    static async resetAll() {
+        const results = await Promise.allSettled(Array.from(BrowserManager.instances.values()).map((instance) => instance.close()));
+        for (const result of results) {
+            if (result.status === 'rejected') {
+                debugLogger.error(`Error during BrowserManager cleanup: ${result.reason instanceof Error ? result.reason.message : String(result.reason)}`);
+            }
+        }
+        BrowserManager.instances.clear();
+    }
+    /**
+     * Alias for resetAll — used by CLI exit cleanup for clarity.
+     */
+    static async closeAll() {
+        await BrowserManager.resetAll();
+    }
+    // --- Instance state ---
     // Raw MCP SDK Client - NOT the wrapper McpClient
     rawMcpClient;
     mcpTransport;
     discoveredTools = [];
+    disconnected = false;
+    isClosing = false;
+    connectionPromise;
+    /**
+     * Whether this instance is currently acquired by an active invocation.
+     * Used by getInstance() to avoid handing the same browser to concurrent
+     * browser_agent calls.
+     */
+    inUse = false;
+    /**
+     * Marks this instance as in-use. Call this when starting a browser agent
+     * invocation so concurrent calls get a separate instance.
+     */
+    acquire() {
+        this.inUse = true;
+    }
+    /**
+     * Marks this instance as available for reuse. Call this in the finally
+     * block of a browser agent invocation.
+     */
+    release() {
+        this.inUse = false;
+    }
+    /**
+     * Returns whether this instance is currently acquired by an active invocation.
+     */
+    isAcquired() {
+        return this.inUse;
+    }
+    /** State for action rate limiting */
+    actionCounter = 0;
+    maxActionsPerTask;
     /**
      * Whether to inject the automation overlay.
      * Always false in headless mode (no visible window to decorate).
@@ -78,6 +222,8 @@ export class BrowserManager {
         const browserConfig = config.getBrowserAgentConfig();
         this.shouldInjectOverlay = !browserConfig?.customConfig?.headless;
         this.shouldDisableInput = config.shouldDisableBrowserUserInput();
+        this.maxActionsPerTask =
+            browserConfig?.customConfig.maxActionsPerTask ?? 100;
     }
     /**
      * Gets the raw MCP SDK Client for direct tool calls.
@@ -107,23 +253,25 @@ export class BrowserManager {
      * @param toolName The name of the tool to call
      * @param args Arguments to pass to the tool
      * @param signal Optional AbortSignal to cancel the call
+     * @param isInternal Determine if the tool is for internal execution
      * @returns The result from the MCP server
      */
-    async callTool(toolName, args, signal) {
+    async callTool(toolName, args, signal, isInternal = false) {
         if (signal?.aborted) {
             throw signal.reason ?? new Error('Operation cancelled');
         }
+        // Hard enforcement of per-action rate limit
+        if (!isInternal) {
+            if (this.actionCounter >= this.maxActionsPerTask) {
+                const error = new Error(`Browser agent reached maximum action limit (${this.maxActionsPerTask}). ` +
+                    `Task terminated to prevent runaway execution. To config the limit, use maxActionsPerTask in the settings.`);
+                throw error;
+            }
+            this.actionCounter++;
+        }
         const errorMessage = this.checkNavigationRestrictions(toolName, args);
         if (errorMessage) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: errorMessage,
-                    },
-                ],
-                isError: true,
-            };
+            throw new DomainNotAllowedError(errorMessage);
         }
         const client = await this.getRawMcpClient();
         const callPromise = client.callTool({ name: toolName, arguments: args }, undefined, { timeout: MCP_TIMEOUT_MS });
@@ -154,23 +302,23 @@ export class BrowserManager {
         // Re-inject the automation overlay and input blocker after tools that
         // can cause a full-page navigation. chrome-devtools-mcp emits no MCP
         // notifications, so callTool() is the only interception point.
+        //
+        // The input blocker injection is idempotent: the injected function
+        // reuses the existing DOM element when present and only recreates
+        // it when navigation has actually replaced the page DOM.
         if (!result.isError &&
             POTENTIALLY_NAVIGATING_TOOLS.has(toolName) &&
             !signal?.aborted) {
+            // Don't re-inject if explicitly switching to a page in the background
+            if (toolName === 'select_page' && args['bringToFront'] === false) {
+                return result;
+            }
             try {
                 if (this.shouldInjectOverlay) {
                     await injectAutomationOverlay(this, signal);
                 }
-                // Only re-inject the input blocker for tools that *reliably*
-                // replace the page DOM (navigate_page, new_page, select_page).
-                // click/click_at are handled by pointer-events suspend/resume
-                // in mcpToolWrapper — no full re-inject roundtrip needed.
-                // press_key/handle_dialog only sometimes navigate.
-                const reliableNavigation = toolName === 'navigate_page' ||
-                    toolName === 'new_page' ||
-                    toolName === 'select_page';
-                if (this.shouldDisableInput && reliableNavigation) {
-                    await injectInputBlocker(this);
+                if (this.shouldDisableInput) {
+                    await injectInputBlocker(this, signal);
                 }
             }
             catch {
@@ -196,20 +344,67 @@ export class BrowserManager {
             isError: raw.isError === true,
         };
     }
+    /**
+     * Returns whether the MCP client is currently connected and healthy.
+     */
+    isConnected() {
+        return this.rawMcpClient !== undefined && !this.disconnected;
+    }
     /**
      * Ensures browser and MCP client are connected.
+     * If a previous connection was lost (e.g., user closed the browser),
+     * this will reconnect with exponential backoff (up to MAX_RECONNECT_RETRIES).
+     *
+     * Concurrent callers share a single in-flight connection promise so that
+     * two subagents racing at startup do not trigger duplicate connectMcp() calls.
      */
     async ensureConnection() {
-        if (this.rawMcpClient) {
+        // Already connected and healthy — nothing to do
+        if (this.isConnected()) {
             return;
         }
+        // A connection is already being established — wait for it instead of racing
+        if (this.connectionPromise) {
+            return this.connectionPromise;
+        }
+        // If previously connected but transport died, clean up before reconnecting
+        if (this.disconnected) {
+            debugLogger.log('Previous browser connection was lost. Cleaning up before reconnecting...');
+            await this.close();
+            this.disconnected = false;
+        }
+        // Start connecting; store the promise so concurrent callers can join it
+        this.connectionPromise = this.connectWithRetry().finally(() => {
+            this.connectionPromise = undefined;
+        });
+        return this.connectionPromise;
+    }
+    /**
+     * Connects to chrome-devtools-mcp with exponential backoff retry.
+     */
+    async connectWithRetry() {
         // Request browser consent if needed (first-run privacy notice)
         const consentGranted = await getBrowserConsentIfNeeded();
         if (!consentGranted) {
             throw new Error('Browser agent requires user consent to proceed. ' +
                 'Please re-run and accept the privacy notice.');
         }
-        await this.connectMcp();
+        let lastError;
+        for (let attempt = 0; attempt < MAX_RECONNECT_RETRIES; attempt++) {
+            try {
+                await this.connectMcp();
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < MAX_RECONNECT_RETRIES - 1) {
+                    const delay = RECONNECT_BASE_DELAY_MS * Math.pow(2, attempt);
+                    debugLogger.log(`Connection attempt ${attempt + 1} failed, retrying in ${delay}ms...`);
+                    await new Promise((resolve) => setTimeout(resolve, delay));
+                }
+            }
+        }
+        throw lastError;
     }
     /**
      * Closes browser and cleans up connections.
@@ -217,6 +412,7 @@ export class BrowserManager {
      * the transport will terminate the browser.
      */
     async close() {
+        this.isClosing = true;
         // Close MCP client first
         if (this.rawMcpClient) {
             try {
@@ -238,6 +434,7 @@ export class BrowserManager {
             this.mcpTransport = undefined;
         }
         this.discoveredTools = [];
+        this.connectionPromise = undefined;
     }
     /**
      * Connects to chrome-devtools-mcp which manages the browser process.
@@ -250,6 +447,7 @@ export class BrowserManager {
      * BrowserManager instance.
      */
     async connectMcp() {
+        this.isClosing = false;
         debugLogger.log('Connecting isolated MCP client to chrome-devtools-mcp...');
         // Create raw MCP SDK Client (not the wrapper McpClient)
         this.rawMcpClient = new Client({
@@ -260,7 +458,28 @@ export class BrowserManager {
         });
         // Build args for chrome-devtools-mcp
         const browserConfig = this.config.getBrowserAgentConfig();
-        const sessionMode = browserConfig.customConfig.sessionMode ?? 'persistent';
+        const rawSessionMode = browserConfig.customConfig.sessionMode;
+        let sessionMode = rawSessionMode === 'isolated' || rawSessionMode === 'existing'
+            ? rawSessionMode
+            : 'persistent';
+        // Detect sandbox environment.
+        // SANDBOX env var is set to 'sandbox-exec' (seatbelt) or the container
+        // name (Docker/Podman/gVisor/LXC) when running inside a sandbox.
+        // CI uses 'sandbox:none' as a metadata label — not a real sandbox.
+        const sandboxType = process.env['SANDBOX'];
+        const isContainerSandbox = !!sandboxType &&
+            sandboxType !== 'sandbox-exec' &&
+            sandboxType !== 'sandbox:none';
+        const isSeatbeltSandbox = sandboxType === 'sandbox-exec' && sessionMode !== 'existing';
+        // Seatbelt sandbox: force isolated + headless for filesystem compatibility.
+        // Chrome exists on the host, but persistent profiles may conflict with
+        // seatbelt restrictions. Isolated mode uses tmpdir (always writable).
+        if (isSeatbeltSandbox) {
+            if (sessionMode !== 'isolated') {
+                sessionMode = 'isolated';
+                coreEvents.emitFeedback('info', '🔒 Sandbox: Using isolated browser session for compatibility.');
+            }
+        }
         const mcpArgs = ['--experimental-vision'];
         // Session mode determines how the browser is managed:
         // - "isolated": Temp profile, cleaned up after session (--isolated)
@@ -271,13 +490,38 @@ export class BrowserManager {
             mcpArgs.push('--isolated');
         }
         else if (sessionMode === 'existing') {
-            mcpArgs.push('--autoConnect');
-            const message = '🔒 Browsing with your signed-in Chrome profile — cookies and saved logins will be visible to the agent.';
-            coreEvents.emitFeedback('info', message);
-            coreEvents.emitConsoleLog('info', message);
+            if (isContainerSandbox) {
+                // In container sandboxes, --autoConnect can't discover Chrome on the
+                // host (it uses local pipes/sockets). Use --browser-url with the
+                // resolved IP of host.docker.internal instead of the hostname, because
+                // Chrome's DevTools protocol rejects HTTP requests where the Host
+                // header is not 'localhost' or an IP address.
+                const dns = await import('node:dns');
+                let browserHost = 'host.docker.internal';
+                try {
+                    const { address } = await dns.promises.lookup(browserHost);
+                    browserHost = address;
+                }
+                catch {
+                    // Fallback: use hostname as-is if DNS resolution fails
+                    debugLogger.log(`Could not resolve host.docker.internal, using hostname directly`);
+                }
+                const browserUrl = `http://${browserHost}:9222`;
+                mcpArgs.push('--browser-url', browserUrl);
+                coreEvents.emitFeedback('info', `🔒 Container sandbox: Connecting to Chrome via ${browserHost}:9222.`);
+            }
+            else {
+                mcpArgs.push('--autoConnect');
+                const message = '🔒 Browsing with your signed-in Chrome profile — cookies and saved logins will be visible to the agent.';
+                coreEvents.emitFeedback('info', message);
+                coreEvents.emitConsoleLog('info', message);
+            }
         }
-        // Add optional settings from config
-        if (browserConfig.customConfig.headless) {
+        // Add optional settings from config.
+        // Force headless in seatbelt sandbox since Chrome profile/display access
+        // may be restricted, and the user is running in a sandboxed environment.
+        const effectiveHeadless = !!browserConfig.customConfig.headless || isSeatbeltSandbox;
+        if (effectiveHeadless) {
             mcpArgs.push('--headless');
         }
         if (browserConfig.customConfig.profilePath) {
@@ -302,7 +546,7 @@ export class BrowserManager {
                 return `EXCLUDE ${domain}`;
             })
                 .join(', ');
-            mcpArgs.push(`--chromeArg="--host-rules=MAP * 127.0.0.1, ${exclusionRules}, EXCLUDE 127.0.0.1"`);
+            mcpArgs.push(`--chromeArg="--host-rules=MAP * ~NOTFOUND, ${exclusionRules}"`);
         }
         debugLogger.log(`Launching bundled chrome-devtools-mcp (${sessionMode} mode) with args: ${mcpArgs.join(' ')}`);
         // Create stdio transport to the bundled chrome-devtools-mcp.
@@ -327,9 +571,12 @@ export class BrowserManager {
             });
         }
         this.mcpTransport.onclose = () => {
+            this.disconnected = true;
+            if (this.isClosing) {
+                return;
+            }
             debugLogger.error('chrome-devtools-mcp transport closed unexpectedly. ' +
                 'The MCP server process may have crashed.');
-            this.rawMcpClient = undefined;
         };
         this.mcpTransport.onerror = (error) => {
             debugLogger.error(`chrome-devtools-mcp transport error: ${error.message}`);
@@ -338,13 +585,21 @@ export class BrowserManager {
         // since it should connect quickly if remote debugging is enabled.
         const connectTimeoutMs = sessionMode === 'existing' ? 15_000 : MCP_TIMEOUT_MS;
         let timeoutId;
+        const connectStartMs = Date.now();
         try {
             await Promise.race([
                 (async () => {
                     await this.rawMcpClient.connect(this.mcpTransport);
                     debugLogger.log('MCP client connected to chrome-devtools-mcp');
                     await this.discoverTools();
-                    this.registerInputBlockerHandler();
+                    // clear the action counter for each connection
+                    this.actionCounter = 0;
+                    logBrowserAgentConnection(this.config, Date.now() - connectStartMs, {
+                        session_mode: sessionMode,
+                        headless: effectiveHeadless,
+                        success: true,
+                        tool_count: this.discoveredTools.length,
+                    });
                 })(),
                 new Promise((_, reject) => {
                     timeoutId = setTimeout(() => reject(new Error(`Timed out connecting to chrome-devtools-mcp (${connectTimeoutMs}ms)`)), connectTimeoutMs);
@@ -353,8 +608,16 @@ export class BrowserManager {
         }
         catch (error) {
             await this.close();
+            const rawErrorMessage = error instanceof Error ? error.message : String(error);
+            const errorType = BrowserManager.classifyConnectionError(rawErrorMessage);
+            logBrowserAgentConnection(this.config, Date.now() - connectStartMs, {
+                session_mode: sessionMode,
+                headless: effectiveHeadless,
+                success: false,
+                error_type: errorType,
+            });
             // Provide error-specific, session-mode-aware remediation
-            throw this.createConnectionError(error instanceof Error ? error.message : String(error), sessionMode);
+            throw this.createConnectionError(rawErrorMessage, sessionMode);
         }
         finally {
             if (timeoutId !== undefined) {
@@ -362,14 +625,32 @@ export class BrowserManager {
             }
         }
     }
+    /**
+     * Classifies a connection error message into a known error type.
+     * Shared between connectMcp error recording and createConnectionError
+     * to ensure consistent error categorization across the browser agent.
+     */
+    static classifyConnectionError(message) {
+        const lowerMessage = message.toLowerCase();
+        if (lowerMessage.includes('already running')) {
+            return 'profile_locked';
+        }
+        else if (lowerMessage.includes('timed out')) {
+            return 'timeout';
+        }
+        else if (lowerMessage.includes('connection refused')) {
+            return 'connection_refused';
+        }
+        return 'unknown';
+    }
     /**
      * Creates an Error with context-specific remediation based on the actual
      * error message and the current sessionMode.
      */
     createConnectionError(message, sessionMode) {
-        const lowerMessage = message.toLowerCase();
+        const errorType = BrowserManager.classifyConnectionError(message);
         // "already running for the current profile" — persistent mode profile lock
-        if (lowerMessage.includes('already running')) {
+        if (errorType === 'profile_locked') {
             if (sessionMode === 'persistent' || sessionMode === 'isolated') {
                 return new Error(`Could not connect to Chrome: ${message}\n\n` +
                     `The Chrome profile is locked by another running instance.\n` +
@@ -384,7 +665,7 @@ export class BrowserManager {
                 `Close other Chrome instances and try again.`);
         }
         // Timeout errors
-        if (lowerMessage.includes('timed out')) {
+        if (errorType === 'timeout') {
             if (sessionMode === 'existing') {
                 return new Error(`Timed out connecting to Chrome: ${message}\n\n` +
                     `To use sessionMode "existing", you must:\n` +
@@ -446,57 +727,59 @@ export class BrowserManager {
         }
         try {
             const parsedUrl = new URL(url);
-            const urlHostname = parsedUrl.hostname.replace(/\.$/, '');
-            for (const domainPattern of allowedDomains) {
-                if (domainPattern.startsWith('*.')) {
-                    const baseDomain = domainPattern.substring(2);
-                    if (urlHostname === baseDomain ||
-                        urlHostname.endsWith(`.${baseDomain}`)) {
-                        return undefined;
+            const urlHostname = parsedUrl.hostname;
+            if (!this.isDomainAllowed(urlHostname, allowedDomains)) {
+                return 'Domain not allowed: The requested domain is not in the allowed list.';
+            }
+            // Check query parameters for embedded URLs that could bypass domain
+            // restrictions via proxy services (e.g. translate.google.com/translate?u=BLOCKED).
+            const paramsToCheck = [
+                ...parsedUrl.searchParams.values(),
+                // Also check fragments which might contain query-like params
+                ...new URLSearchParams(parsedUrl.hash.replace(/^#/, '')).values(),
+            ];
+            for (const paramValue of paramsToCheck) {
+                try {
+                    const embeddedUrl = new URL(paramValue);
+                    if (embeddedUrl.protocol === 'http:' ||
+                        embeddedUrl.protocol === 'https:') {
+                        const embeddedHostname = embeddedUrl.hostname.replace(/\.$/, '');
+                        if (!this.isDomainAllowed(embeddedHostname, allowedDomains)) {
+                            return 'Domain not allowed: Embedded URL targets a disallowed domain.';
+                        }
                     }
                 }
-                else {
-                    if (urlHostname === domainPattern) {
-                        return undefined;
-                    }
+                catch {
+                    // Not a valid URL, skip.
                 }
             }
+            return undefined;
         }
         catch {
             return `Invalid URL: Malformed URL string.`;
         }
-        // If none matched, then deny
-        return `Tool '${toolName}' is not permitted for the requested URL/domain based on your current browser settings.`;
     }
     /**
-     * Registers a fallback notification handler on the MCP client to
-     * automatically re-inject the input blocker after any server-side
-     * notification (e.g. page navigation, resource updates).
-     *
-     * This covers ALL navigation types (link clicks, form submissions,
-     * history navigation) — not just explicit navigate_page tool calls.
+     * Checks whether a hostname matches any pattern in the allowed domains list.
      */
-    registerInputBlockerHandler() {
-        if (!this.rawMcpClient) {
-            return;
-        }
-        if (!this.config.shouldDisableBrowserUserInput()) {
-            return;
-        }
-        const existingHandler = this.rawMcpClient.fallbackNotificationHandler;
-        this.rawMcpClient.fallbackNotificationHandler = async (notification) => {
-            // Chain with any existing handler first.
-            if (existingHandler) {
-                await existingHandler(notification);
+    isDomainAllowed(hostname, allowedDomains) {
+        const normalized = hostname.replace(/\.$/, '');
+        for (const domainPattern of allowedDomains) {
+            if (domainPattern.startsWith('*.')) {
+                const baseDomain = domainPattern.substring(2);
+                if (normalized === baseDomain ||
+                    normalized.endsWith(`.${baseDomain}`)) {
+                    return true;
+                }
             }
-            // Only re-inject on resource update notifications which indicate
-            // page content has changed (navigation, new page, etc.)
-            if (notification.method === 'notifications/resources/updated') {
-                debugLogger.log('Page content changed, re-injecting input blocker...');
-                void injectInputBlocker(this);
+            else {
+                if (normalized === domainPattern) {
+                    return true;
+                }
             }
-        };
-        debugLogger.log('Registered global notification handler for input blocker re-injection');
+        }
+        // If none matched, then deny
+        return false;
     }
 }
 //# sourceMappingURL=browserManager.js.map