browser-use 0.4.0 → 0.5.0

package/dist/browser/profile.js

@@ -360,10 +360,17 @@ const DEFAULT_BROWSER_PROFILE_OPTIONS = {
     profile_directory: 'Default',
     cookies_file: null,
 };
+const splitArgOnce = (arg) => {
+    const separatorIndex = arg.indexOf('=');
+    if (separatorIndex === -1) {
+        return [arg, ''];
+    }
+    return [arg.slice(0, separatorIndex), arg.slice(separatorIndex + 1)];
+};
 const argsAsDict = (args) => {
     const result = {};
     for (const arg of args) {
-        const [keyPart, valuePart = ''] = arg.split('=', 1);
+        const [keyPart, valuePart = ''] = splitArgOnce(arg);
         const key = keyPart.trim().replace(/^-+/, '');
         result[key] = valuePart.trim();
     }
@@ -376,9 +383,22 @@ const cloneDefaultOptions = () => JSON.parse(JSON.stringify(DEFAULT_BROWSER_PROF
 const normalizeDomainEntry = (entry) => String(entry ?? '')
     .trim()
     .toLowerCase();
+const isExactHostDomainEntry = (entry) => {
+    if (!entry) {
+        return false;
+    }
+    if (entry.includes('*') || entry.includes('://') || entry.includes('/')) {
+        return false;
+    }
+    // Keep set optimization for plain hostnames only. Entries with ports/pattern-like
+    // delimiters must stay as arrays to preserve wildcard/scheme matching semantics.
+    return !entry.includes(':');
+};
 const optimizeDomainList = (value) => {
     const cleaned = value.map(normalizeDomainEntry).filter(Boolean);
-    if (cleaned.length >= DOMAIN_OPTIMIZATION_THRESHOLD) {
+    const canOptimizeToSet = cleaned.length >= DOMAIN_OPTIMIZATION_THRESHOLD &&
+        cleaned.every(isExactHostDomainEntry);
+    if (canOptimizeToSet) {
         logger.warning(`Optimizing domain list with ${cleaned.length} entries to a Set for O(1) matching`);
         return new Set(cleaned);
     }
@@ -407,16 +427,12 @@ export class BrowserProfile {
             allowed_domains: Array.isArray(init.allowed_domains)
                 ? optimizeDomainList(init.allowed_domains)
                 : init.allowed_domains instanceof Set
-                    ? new Set(Array.from(init.allowed_domains)
-                        .map(normalizeDomainEntry)
-                        .filter(Boolean))
+                    ? optimizeDomainList(Array.from(init.allowed_domains))
                     : defaults.allowed_domains,
             prohibited_domains: Array.isArray(init.prohibited_domains)
                 ? optimizeDomainList(init.prohibited_domains)
                 : init.prohibited_domains instanceof Set
-                    ? new Set(Array.from(init.prohibited_domains)
-                        .map(normalizeDomainEntry)
-                        .filter(Boolean))
+                    ? optimizeDomainList(Array.from(init.prohibited_domains))
                     : defaults.prohibited_domains,
             window_position: init.window_position ?? defaults.window_position,
         };

package/dist/browser/session.d.ts

@@ -96,6 +96,8 @@ export declare class BrowserSession {
     get_or_create_cdp_session(page?: Page | null): Promise<any>;
     private _waitForStableNetwork;
     private _setActivePage;
+    private _syncCurrentTabFromPage;
+    private _syncTabsWithBrowserPages;
     private _captureClosedPopupMessage;
     private _getClosedPopupMessagesSnapshot;
     private _recordRecentEvent;
@@ -327,6 +329,7 @@ export declare class BrowserSession {
     private _is_new_tab_page;
     private _is_ip_address_host;
     private _get_domain_variants;
+    private _setEntryMatchesUrl;
     /**
      * Check if page is displaying a PDF
      */

package/dist/browser/session.js

@@ -400,6 +400,117 @@ export class BrowserSession {
         this._attachDialogHandler(page);
         this.agent_current_page = page ?? null;
     }
+    async _syncCurrentTabFromPage(page) {
+        if (!page) {
+            return;
+        }
+        let resolvedUrl = null;
+        try {
+            const rawUrl = page.url();
+            if (typeof rawUrl === 'string' && rawUrl.trim()) {
+                resolvedUrl = normalize_url(rawUrl);
+                this.currentUrl = resolvedUrl;
+            }
+        }
+        catch {
+            // Ignore transient URL read failures.
+        }
+        let resolvedTitle = null;
+        if (typeof page.title === 'function') {
+            try {
+                const title = await page.title();
+                if (typeof title === 'string' && title.trim()) {
+                    resolvedTitle = title;
+                }
+            }
+            catch {
+                // Ignore transient title read failures.
+            }
+        }
+        if (!resolvedTitle) {
+            resolvedTitle = resolvedUrl ?? this.currentTitle ?? this.currentUrl;
+        }
+        this.currentTitle = resolvedTitle;
+        const currentTab = this._tabs[this.currentTabIndex];
+        if (currentTab) {
+            if (resolvedUrl) {
+                currentTab.url = resolvedUrl;
+            }
+            currentTab.title = resolvedTitle;
+            this._syncSessionManagerFromTabs();
+        }
+    }
+    _syncTabsWithBrowserPages() {
+        const pages = this.browser_context?.pages?.() ?? [];
+        if (!pages.length) {
+            return;
+        }
+        const nextTabs = [];
+        const nextTabPages = new Map();
+        const usedPageIds = new Set();
+        const knownPageMappings = Array.from(this.tabPages.entries());
+        for (const page of pages) {
+            this._attachDialogHandler(page ?? null);
+            let pageId = null;
+            for (const [candidateId, candidatePage] of knownPageMappings) {
+                if (candidatePage === page && !usedPageIds.has(candidateId)) {
+                    pageId = candidateId;
+                    break;
+                }
+            }
+            if (pageId === null) {
+                pageId = this._tabCounter++;
+            }
+            usedPageIds.add(pageId);
+            const existingTab = this._tabs.find((tab) => tab.page_id === pageId);
+            const tab = existingTab
+                ? { ...existingTab }
+                : this._createTabInfo({
+                    page_id: pageId,
+                    url: 'about:blank',
+                    title: 'about:blank',
+                });
+            try {
+                const rawUrl = page.url();
+                if (typeof rawUrl === 'string' && rawUrl.trim()) {
+                    tab.url = normalize_url(rawUrl);
+                }
+            }
+            catch {
+                // Keep existing tab url when page url is not readable.
+            }
+            if (!existingTab || !tab.title || tab.title === 'about:blank') {
+                tab.title = tab.url;
+            }
+            nextTabs.push(tab);
+            nextTabPages.set(pageId, page);
+        }
+        if (!nextTabs.length) {
+            return;
+        }
+        this._tabs = nextTabs;
+        this.tabPages = nextTabPages;
+        const activePage = this.agent_current_page && pages.includes(this.agent_current_page)
+            ? this.agent_current_page
+            : pages[0] ?? null;
+        if (activePage) {
+            const activeIndex = this._tabs.findIndex((tab) => this.tabPages.get(tab.page_id) === activePage);
+            if (activeIndex !== -1) {
+                this.currentTabIndex = activeIndex;
+            }
+        }
+        if (this.currentTabIndex < 0 || this.currentTabIndex >= this._tabs.length) {
+            this.currentTabIndex = Math.max(0, this._tabs.length - 1);
+        }
+        const activeTab = this._tabs[this.currentTabIndex] ?? null;
+        if (activeTab) {
+            this.currentUrl = activeTab.url;
+            this.currentTitle = activeTab.title || activeTab.url;
+            this.agent_current_page = this.tabPages.get(activeTab.page_id) ?? null;
+            this.human_current_page = this.human_current_page ?? this.agent_current_page;
+        }
+        this._syncSessionManagerFromTabs();
+    }
     _captureClosedPopupMessage(dialogType, message) {
         const normalizedType = String(dialogType || 'alert').trim() || 'alert';
         const normalizedMessage = String(message || '').trim();
@@ -1101,7 +1212,7 @@ export class BrowserSession {
         else {
             try {
                 const domService = new DomService(page, this.logger);
-                domState = await this._withAbort(domService.get_clickable_elements(), signal);
+                domState = await this._withAbort(domService.get_clickable_elements(this.browser_profile.highlight_elements, -1, this.browser_profile.viewport_expansion), signal);
             }
             catch (error) {
                 if (this._isAbortError(error)) {
@@ -1176,6 +1287,9 @@ export class BrowserSession {
             }
         }
         const pendingNetworkRequests = await this._getPendingNetworkRequests(page);
+        if (page) {
+            await this._syncCurrentTabFromPage(page);
+        }
         if (pageInfo &&
             Number.isFinite(pageInfo.viewport_width) &&
             Number.isFinite(pageInfo.viewport_height)) {
@@ -1225,6 +1339,7 @@ export class BrowserSession {
         return summary;
     }
     async get_current_page() {
+        this._syncTabsWithBrowserPages();
         if (this.agent_current_page) {
             return this.agent_current_page;
         }
@@ -1275,6 +1390,7 @@ export class BrowserSession {
         this._throwIfAborted(signal);
         this._assert_url_allowed(url);
         const normalized = normalize_url(url);
+        let completedUrl = normalized;
         const waitUntil = options.wait_until ?? 'domcontentloaded';
         const timeoutMs = typeof options.timeout_ms === 'number' &&
             Number.isFinite(options.timeout_ms)
@@ -1294,6 +1410,7 @@ export class BrowserSession {
                 await this._withAbort(page.goto(normalized, gotoOptions), signal);
                 const finalUrl = page.url();
                 this._assert_url_allowed(finalUrl);
+                completedUrl = normalize_url(finalUrl);
                 await this._waitForStableNetwork(page, signal);
             }
             catch (error) {
@@ -1309,16 +1426,24 @@ export class BrowserSession {
             }
         }
         this._throwIfAborted(signal);
-        this.currentUrl = normalized;
-        this.currentTitle = normalized;
-        this.historyStack.push(normalized);
-        if (this._tabs[this.currentTabIndex]) {
-            this._tabs[this.currentTabIndex].url = normalized;
-            this._tabs[this.currentTabIndex].title = normalized;
+        if (page) {
+            await this._syncCurrentTabFromPage(page);
+            completedUrl = this.currentUrl || completedUrl;
+        }
+        else {
+            this.currentUrl = normalized;
+            this.currentTitle = normalized;
+            if (this._tabs[this.currentTabIndex]) {
+                this._tabs[this.currentTabIndex].url = normalized;
+                this._tabs[this.currentTabIndex].title = normalized;
+            }
+            this._syncSessionManagerFromTabs();
+        }
+        if (this.historyStack[this.historyStack.length - 1] !== completedUrl) {
+            this.historyStack.push(completedUrl);
         }
-        this._syncSessionManagerFromTabs();
         this._setActivePage(page ?? null);
-        this._recordRecentEvent('navigation_completed', { url: normalized });
+        this._recordRecentEvent('navigation_completed', { url: completedUrl });
         this.cachedBrowserState = null;
         return this.agent_current_page;
     }
@@ -1327,11 +1452,14 @@ export class BrowserSession {
         this._throwIfAborted(signal);
         this._assert_url_allowed(url);
         const normalized = normalize_url(url);
+        let completedUrl = normalized;
         const waitUntil = options.wait_until ?? 'domcontentloaded';
         const timeoutMs = typeof options.timeout_ms === 'number' &&
             Number.isFinite(options.timeout_ms)
             ? Math.max(0, options.timeout_ms)
             : null;
+        const previousTabIndex = this.currentTabIndex;
+        const previousTab = this._tabs[this.currentTabIndex] ?? null;
         const newTab = this._createTabInfo({
             page_id: this._tabCounter++,
             url: normalized,
@@ -1342,11 +1470,6 @@ export class BrowserSession {
         this.currentUrl = normalized;
         this.currentTitle = normalized;
         this.historyStack.push(normalized);
-        this._recordRecentEvent('tab_created', {
-            url: normalized,
-            page_id: newTab.page_id,
-            tab_id: newTab.tab_id,
-        });
         let page = null;
         try {
             page =
@@ -1362,6 +1485,7 @@ export class BrowserSession {
                 await this._withAbort(page.goto(normalized, gotoOptions), signal);
                 const finalUrl = page.url();
                 this._assert_url_allowed(finalUrl);
+                completedUrl = normalize_url(finalUrl);
                 await this._waitForStableNetwork(page, signal);
             }
         }
@@ -1369,29 +1493,82 @@ export class BrowserSession {
             if (this._isAbortError(error)) {
                 throw error;
             }
+            const message = error.message ?? 'Failed to open new tab';
             this._recordRecentEvent('tab_navigation_failed', {
                 url: normalized,
                 page_id: newTab.page_id,
                 tab_id: newTab.tab_id,
-                error_message: error.message ?? 'Failed to open new tab',
+                error_message: message,
             });
-            this.logger.debug(`Failed to open new tab via Playwright: ${error.message}`);
+            this.logger.debug(`Failed to open new tab via Playwright: ${message}`);
+            if (page?.close) {
+                try {
+                    await page.close();
+                }
+                catch {
+                    // Ignore best-effort tab close failures during rollback.
+                }
+            }
+            this._tabs = this._tabs.filter((tab) => tab.page_id !== newTab.page_id);
+            this.tabPages.delete(newTab.page_id);
+            if (this.historyStack[this.historyStack.length - 1] === normalized) {
+                this.historyStack.pop();
+            }
+            if (this._tabs.length > 0) {
+                let restoredIndex = previousTab
+                    ? this._tabs.findIndex((tab) => tab.page_id === previousTab.page_id)
+                    : -1;
+                if (restoredIndex === -1) {
+                    restoredIndex = Math.min(previousTabIndex, this._tabs.length - 1);
+                }
+                this.currentTabIndex = Math.max(0, restoredIndex);
+                const restoredTab = this._tabs[this.currentTabIndex];
+                this.currentUrl = restoredTab.url;
+                this.currentTitle = restoredTab.title;
+                const restoredPage = this.tabPages.get(restoredTab.page_id) ?? null;
+                this._setActivePage(restoredPage);
+                await this._syncCurrentTabFromPage(restoredPage);
+            }
+            else {
+                this.currentTabIndex = 0;
+                this.currentUrl = 'about:blank';
+                this.currentTitle = 'about:blank';
+                this._setActivePage(null);
+            }
+            this._syncSessionManagerFromTabs();
+            this.cachedBrowserState = null;
+            throw new BrowserError(message);
         }
         this.tabPages.set(newTab.page_id, page);
         this._syncSessionManagerFromTabs();
         this._setActivePage(page);
+        if (page) {
+            await this._syncCurrentTabFromPage(page);
+            completedUrl = this.currentUrl || completedUrl;
+        }
+        if (this.historyStack[this.historyStack.length - 1] === normalized) {
+            this.historyStack[this.historyStack.length - 1] = completedUrl;
+        }
+        else if (this.historyStack[this.historyStack.length - 1] !== completedUrl) {
+            this.historyStack.push(completedUrl);
+        }
         this.currentPageLoadingStatus = null;
         if (!this.human_current_page) {
             this.human_current_page = page;
         }
+        this._recordRecentEvent('tab_created', {
+            url: completedUrl,
+            page_id: newTab.page_id,
+            tab_id: newTab.tab_id,
+        });
         this._recordRecentEvent('tab_ready', {
-            url: normalized,
+            url: completedUrl,
             page_id: newTab.page_id,
             tab_id: newTab.tab_id,
         });
         await this.event_bus.dispatch(new TabCreatedEvent({
             target_id: newTab.target_id ?? newTab.tab_id ?? 'unknown_target',
-            url: normalized,
+            url: completedUrl,
         }));
         this.cachedBrowserState = null;
         return this.agent_current_page;
@@ -1434,6 +1611,7 @@ export class BrowserSession {
     async switch_to_tab(identifier, options = {}) {
         const signal = options.signal ?? null;
         this._throwIfAborted(signal);
+        this._syncTabsWithBrowserPages();
         const index = this._resolveTabIndex(identifier);
         const tab = index >= 0 ? (this._tabs[index] ?? null) : null;
         if (!tab) {
@@ -1473,6 +1651,7 @@ export class BrowserSession {
         return page;
     }
     async close_tab(identifier) {
+        this._syncTabsWithBrowserPages();
         const index = this._resolveTabIndex(identifier);
         if (index < 0 || index >= this._tabs.length) {
             throw new Error(`Tab '${identifier}' does not exist`);
@@ -1887,31 +2066,34 @@ export class BrowserSession {
     async go_back(options = {}) {
         const signal = options.signal ?? null;
         this._throwIfAborted(signal);
-        if (this.historyStack.length <= 1) {
+        const page = await this._withAbort(this.get_current_page(), signal);
+        if (!page?.goBack) {
             return;
         }
-        const page = await this._withAbort(this.get_current_page(), signal);
-        if (page?.goBack) {
-            try {
-                await this._withAbort(page.goBack(), signal);
-            }
-            catch (error) {
-                if (this._isAbortError(error)) {
-                    throw error;
-                }
-                this.logger.debug(`Failed to navigate back: ${error.message}`);
+        const previousUrl = this.currentUrl;
+        try {
+            await this._withAbort(page.goBack(), signal);
+        }
+        catch (error) {
+            if (this._isAbortError(error)) {
+                throw error;
             }
+            this.logger.debug(`Failed to navigate back: ${error.message}`);
         }
         this._throwIfAborted(signal);
-        this.historyStack.pop();
-        const previous = this.historyStack[this.historyStack.length - 1];
-        this.currentUrl = previous;
-        this.currentTitle = previous;
-        if (this._tabs[this.currentTabIndex]) {
-            this._tabs[this.currentTabIndex].url = previous;
-            this._tabs[this.currentTabIndex].title = previous;
+        await this._syncCurrentTabFromPage(page);
+        const currentUrl = this.currentUrl;
+        if (currentUrl && currentUrl !== previousUrl) {
+            const existingIndex = this.historyStack.lastIndexOf(currentUrl);
+            if (existingIndex !== -1) {
+                this.historyStack = this.historyStack.slice(0, existingIndex + 1);
+            }
+            else if (this.historyStack[this.historyStack.length - 1] !== currentUrl) {
+                this.historyStack.push(currentUrl);
+            }
         }
-        this._recordRecentEvent('navigation_back', { url: previous });
+        this.cachedBrowserState = null;
+        this._recordRecentEvent('navigation_back', { url: currentUrl });
     }
     async get_dom_element_by_index(_index, options = {}) {
         const selectorMap = await this.get_selector_map(options);
@@ -2123,6 +2305,13 @@ export class BrowserSession {
             await performClick();
         }
         await this._waitForLoad(page, 5000, signal);
+        if (page) {
+            await this._syncCurrentTabFromPage(page);
+            if (this.historyStack[this.historyStack.length - 1] !== this.currentUrl) {
+                this.historyStack.push(this.currentUrl);
+            }
+        }
+        this.cachedBrowserState = null;
         return null;
     }
     async _waitForLoad(page, timeout = 5000, signal = null) {
@@ -2471,7 +2660,7 @@ export class BrowserSession {
             cdp_session = await this.get_or_create_cdp_session(page);
             // Capture screenshot via CDP
             const screenshot_response = await cdp_session.send('Page.captureScreenshot', {
-                captureBeyondViewport: false,
+                captureBeyondViewport: full_page,
                 fromSurface: true,
                 format: 'png',
             });
@@ -2548,22 +2737,33 @@ export class BrowserSession {
         if (!this.browser_context) {
             return [];
         }
+        this._syncTabsWithBrowserPages();
         const tabs_info = [];
-        const pages = this.browser_context.pages();
-        for (let page_id = 0; page_id < pages.length; page_id++) {
-            const page = pages[page_id];
-            const tab_id = this._tabs.find((tab) => tab.page_id === page_id)?.tab_id ??
-                this._formatTabId(page_id);
-            this._attachDialogHandler(page ?? null);
+        for (const tab of this._tabs) {
+            const page_id = tab.page_id;
+            const page = this.tabPages.get(page_id) ?? null;
+            const tab_id = tab.tab_id || this._formatTabId(page_id);
+            if (!tab.tab_id) {
+                tab.tab_id = tab_id;
+            }
+            this._attachDialogHandler(page);
+            let currentUrl = tab.url;
+            if (page?.url) {
+                try {
+                    currentUrl = normalize_url(page.url());
+                }
+                catch {
+                    // Keep tab url fallback when page url is unavailable.
+                }
+            }
             // Skip chrome:// pages and new tab pages
-            const isNewTab = page.url() === 'about:blank' ||
-                page.url().startsWith('chrome://newtab');
-            if (isNewTab || page.url().startsWith('chrome://')) {
+            const isNewTab = currentUrl === 'about:blank' || currentUrl.startsWith('chrome://newtab');
+            if (isNewTab || currentUrl.startsWith('chrome://')) {
                 if (isNewTab) {
                     tabs_info.push({
                         page_id,
                         tab_id,
-                        url: page.url(),
+                        url: currentUrl,
                         title: 'ignore this tab and do not use it',
                     });
                 }
@@ -2571,28 +2771,31 @@ export class BrowserSession {
                     tabs_info.push({
                         page_id,
                         tab_id,
-                        url: page.url(),
-                        title: page.url(),
+                        url: currentUrl,
+                        title: currentUrl,
                     });
                 }
                 continue;
             }
             // Normal pages - try to get title with timeout
             try {
+                if (!page?.title) {
+                    throw new Error('page_title_unavailable');
+                }
                 const titlePromise = page.title();
                 const timeoutPromise = new Promise((_, reject) => {
                     setTimeout(() => reject(new Error('timeout')), 2000);
                 });
                 const title = await Promise.race([titlePromise, timeoutPromise]);
-                tabs_info.push({ page_id, tab_id, url: page.url(), title });
+                tabs_info.push({ page_id, tab_id, url: currentUrl, title });
             }
             catch (error) {
-                this.logger.debug(`⚠️ Failed to get tab info for tab #${page_id}: ${page.url()} (using fallback title)`);
+                this.logger.debug(`⚠️ Failed to get tab info for tab #${page_id}: ${currentUrl} (using fallback title)`);
                 if (isNewTab) {
                     tabs_info.push({
                         page_id,
                         tab_id,
-                        url: page.url(),
+                        url: currentUrl,
                         title: 'ignore this tab and do not use it',
                     });
                 }
@@ -2600,8 +2803,8 @@ export class BrowserSession {
                     tabs_info.push({
                         page_id,
                         tab_id,
-                        url: page.url(),
-                        title: page.url(), // Use URL as fallback title
+                        url: currentUrl,
+                        title: tab.title || currentUrl,
                     });
                 }
             }
@@ -2966,6 +3169,15 @@ export class BrowserSession {
         }
         return [host, `www.${host}`];
     }
+    _setEntryMatchesUrl(domains, hostVariant, hostAlt, protocol) {
+        const matchedHost = domains.has(hostVariant) || domains.has(hostAlt);
+        if (!matchedHost) {
+            return false;
+        }
+        // Set-optimized entries are exact hostnames without explicit schemes,
+        // so keep parity with pattern matching default: https-only.
+        return protocol.toLowerCase() === 'https:';
+    }
     /**
      * Check if page is displaying a PDF
      */
@@ -3258,7 +3470,7 @@ export class BrowserSession {
             ((Array.isArray(allowedDomains) && allowedDomains.length > 0) ||
                 (allowedDomains instanceof Set && allowedDomains.size > 0))) {
             if (allowedDomains instanceof Set) {
-                if (allowedDomains.has(hostVariant) || allowedDomains.has(hostAlt)) {
+                if (this._setEntryMatchesUrl(allowedDomains, hostVariant, hostAlt, parsed.protocol)) {
                     return null;
                 }
             }
@@ -3281,8 +3493,7 @@ export class BrowserSession {
             ((Array.isArray(prohibitedDomains) && prohibitedDomains.length > 0) ||
                 (prohibitedDomains instanceof Set && prohibitedDomains.size > 0))) {
             if (prohibitedDomains instanceof Set) {
-                if (prohibitedDomains.has(hostVariant) ||
-                    prohibitedDomains.has(hostAlt)) {
+                if (this._setEntryMatchesUrl(prohibitedDomains, hostVariant, hostAlt, parsed.protocol)) {
                     return 'in_prohibited_domains';
                 }
             }
@@ -3405,57 +3616,30 @@ export class BrowserSession {
         // Check if downloads are enabled
         const downloads_path = this.browser_profile.downloads_path;
         if (downloads_path) {
+            fs.mkdirSync(downloads_path, { recursive: true });
+            // Try to detect file download.
+            const download_promise = page.waitForEvent('download', {
+                timeout: 5000,
+            });
+            // Click failures should bubble to the caller.
             try {
-                // Try to detect file download
-                const download_promise = page.waitForEvent('download', {
-                    timeout: 5000,
-                });
-                // Perform the click
                 await element_handle.click();
-                // Wait for download or timeout
-                const download = await download_promise;
-                // Save the downloaded file
-                const suggested_filename = download.suggestedFilename();
-                const unique_filename = await BrowserSession.get_unique_filename(downloads_path, suggested_filename);
-                const download_path = path.join(downloads_path, unique_filename);
-                const download_guid = uuid7str();
-                const download_url = typeof download.url === 'function'
-                    ? download.url()
-                    : (this.currentUrl ?? '');
-                await this.event_bus.dispatch(new DownloadStartedEvent({
-                    guid: download_guid,
-                    url: download_url,
-                    suggested_filename,
-                    auto_download: false,
-                }));
-                await download.saveAs(download_path);
-                this.logger.info(`⬇️ Downloaded file to: ${download_path}`);
-                const stats = fs.existsSync(download_path)
-                    ? fs.statSync(download_path)
-                    : null;
-                await this.event_bus.dispatch(new DownloadProgressEvent({
-                    guid: download_guid,
-                    received_bytes: stats?.size ?? 0,
-                    total_bytes: stats?.size ?? 0,
-                    state: 'completed',
-                }));
-                const fileDownloadedResult = await this.event_bus.dispatch(new FileDownloadedEvent({
-                    guid: download_guid,
-                    url: download_url,
-                    path: download_path,
-                    file_name: unique_filename,
-                    file_size: stats?.size ?? 0,
-                    file_type: path.extname(unique_filename).replace('.', '') || null,
-                    mime_type: null,
-                    auto_download: false,
-                }));
-                if (fileDownloadedResult.handler_results.length === 0) {
-                    this.add_downloaded_file(download_path);
-                }
-                return download_path;
             }
             catch (error) {
-                // No download triggered, treat as normal click
+                void download_promise.catch(() => undefined);
+                throw error;
+            }
+            let download;
+            try {
+                download = await download_promise;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const isDownloadTimeout = error instanceof Error &&
+                    (error.name === 'TimeoutError' || message.toLowerCase().includes('timeout'));
+                if (!isDownloadTimeout) {
+                    throw error;
+                }
                 this.logger.debug('No download triggered within timeout. Checking navigation...');
                 try {
                     await page.waitForLoadState();
@@ -3463,7 +3647,45 @@ export class BrowserSession {
                 catch (e) {
                     this.logger.warning(`Navigation check failed: ${e.message}`);
                 }
+                return null;
+            }
+            // Save the downloaded file.
+            const suggested_filename = download.suggestedFilename();
+            const unique_filename = await BrowserSession.get_unique_filename(downloads_path, suggested_filename);
+            const download_path = path.join(downloads_path, unique_filename);
+            const download_guid = uuid7str();
+            const download_url = typeof download.url === 'function' ? download.url() : (this.currentUrl ?? '');
+            await this.event_bus.dispatch(new DownloadStartedEvent({
+                guid: download_guid,
+                url: download_url,
+                suggested_filename,
+                auto_download: false,
+            }));
+            await download.saveAs(download_path);
+            this.logger.info(`⬇️ Downloaded file to: ${download_path}`);
+            const stats = fs.existsSync(download_path)
+                ? fs.statSync(download_path)
+                : null;
+            await this.event_bus.dispatch(new DownloadProgressEvent({
+                guid: download_guid,
+                received_bytes: stats?.size ?? 0,
+                total_bytes: stats?.size ?? 0,
+                state: 'completed',
+            }));
+            const fileDownloadedResult = await this.event_bus.dispatch(new FileDownloadedEvent({
+                guid: download_guid,
+                url: download_url,
+                path: download_path,
+                file_name: unique_filename,
+                file_size: stats?.size ?? 0,
+                file_type: path.extname(unique_filename).replace('.', '') || null,
+                mime_type: null,
+                auto_download: false,
+            }));
+            if (fileDownloadedResult.handler_results.length === 0) {
+                this.add_downloaded_file(download_path);
             }
+            return download_path;
         }
         else {
             // No downloads path configured, just click
@@ -3481,15 +3703,33 @@ export class BrowserSession {
         }
         try {
             await page.evaluate(() => {
-                // Remove all elements with browser-use highlight class
+                const pageWindow = window;
+                const cleanupFunctions = Array.isArray(pageWindow._highlightCleanupFunctions)
+                    ? pageWindow._highlightCleanupFunctions
+                    : [];
+                for (const cleanupFn of cleanupFunctions) {
+                    try {
+                        if (typeof cleanupFn === 'function') {
+                            cleanupFn();
+                        }
+                    }
+                    catch {
+                        // Ignore callback cleanup failures.
+                    }
+                }
+                pageWindow._highlightCleanupFunctions = [];
+                const containers = document.querySelectorAll('#playwright-highlight-container');
+                containers.forEach((element) => element.remove());
+                const labels = document.querySelectorAll('.playwright-highlight-label');
+                labels.forEach((element) => element.remove());
+                // Backward compatibility with legacy selectors.
                 const highlights = document.querySelectorAll('.browser-use-highlight');
-                highlights.forEach((el) => el.remove());
-                // Remove inline highlight styles
+                highlights.forEach((element) => element.remove());
                 const styled = document.querySelectorAll('[style*="browser-use"]');
-                styled.forEach((el) => {
-                    if (el.style) {
-                        el.style.outline = '';
-                        el.style.border = '';
+                styled.forEach((element) => {
+                    if (element.style) {
+                        element.style.outline = '';
+                        element.style.border = '';
                     }
                 });
             });

package/dist/dom/dom_tree/index.js

@@ -343,17 +343,29 @@
     }
   }
 
-  // // Add this function to perform cleanup when needed
-  // function cleanupHighlights() {
-  //   if (window._highlightCleanupFunctions && window._highlightCleanupFunctions.length) {
-  //     window._highlightCleanupFunctions.forEach(fn => fn());
-  //     window._highlightCleanupFunctions = [];
-  //   }
-
-  //   // Also remove the container
-  //   const container = document.getElementById(HIGHLIGHT_CONTAINER_ID);
-  //   if (container) container.remove();
-  // }
+  function cleanupHighlights() {
+    try {
+      const cleanupFns = Array.isArray(window._highlightCleanupFunctions)
+        ? window._highlightCleanupFunctions
+        : [];
+      for (const fn of cleanupFns) {
+        try {
+          if (typeof fn === 'function') {
+            fn();
+          }
+        } catch (error) {
+          // Ignore cleanup callback failures to keep extraction resilient.
+        }
+      }
+      window._highlightCleanupFunctions = [];
+      const container = document.getElementById(HIGHLIGHT_CONTAINER_ID);
+      if (container) {
+        container.remove();
+      }
+    } catch (error) {
+      // Ignore cleanup failures and continue with DOM extraction.
+    }
+  }
 
   /**
    * Gets the position of an element in its parent.
@@ -1391,6 +1403,7 @@
     return id;
   }
 
+  cleanupHighlights();
   const rootId = buildDomTree(document.body);
 
   // Clear the cache before starting

package/dist/utils.d.ts

@@ -116,7 +116,7 @@ export declare function createSemaphore(maxConcurrent: number): {
     getQueueLength(): number;
 };
 /**
- * Check if a URL is a new tab page (about:blank, chrome://new-tab-page, or chrome://newtab).
+ * Check if a URL is a new tab page (about:blank/about:newtab/chrome://new-tab-page/chrome://newtab).
  */
 export declare function is_new_tab_page(url: string): boolean;
 /**

package/dist/utils.js

@@ -488,10 +488,11 @@ export function createSemaphore(maxConcurrent) {
     };
 }
 /**
- * Check if a URL is a new tab page (about:blank, chrome://new-tab-page, or chrome://newtab).
+ * Check if a URL is a new tab page (about:blank/about:newtab/chrome://new-tab-page/chrome://newtab).
  */
 export function is_new_tab_page(url) {
     return (url === 'about:blank' ||
+        url === 'about:newtab' ||
         url === 'chrome://new-tab-page/' ||
         url === 'chrome://new-tab-page' ||
         url === 'chrome://newtab/' ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-use",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A TypeScript-first library for programmatic browser control, designed for building AI-powered web agents.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",