@phuetz/code-buddy 0.3.0 → 1.0.0-rc.8

package/dist/browser-automation/browser-manager.js

@@ -1,7 +1,7 @@
 /**
  * Browser Manager
  *
- * OpenClaw-inspired browser automation using Playwright for CDP control.
+ * Enterprise-grade browser automation using Playwright for CDP control.
  * Provides:
  * - Tab management
  * - Smart Snapshot for element references
@@ -23,11 +23,16 @@ export class BrowserManager extends EventEmitter {
     currentPageId = null;
     currentSnapshot = null;
     nextRef = 1;
+    pendingDialogs = new Map();
+    dialogCounter = 0;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any -- playwright is dynamically imported
     playwright = null;
     // Console history buffer
     consoleBuffer = [];
     static MAX_CONSOLE_ENTRIES = 500;
+    // Mouse position tracking for human-like movement
+    lastMouseX = 0;
+    lastMouseY = 0;
     // Lazy-loaded subsystems
     _routeInterceptor = null;
     _profileManager = null;
@@ -61,8 +66,9 @@ export class BrowserManager extends EventEmitter {
             this.context = await this.browser.newContext({
                 viewport: this.config.viewport,
                 ignoreHTTPSErrors: this.config.ignoreHTTPSErrors,
-                userAgent: this.config.proxy ? undefined : undefined,
+                userAgent: this.config.userAgent || (this.config.headless ? 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36' : undefined),
             });
+            await this.applyStealth(this.context);
             // Set up event listeners
             this.context.on('page', (page) => {
                 const pageId = `page-${Date.now()}`;
@@ -94,14 +100,16 @@ export class BrowserManager extends EventEmitter {
             this.browser = await this.playwright.chromium.connectOverCDP(cdpUrl);
             const contexts = this.browser.contexts();
             this.context = contexts[0] || await this.browser.newContext();
+            await this.applyStealth(this.context);
             const pages = this.context.pages();
             for (const page of pages) {
                 const pageId = `page-${Date.now()}-${Math.random().toString(36).slice(2)}`;
                 this.pages.set(pageId, page);
                 this.setupPageListeners(pageId, page);
             }
-            if (pages.length > 0) {
-                this.currentPageId = Array.from(this.pages.keys())[0];
+            const firstPageId = Array.from(this.pages.keys())[0];
+            if (pages.length > 0 && firstPageId !== undefined) {
+                this.currentPageId = firstPageId;
             }
             logger.info('Connected to browser via CDP', { cdpUrl });
         }
@@ -119,6 +127,7 @@ export class BrowserManager extends EventEmitter {
             this.browser = null;
             this.context = null;
             this.pages.clear();
+            this.pendingDialogs.clear();
             this.currentPageId = null;
             logger.info('Browser closed');
         }
@@ -132,26 +141,37 @@ export class BrowserManager extends EventEmitter {
             }
         });
         page.on('pageerror', (error) => {
+            this.pushConsoleEntry({
+                type: 'pageerror',
+                text: error.message,
+                timestamp: new Date(),
+                pageId,
+                url: page.url(),
+            });
             this.emit('page-error', error);
         });
         page.on('dialog', (dialog) => {
-            this.emit('dialog', {
-                type: dialog.type(),
+            const id = `dialog-${++this.dialogCounter}`;
+            const info = {
+                id,
+                pageId,
+                type: this.toDialogType(dialog.type()),
                 message: dialog.message(),
                 defaultValue: dialog.defaultValue(),
-            });
+                createdAt: new Date().toISOString(),
+            };
+            this.pendingDialogs.set(id, { info, dialog });
+            this.emit('dialog', info);
         });
         page.on('console', (msg) => {
             this.emit('console', msg.type(), msg.text());
-            // Buffer console entries
-            this.consoleBuffer.push({
+            this.pushConsoleEntry({
                 type: msg.type(),
                 text: msg.text(),
                 timestamp: new Date(),
+                pageId,
+                url: page.url(),
             });
-            if (this.consoleBuffer.length > BrowserManager.MAX_CONSOLE_ENTRIES) {
-                this.consoleBuffer.splice(0, this.consoleBuffer.length - BrowserManager.MAX_CONSOLE_ENTRIES);
-            }
         });
         page.on('request', (request) => {
             this.emit('network-request', {
@@ -240,8 +260,9 @@ export class BrowserManager extends EventEmitter {
         }
         await page.close();
         this.pages.delete(tabId);
+        this.removePendingDialogsForPage(tabId);
         if (this.currentPageId === tabId) {
-            this.currentPageId = this.pages.size > 0 ? Array.from(this.pages.keys())[0] : null;
+            this.currentPageId = this.pages.size > 0 ? Array.from(this.pages.keys())[0] ?? null : null;
         }
     }
     // ============================================================================
@@ -261,6 +282,33 @@ export class BrowserManager extends EventEmitter {
         // Don't reset nextRef — continuous counter for globally unique refs
         const ttl = options.ttl ?? 5000;
         const format = options.format ?? 'ai';
+        const pendingDialogs = this.listPendingDialogs();
+        if (pendingDialogs.length > 0) {
+            const viewport = page.viewportSize() || { width: 1280, height: 720 };
+            const snapshot = {
+                id: `websnap-${Date.now()}`,
+                timestamp: new Date(),
+                url: page.url(),
+                title: '(browser dialog pending)',
+                elements: [],
+                elementMap: new Map(),
+                viewport,
+                valid: true,
+                ttl,
+                format,
+                pendingDialogs,
+            };
+            setTimeout(() => {
+                snapshot.valid = false;
+                this.emit('snapshot-expired', { id: snapshot.id });
+            }, ttl);
+            this.currentSnapshot = snapshot;
+            logger.info('Web snapshot taken with pending browser dialog', {
+                id: snapshot.id,
+                pendingDialogs: pendingDialogs.length,
+            });
+            return snapshot;
+        }
         // Get all interactive elements using accessibility tree
         const elements = await this.extractElements(page, options);
         // Build element map
@@ -282,6 +330,7 @@ export class BrowserManager extends EventEmitter {
             valid: true,
             ttl,
             format,
+            pendingDialogs: [],
         };
         // Invalidate after TTL
         setTimeout(() => {
@@ -297,8 +346,20 @@ export class BrowserManager extends EventEmitter {
      */
     async extractElements(page, options) {
         const maxElements = options.maxElements ?? 200;
-        // Use Playwright's accessibility tree
-        const accessibilityTree = await page.accessibility.snapshot({ interestingOnly: true });
+        // Get accessibility tree (page.accessibility removed in Playwright 1.48+)
+        let accessibilityTree = null;
+        try {
+            if (page.accessibility) {
+                accessibilityTree = await page.accessibility.snapshot({ interestingOnly: true });
+            }
+        }
+        catch {
+            // Accessibility API unavailable
+        }
+        // Fallback: extract via DOM when accessibility API is unavailable
+        if (!accessibilityTree) {
+            return this.extractElementsViaDOM(page, maxElements, options);
+        }
         const elements = [];
         const processNode = async (node, depth = 0) => {
             if (elements.length >= maxElements)
@@ -365,6 +426,84 @@ export class BrowserManager extends EventEmitter {
         }
         return elements;
     }
+    /**
+     * DOM-based element extraction fallback for Playwright 1.48+ where page.accessibility was removed
+     */
+    async extractElementsViaDOM(page, maxElements, options) {
+        const interactiveSelector = 'a, button, input, select, textarea, [role="button"], [role="link"], [role="textbox"], [role="checkbox"], [role="radio"], [role="combobox"], [role="listbox"], [role="menuitem"], [role="tab"], [role="switch"], [role="slider"], [role="searchbox"], [contenteditable="true"]';
+        const selector = options.interactiveOnly ? interactiveSelector : `${interactiveSelector}, h1, h2, h3, h4, h5, h6, p, img, li, td, th, label`;
+        const startRef = this.nextRef;
+        const domNodes = await page.evaluate(({ sel, start }) => {
+            const nodes = Array.from(document.querySelectorAll(sel));
+            let currentRef = start;
+            return nodes.slice(0, 300).map((el) => {
+                const rect = el.getBoundingClientRect();
+                const htmlEl = el;
+                // Inject data-agent-ref for reliable selector-based action mapping
+                const ref = currentRef++;
+                try {
+                    el.setAttribute('data-agent-ref', String(ref));
+                }
+                catch (_) { /* ignore */ }
+                const name = (el.getAttribute('aria-label') || htmlEl.placeholder || el.textContent?.trim().slice(0, 100) || '').trim();
+                const value = htmlEl.value || el.getAttribute('aria-valuetext') || '';
+                return {
+                    ref,
+                    tagName: el.tagName.toLowerCase(),
+                    role: el.getAttribute('role') || '',
+                    name,
+                    value,
+                    disabled: htmlEl.disabled || el.getAttribute('aria-disabled') === 'true',
+                    focused: document.activeElement === el,
+                    checked: htmlEl.checked || false,
+                    x: rect.x, y: rect.y, width: rect.width, height: rect.height,
+                };
+            });
+        }, { sel: selector, start: startRef });
+        const elements = [];
+        for (const node of domNodes) {
+            if (elements.length >= maxElements)
+                break;
+            if (!options.includeHidden && node.width === 0 && node.height === 0)
+                continue;
+            const role = node.role || this.tagNameToRole(node.tagName);
+            const isInteractive = this.isInteractiveRole(role);
+            if (options.interactiveOnly && !isInteractive)
+                continue;
+            // Semantic Pruning: Skip non-interactive element if name and value are empty
+            if (!isInteractive && !node.name && !node.value) {
+                continue;
+            }
+            elements.push({
+                ref: node.ref,
+                tagName: node.tagName,
+                role,
+                name: node.name,
+                text: node.name,
+                boundingBox: { x: node.x, y: node.y, width: node.width, height: node.height },
+                center: { x: node.x + node.width / 2, y: node.y + node.height / 2 },
+                visible: node.width > 0 && node.height > 0,
+                interactive: isInteractive,
+                focused: node.focused,
+                disabled: node.disabled,
+                value: node.value || undefined,
+                ariaAttributes: {},
+            });
+        }
+        // Update nextRef
+        this.nextRef = startRef + domNodes.length;
+        return elements;
+    }
+    tagNameToRole(tagName) {
+        const tagRoleMap = {
+            a: 'link', button: 'button', input: 'textbox', select: 'combobox',
+            textarea: 'textbox', h1: 'heading', h2: 'heading', h3: 'heading',
+            h4: 'heading', h5: 'heading', h6: 'heading', img: 'img',
+            p: 'paragraph', li: 'listitem', ul: 'list', ol: 'list',
+            table: 'table', td: 'cell', th: 'columnheader', label: 'label',
+        };
+        return tagRoleMap[tagName] || 'generic';
+    }
     isInteractiveRole(role) {
         const interactiveRoles = [
             'button', 'link', 'textbox', 'checkbox', 'radio',
@@ -416,9 +555,18 @@ export class BrowserManager extends EventEmitter {
             `Title: ${snap.title}`,
             `Elements: ${snap.elements.length}`,
             '',
-            '## Interactive Elements',
-            '',
         ];
+        if (snap.pendingDialogs?.length) {
+            lines.push('## Pending Browser Dialogs');
+            lines.push('');
+            for (const dialog of snap.pendingDialogs) {
+                const defaultValue = dialog.defaultValue ? ` default="${dialog.defaultValue}"` : '';
+                lines.push(`  [${dialog.id ?? 'dialog'}] ${dialog.type}: ${dialog.message}${defaultValue}`);
+            }
+            lines.push('');
+        }
+        lines.push('## Interactive Elements');
+        lines.push('');
         // Group by role
         const byRole = new Map();
         for (const elem of snap.elements) {
@@ -443,20 +591,32 @@ export class BrowserManager extends EventEmitter {
     // ============================================================================
     // Navigation
     // ============================================================================
-    /**
-     * Navigate to URL
-     */
     async navigate(options) {
         const page = this.getCurrentPage();
-        await page.goto(options.url, {
-            waitUntil: options.waitUntil || 'domcontentloaded',
-            timeout: options.timeout || this.config.timeout,
-            referer: options.referer,
-        });
-        // Invalidate snapshot
-        if (this.currentSnapshot) {
-            this.currentSnapshot.valid = false;
+        const timeout = options.timeout || this.config.timeout || 30000;
+        let lastError = null;
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            try {
+                await page.goto(options.url, {
+                    waitUntil: options.waitUntil || 'domcontentloaded',
+                    timeout,
+                    referer: options.referer,
+                });
+                // Invalidate snapshot
+                if (this.currentSnapshot) {
+                    this.currentSnapshot.valid = false;
+                }
+                return; // Succeeded!
+            }
+            catch (err) {
+                lastError = err;
+                logger.warn(`Navigation attempt ${attempt} to ${options.url} failed, retrying...`, { error: err });
+                if (attempt < 3) {
+                    await page.waitForTimeout(1000 * attempt); // Exponential backoff wait before retry
+                }
+            }
         }
+        throw new Error(`Navigation to ${options.url} failed after 3 attempts. Last error: ${lastError?.message}`);
     }
     /**
      * Go back
@@ -482,15 +642,42 @@ export class BrowserManager extends EventEmitter {
     // ============================================================================
     // Interactions
     // ============================================================================
-    /**
-     * Click element by reference
-     */
     async click(ref, options = {}) {
         const page = this.getCurrentPage();
         const element = this.getElement(ref);
         if (!element) {
             throw new Error(`Element [${ref}] not found. Take a new snapshot.`);
         }
+        // Move mouse smoothly from last position to element center
+        try {
+            await this.moveMouseHumanLike(page, this.lastMouseX, this.lastMouseY, element.center.x, element.center.y);
+            this.lastMouseX = element.center.x;
+            this.lastMouseY = element.center.y;
+        }
+        catch (_) {
+            try {
+                await page.mouse.move(element.center.x, element.center.y);
+            }
+            catch (_) { /* ignore */ }
+        }
+        // Try selector click first for robustness
+        try {
+            const selector = `[data-agent-ref="${ref}"]`;
+            const locator = page.locator(selector).first();
+            if (await locator.count() > 0 && await locator.isVisible()) {
+                await locator.click({
+                    button: options.button || 'left',
+                    clickCount: options.clickCount || 1,
+                    delay: options.delay,
+                    timeout: 2000,
+                });
+                logger.info(`Clicked element [${ref}] using selector ${selector}`);
+                return;
+            }
+        }
+        catch (err) {
+            logger.debug(`Selector click failed for [${ref}], falling back to coordinates`, { error: err });
+        }
         await page.mouse.click(element.center.x, element.center.y, {
             button: options.button || 'left',
             clickCount: options.clickCount || 1,
@@ -506,15 +693,55 @@ export class BrowserManager extends EventEmitter {
         if (!element) {
             throw new Error(`Element [${ref}] not found. Take a new snapshot.`);
         }
-        // Click to focus
-        await page.mouse.click(element.center.x, element.center.y);
-        // Clear if requested
-        if (options.clear) {
-            await page.keyboard.press('Control+A');
-            await page.keyboard.press('Backspace');
+        let typedViaSelector = false;
+        try {
+            const selector = `[data-agent-ref="${ref}"]`;
+            const locator = page.locator(selector).first();
+            if (await locator.count() > 0 && await locator.isVisible()) {
+                if (options.clear) {
+                    await locator.fill('');
+                }
+                await locator.focus();
+                const baseDelay = options.delay || 50;
+                for (const char of text) {
+                    await page.keyboard.type(char);
+                    const jitterDelay = baseDelay * 0.5 + Math.random() * baseDelay;
+                    await page.waitForTimeout(jitterDelay);
+                }
+                logger.info(`Typed into element [${ref}] using selector ${selector} with human-like jitter`);
+                typedViaSelector = true;
+            }
+        }
+        catch (err) {
+            logger.debug(`Selector typing failed for [${ref}], falling back to coordinates`, { error: err });
+        }
+        if (!typedViaSelector) {
+            // Click to focus (includes smooth mouse movement)
+            try {
+                await this.moveMouseHumanLike(page, this.lastMouseX, this.lastMouseY, element.center.x, element.center.y);
+                this.lastMouseX = element.center.x;
+                this.lastMouseY = element.center.y;
+            }
+            catch (_) {
+                try {
+                    await page.mouse.move(element.center.x, element.center.y);
+                }
+                catch (_) { /* ignore */ }
+            }
+            await page.mouse.click(element.center.x, element.center.y);
+            // Clear if requested
+            if (options.clear) {
+                await page.keyboard.press('Control+A');
+                await page.keyboard.press('Backspace');
+            }
+            // Type text with human-like jitter
+            const baseDelay = options.delay || 50;
+            for (const char of text) {
+                await page.keyboard.type(char);
+                const jitterDelay = baseDelay * 0.5 + Math.random() * baseDelay;
+                await page.waitForTimeout(jitterDelay);
+            }
         }
-        // Type text
-        await page.keyboard.type(text, { delay: options.delay || 50 });
     }
     /**
      * Fill multiple fields
@@ -537,7 +764,15 @@ export class BrowserManager extends EventEmitter {
         if (options.toElement !== undefined) {
             const element = this.getElement(options.toElement);
             if (element) {
-                await page.mouse.wheel(0, element.boundingBox.y - 100);
+                const selector = `[data-agent-ref="${options.toElement}"]`;
+                try {
+                    await page.locator(selector).first().scrollIntoViewIfNeeded({ timeout: 1000 });
+                }
+                catch {
+                    await page.evaluate(({ top }) => window.scrollBy(0, top), {
+                        top: element.boundingBox.y - 100,
+                    });
+                }
             }
         }
         else {
@@ -558,33 +793,77 @@ export class BrowserManager extends EventEmitter {
                     deltaX = amount;
                     break;
             }
-            await page.mouse.wheel(deltaX, deltaY);
+            const before = await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY }));
+            await page.evaluate(({ x, y }) => window.scrollBy(x, y), {
+                x: deltaX,
+                y: deltaY,
+            });
+            const after = await page.evaluate(() => ({ x: window.scrollX, y: window.scrollY }));
+            if (after.x === before.x && after.y === before.y) {
+                await page.mouse.wheel(deltaX, deltaY);
+            }
         }
     }
-    /**
-     * Select option in dropdown
-     */
     async select(options) {
         const page = this.getCurrentPage();
         const element = this.getElement(options.ref);
         if (!element) {
             throw new Error(`Element [${options.ref}] not found.`);
         }
-        // Click to open dropdown
-        await page.mouse.click(element.center.x, element.center.y);
-        // Wait a bit for dropdown to open
-        await page.waitForTimeout(200);
-        // Select by value, label, or index
-        if (options.value) {
-            await page.keyboard.type(options.value.charAt(0));
-            await page.keyboard.press('Enter');
-        }
-        else if (options.index !== undefined) {
-            for (let i = 0; i < options.index; i++) {
-                await page.keyboard.press('ArrowDown');
+        const selector = `[data-agent-ref="${options.ref}"]`;
+        let lastError = null;
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            try {
+                // Native selectOption first
+                if (element.tagName === 'select' || element.role === 'combobox' || element.role === 'listbox') {
+                    try {
+                        if (options.value) {
+                            await page.selectOption(selector, { value: options.value });
+                        }
+                        else if (options.label) {
+                            await page.selectOption(selector, { label: options.label });
+                        }
+                        else if (options.index !== undefined) {
+                            await page.selectOption(selector, { index: options.index });
+                        }
+                        return; // Succeeded natively!
+                    }
+                    catch (err) {
+                        logger.warn(`Native selectOption attempt ${attempt} failed, falling back to mouse/keyboard interactions`, { error: err });
+                    }
+                }
+                // Custom dropdown interactive fallback
+                const locator = page.locator(selector).first();
+                await locator.waitFor({ state: 'visible', timeout: 2000 });
+                await locator.click();
+                // Wait for dropdown to open (menus, listboxes, lists)
+                try {
+                    await page.waitForSelector('[role="listbox"]:visible, [role="menu"]:visible, ul:visible, select:visible', { timeout: 500 });
+                }
+                catch {
+                    await page.waitForTimeout(150);
+                }
+                if (options.value) {
+                    await page.keyboard.type(options.value.charAt(0));
+                    await page.keyboard.press('Enter');
+                }
+                else if (options.index !== undefined) {
+                    for (let i = 0; i < options.index; i++) {
+                        await page.keyboard.press('ArrowDown');
+                    }
+                    await page.keyboard.press('Enter');
+                }
+                return; // Succeeded!
+            }
+            catch (err) {
+                lastError = err;
+                logger.warn(`Dropdown select attempt ${attempt} failed, retrying...`, { error: err });
+                if (attempt < 3) {
+                    await page.waitForTimeout(500);
+                }
             }
-            await page.keyboard.press('Enter');
         }
+        throw new Error(`Dropdown selection failed after 3 attempts. Last error: ${lastError?.message}`);
     }
     /**
      * Press keyboard key
@@ -612,7 +891,48 @@ export class BrowserManager extends EventEmitter {
         if (!element) {
             throw new Error(`Element [${ref}] not found.`);
         }
-        await page.mouse.move(element.center.x, element.center.y);
+        try {
+            await this.moveMouseHumanLike(page, this.lastMouseX, this.lastMouseY, element.center.x, element.center.y);
+            this.lastMouseX = element.center.x;
+            this.lastMouseY = element.center.y;
+        }
+        catch (_) {
+            await page.mouse.move(element.center.x, element.center.y);
+        }
+    }
+    /**
+     * Move mouse dynamically using cubic Bezier curves to simulate human behavior
+     */
+    async moveMouseHumanLike(page, fromX, fromY, toX, toY) {
+        const distance = Math.hypot(toX - fromX, toY - fromY);
+        if (distance < 10) {
+            await page.mouse.move(toX, toY);
+            return;
+        }
+        const steps = Math.min(25, Math.max(10, Math.round(distance / 40)));
+        // Generate random control points for Bezier curve to simulate natural arm/wrist arc
+        const ctrlX1 = fromX + (toX - fromX) * 0.25 + (Math.random() - 0.5) * 150;
+        const ctrlY1 = fromY + (toY - fromY) * 0.25 + (Math.random() - 0.5) * 150;
+        const ctrlX2 = fromX + (toX - fromX) * 0.75 + (Math.random() - 0.5) * 150;
+        const ctrlY2 = fromY + (toY - fromY) * 0.75 + (Math.random() - 0.5) * 150;
+        for (let i = 1; i <= steps; i++) {
+            const t = i / steps;
+            // Cubic Bezier interpolation
+            const x = Math.round((1 - t) ** 3 * fromX +
+                3 * (1 - t) ** 2 * t * ctrlX1 +
+                3 * (1 - t) * t ** 2 * ctrlX2 +
+                t ** 3 * toX);
+            const y = Math.round((1 - t) ** 3 * fromY +
+                3 * (1 - t) ** 2 * t * ctrlY1 +
+                3 * (1 - t) * t ** 2 * ctrlY2 +
+                t ** 3 * toY);
+            const jitterX = x + (Math.random() > 0.5 ? 1 : -1) * (Math.random() * 1.5);
+            const jitterY = y + (Math.random() > 0.5 ? 1 : -1) * (Math.random() * 1.5);
+            await page.mouse.move(Math.round(jitterX), Math.round(jitterY));
+            const stepDelay = 8 + Math.random() * 7;
+            await page.waitForTimeout(stepDelay);
+        }
+        await page.mouse.move(toX, toY);
     }
     // ============================================================================
     // Media Capture
@@ -799,15 +1119,31 @@ export class BrowserManager extends EventEmitter {
      * Handle dialog
      */
     async handleDialog(action) {
-        const page = this.getCurrentPage();
-        page.once('dialog', async (dialog) => {
+        const pending = this.findPendingDialog(action.dialogId);
+        if (!pending) {
+            throw new Error('No pending browser dialog found. Trigger the dialog first, then call browser_dialog.');
+        }
+        try {
             if (action.accept) {
-                await dialog.accept(action.promptText);
+                await pending.dialog.accept(action.promptText);
             }
             else {
-                await dialog.dismiss();
+                await pending.dialog.dismiss();
             }
-        });
+            return pending.info;
+        }
+        finally {
+            if (pending.info.id) {
+                this.pendingDialogs.delete(pending.info.id);
+            }
+        }
+    }
+    listPendingDialogs(options = {}) {
+        const currentPageOnly = options.currentPageOnly ?? true;
+        const currentPageId = this.currentPageId;
+        return Array.from(this.pendingDialogs.values())
+            .map(entry => entry.info)
+            .filter(info => !currentPageOnly || !currentPageId || info.pageId === currentPageId);
     }
     // ============================================================================
     // File Upload
@@ -836,9 +1172,38 @@ export class BrowserManager extends EventEmitter {
             throw new Error(`Source element [${options.sourceRef}] not found.`);
         if (!target)
             throw new Error(`Target element [${options.targetRef}] not found.`);
-        const sourceLocator = page.locator(`[aria-label="${source.name}"]`).first();
-        const targetLocator = page.locator(`[aria-label="${target.name}"]`).first();
-        await sourceLocator.dragTo(targetLocator);
+        // Use injected selector first, fallback to coordinates or aria-label locators
+        const sourceSelector = `[data-agent-ref="${options.sourceRef}"]`;
+        const targetSelector = `[data-agent-ref="${options.targetRef}"]`;
+        let lastError = null;
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            try {
+                const sourceLoc = page.locator(sourceSelector).first();
+                const targetLoc = page.locator(targetSelector).first();
+                // Check visibility and wait
+                await sourceLoc.waitFor({ state: 'visible', timeout: 2000 });
+                await targetLoc.waitFor({ state: 'visible', timeout: 2000 });
+                await sourceLoc.dragTo(targetLoc);
+                return; // Succeeded!
+            }
+            catch (err) {
+                lastError = err;
+                logger.warn(`Drag-and-drop attempt ${attempt} failed, retrying...`, { error: err });
+                // Fallback to hover + mouse down + move + mouse up if dragTo fails
+                try {
+                    await page.mouse.move(source.center.x, source.center.y);
+                    await page.mouse.down();
+                    await page.waitForTimeout(100);
+                    await page.mouse.move(target.center.x, target.center.y, { steps: 5 });
+                    await page.mouse.up();
+                    return; // Fallback succeeded!
+                }
+                catch (fallbackErr) {
+                    logger.warn(`Drag-and-drop coordinates fallback attempt ${attempt} failed`, { error: fallbackErr });
+                }
+            }
+        }
+        throw new Error(`Drag-and-drop failed after 3 attempts. Last error: ${lastError?.message}`);
     }
     /**
      * Wait for navigation to complete
@@ -873,6 +1238,27 @@ export class BrowserManager extends EventEmitter {
         }
         return this.pages.get(this.currentPageId);
     }
+    findPendingDialog(dialogId) {
+        if (dialogId) {
+            return this.pendingDialogs.get(dialogId);
+        }
+        const currentPageId = this.currentPageId;
+        return Array.from(this.pendingDialogs.values())
+            .find(entry => !currentPageId || entry.info.pageId === currentPageId);
+    }
+    removePendingDialogsForPage(pageId) {
+        for (const [dialogId, entry] of this.pendingDialogs.entries()) {
+            if (entry.info.pageId === pageId) {
+                this.pendingDialogs.delete(dialogId);
+            }
+        }
+    }
+    toDialogType(type) {
+        if (type === 'alert' || type === 'confirm' || type === 'prompt' || type === 'beforeunload') {
+            return type;
+        }
+        return 'alert';
+    }
     /**
      * Check if browser is launched
      */
@@ -901,6 +1287,12 @@ export class BrowserManager extends EventEmitter {
     clearConsoleHistory() {
         this.consoleBuffer = [];
     }
+    pushConsoleEntry(entry) {
+        this.consoleBuffer.push(entry);
+        if (this.consoleBuffer.length > BrowserManager.MAX_CONSOLE_ENTRIES) {
+            this.consoleBuffer.splice(0, this.consoleBuffer.length - BrowserManager.MAX_CONSOLE_ENTRIES);
+        }
+    }
     // ============================================================================
     // localStorage / sessionStorage
     // ============================================================================
@@ -1110,6 +1502,52 @@ export class BrowserManager extends EventEmitter {
             await this._routeInterceptor.clearRules(page);
         }
     }
+    /**
+     * Apply stealth overrides to browser context
+     */
+    async applyStealth(context) {
+        try {
+            await context.addInitScript(() => {
+                try {
+                    Object.defineProperty(navigator, 'webdriver', {
+                        get: () => false,
+                    });
+                }
+                catch (_) { /* ignore */ }
+                try {
+                    const getParameter = WebGLRenderingContext.prototype.getParameter;
+                    WebGLRenderingContext.prototype.getParameter = function (parameter) {
+                        if (parameter === 37445)
+                            return 'Intel Open Source Technology Center';
+                        if (parameter === 37446)
+                            return 'Mesa DRI Intel(R) HD Graphics 620 (Skylake GT2)';
+                        return getParameter.call(this, parameter);
+                    };
+                }
+                catch (_) { /* ignore */ }
+                try {
+                    Object.defineProperty(navigator, 'languages', {
+                        get: () => ['fr-FR', 'fr', 'en-US', 'en'],
+                    });
+                }
+                catch (_) { /* ignore */ }
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    window.chrome = {
+                        runtime: {},
+                        loadTimes: () => { },
+                        csi: () => { },
+                        app: {},
+                    };
+                }
+                catch (_) { /* ignore */ }
+            });
+            logger.info('Applied stealth init scripts to context');
+        }
+        catch (error) {
+            logger.debug('Failed to apply stealth scripts', { error });
+        }
+    }
     /**
      * Get current snapshot
      */