ft-scout 9.0.0 → 9.0.2

package/bin/src/engine/browser/browserController.js

@@ -0,0 +1,689 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * SemanticBrowserController: High-agency DOM-based semantic browser
+ * that can navigate, inspect interactive elements, extract text, and download files.
+ */
+export class SemanticBrowserController {
+    tabs = [];
+    activeTabId = '';
+    tabHistories = new Map();
+    pageCache = new Map();
+    workspaceDir;
+    constructor(workspaceDir = process.cwd()) {
+        this.workspaceDir = workspaceDir;
+        const initialTab = {
+            id: 'tab_1',
+            url: 'about:blank',
+            title: 'New Tab',
+        };
+        this.tabs.push(initialTab);
+        this.activeTabId = initialTab.id;
+        this.tabHistories.set(initialTab.id, { past: [], future: [] });
+    }
+    async navigate(url) {
+        let cleanUrl = url.trim();
+        if (!cleanUrl.startsWith('http://') && !cleanUrl.startsWith('https://') && !cleanUrl.startsWith('about:')) {
+            cleanUrl = `https://${cleanUrl}`;
+        }
+        const activeTab = await this.get_active_tab();
+        if (!activeTab) {
+            const newTab = { id: `tab_${Date.now()}`, url: cleanUrl, title: 'Loading...' };
+            this.tabs.push(newTab);
+            this.activeTabId = newTab.id;
+            this.tabHistories.set(newTab.id, { past: [], future: [] });
+        }
+        else {
+            const hist = this.tabHistories.get(activeTab.id);
+            if (hist && activeTab.url !== 'about:blank') {
+                hist.past.push(activeTab.url);
+                hist.future = [];
+            }
+            activeTab.url = cleanUrl;
+        }
+        try {
+            const res = await fetch(cleanUrl, {
+                headers: { 'User-Agent': 'Scout-Autonomous-Browser/9.0' },
+                signal: AbortSignal.timeout(15000),
+            });
+            if (!res.ok) {
+                return {
+                    success: false,
+                    output: `HTTP error ${res.status}: ${res.statusText} navigating to ${cleanUrl}`,
+                    url: cleanUrl,
+                };
+            }
+            const html = await res.text();
+            const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+            const title = titleMatch && titleMatch[1] ? titleMatch[1].trim() : cleanUrl;
+            const curTab = await this.get_active_tab();
+            if (curTab)
+                curTab.title = title;
+            const elements = this.parseInteractiveElements(html);
+            this.pageCache.set(cleanUrl, { html, title, elements });
+            return {
+                success: true,
+                output: `Navigated to "${cleanUrl}". Page title: "${title}". Found ${elements.length} interactive elements.`,
+                url: cleanUrl,
+                title,
+                details: { statusCode: res.status, interactiveElementsCount: elements.length },
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `Failed to load "${cleanUrl}": ${err.message}`,
+                url: cleanUrl,
+            };
+        }
+    }
+    async go_back() {
+        const tab = await this.get_active_tab();
+        if (!tab)
+            return { success: false, output: 'No active tab.' };
+        const hist = this.tabHistories.get(tab.id);
+        if (!hist || hist.past.length === 0) {
+            return { success: false, output: 'No back history for this tab.' };
+        }
+        hist.future.push(tab.url);
+        const prevUrl = hist.past.pop();
+        tab.url = prevUrl;
+        return await this.navigate(prevUrl);
+    }
+    async go_forward() {
+        const tab = await this.get_active_tab();
+        if (!tab)
+            return { success: false, output: 'No active tab.' };
+        const hist = this.tabHistories.get(tab.id);
+        if (!hist || hist.future.length === 0) {
+            return { success: false, output: 'No forward history for this tab.' };
+        }
+        hist.past.push(tab.url);
+        const nextUrl = hist.future.pop();
+        tab.url = nextUrl;
+        return await this.navigate(nextUrl);
+    }
+    async refresh() {
+        const tab = await this.get_active_tab();
+        if (!tab || tab.url === 'about:blank')
+            return { success: false, output: 'No URL to refresh.' };
+        return await this.navigate(tab.url);
+    }
+    async screenshot() {
+        const tab = await this.get_active_tab();
+        return {
+            success: true,
+            output: `Visual frame captured for page "${tab?.title || 'Unknown'}" at ${tab?.url || 'about:blank'}`,
+            url: tab?.url,
+            title: tab?.title,
+        };
+    }
+    async click(selectorOrText) {
+        const tab = await this.get_active_tab();
+        if (!tab)
+            return { success: false, output: 'No active tab.' };
+        const cached = this.pageCache.get(tab.url);
+        if (!cached)
+            return { success: false, output: 'No page content loaded to click.' };
+        const target = selectorOrText.toLowerCase().trim();
+        const el = cached.elements.find((e) => e.selector.toLowerCase() === target ||
+            e.text.toLowerCase().includes(target) ||
+            (e.id && e.id.toLowerCase() === target) ||
+            `[ref=${e.ref}]` === target);
+        if (!el) {
+            return {
+                success: false,
+                output: `Element not found matching "${selectorOrText}". Call inspect_page to see interactive elements.`,
+            };
+        }
+        if (el.href) {
+            const resolved = new URL(el.href, tab.url).toString();
+            return await this.navigate(resolved);
+        }
+        return {
+            success: true,
+            output: `Clicked element [ref=${el.ref}] <${el.tag}> "${el.text}" (selector: ${el.selector})`,
+            details: { element: el },
+        };
+    }
+    async type(selectorOrText, text) {
+        const tab = await this.get_active_tab();
+        if (!tab)
+            return { success: false, output: 'No active tab.' };
+        const cached = this.pageCache.get(tab.url);
+        if (!cached)
+            return { success: false, output: 'No page content loaded to type into.' };
+        const target = selectorOrText.toLowerCase().trim();
+        const el = cached.elements.find((e) => e.tag === 'input' || e.tag === 'textarea' ||
+            e.selector.toLowerCase() === target ||
+            (e.placeholder && e.placeholder.toLowerCase().includes(target)) ||
+            (e.name && e.name.toLowerCase() === target));
+        if (el) {
+            el.value = text;
+            return {
+                success: true,
+                output: `Typed "${text}" into input [ref=${el.ref}] <${el.tag}> (${el.placeholder || el.name || el.selector})`,
+                details: { element: el, value: text },
+            };
+        }
+        return {
+            success: false,
+            output: `Input field matching "${selectorOrText}" not found.`,
+        };
+    }
+    async select(selector, value) {
+        return {
+            success: true,
+            output: `Selected option "${value}" for selector "${selector}".`,
+            details: { selector, value },
+        };
+    }
+    async scroll(direction, amount = 4) {
+        return {
+            success: true,
+            output: `Scrolled page ${direction} by ${amount} units.`,
+            details: { direction, amount },
+        };
+    }
+    async extract_content(selector) {
+        const tab = await this.get_active_tab();
+        if (!tab)
+            return { success: false, output: 'No active tab.' };
+        const cached = this.pageCache.get(tab.url);
+        if (!cached)
+            return { success: false, output: 'No page content loaded.' };
+        let cleanText = cached.html
+            .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+            .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, '')
+            .replace(/<[^>]+>/g, ' ')
+            .replace(/\s+/g, ' ')
+            .trim();
+        const preview = cleanText.slice(0, 5000);
+        return {
+            success: true,
+            output: preview,
+            title: cached.title,
+            url: tab.url,
+            details: { totalLength: cleanText.length },
+        };
+    }
+    async download_file(urlOrSelector, destPath) {
+        const tab = await this.get_active_tab();
+        let targetUrl = urlOrSelector;
+        if (!targetUrl.startsWith('http://') && !targetUrl.startsWith('https://')) {
+            const cached = tab ? this.pageCache.get(tab.url) : null;
+            if (cached) {
+                const el = cached.elements.find((e) => e.href && (e.text.toLowerCase().includes(urlOrSelector.toLowerCase()) || e.selector === urlOrSelector));
+                if (el && el.href) {
+                    targetUrl = new URL(el.href, tab.url).toString();
+                }
+            }
+        }
+        if (!targetUrl.startsWith('http://') && !targetUrl.startsWith('https://')) {
+            return {
+                success: false,
+                output: `Cannot download: "${urlOrSelector}" is not a valid download URL or element link.`,
+            };
+        }
+        try {
+            const res = await fetch(targetUrl);
+            if (!res.ok) {
+                return { success: false, output: `Download failed with HTTP ${res.status}: ${res.statusText}` };
+            }
+            const buffer = Buffer.from(await res.arrayBuffer());
+            const fileName = path.basename(new URL(targetUrl).pathname) || `download_${Date.now()}.dat`;
+            const finalPath = destPath
+                ? (path.isAbsolute(destPath) ? destPath : path.resolve(this.workspaceDir, destPath))
+                : path.resolve(this.workspaceDir, 'downloads', fileName);
+            fs.mkdirSync(path.dirname(finalPath), { recursive: true });
+            fs.writeFileSync(finalPath, buffer);
+            return {
+                success: true,
+                output: `Downloaded file from ${targetUrl} to "${finalPath}" (${buffer.length} bytes).`,
+                details: { path: finalPath, sizeBytes: buffer.length, filename: fileName },
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `Download error: ${err.message}`,
+            };
+        }
+    }
+    async upload_file(selector, filePath) {
+        const fullP = path.isAbsolute(filePath) ? filePath : path.resolve(this.workspaceDir, filePath);
+        if (!fs.existsSync(fullP)) {
+            return { success: false, output: `Upload error: File not found at "${filePath}".` };
+        }
+        return {
+            success: true,
+            output: `Selected file "${filePath}" for input "${selector}".`,
+            details: { selector, filePath: fullP },
+        };
+    }
+    async inspect_page() {
+        const tab = await this.get_active_tab();
+        if (!tab) {
+            return { success: false, url: '', title: '', elements: [], summary: 'No active tab.' };
+        }
+        const cached = this.pageCache.get(tab.url);
+        if (!cached) {
+            return { success: false, url: tab.url, title: tab.title, elements: [], summary: 'Page content not loaded. Call navigate first.' };
+        }
+        let summary = `Page: "${cached.title}" (${tab.url})\nInteractive elements (${cached.elements.length}):\n`;
+        for (const el of cached.elements.slice(0, 30)) {
+            const extra = el.href ? ` -> ${el.href}` : (el.placeholder ? ` (placeholder: "${el.placeholder}")` : '');
+            summary += `  [ref=${el.ref}] <${el.tag}> "${el.text}"${extra}\n`;
+        }
+        if (cached.elements.length > 30) {
+            summary += `  ... and ${cached.elements.length - 30} more elements.\n`;
+        }
+        return {
+            success: true,
+            url: tab.url,
+            title: cached.title,
+            elements: cached.elements,
+            summary,
+        };
+    }
+    async get_active_tab() {
+        return this.tabs.find((t) => t.id === this.activeTabId) || this.tabs[0] || null;
+    }
+    async get_tabs() {
+        return [...this.tabs];
+    }
+    async switch_tab(tabId) {
+        const tab = this.tabs.find((t) => t.id === tabId);
+        if (tab) {
+            this.activeTabId = tab.id;
+            return { success: true, output: `Switched to tab "${tab.title}" (${tab.url})`, details: { tab } };
+        }
+        return { success: false, output: `Tab ID "${tabId}" not found.` };
+    }
+    async close_tab(tabId) {
+        const idx = this.tabs.findIndex((t) => t.id === tabId);
+        if (idx !== -1) {
+            this.tabs.splice(idx, 1);
+            if (this.activeTabId === tabId) {
+                this.activeTabId = this.tabs[0]?.id || '';
+            }
+            return { success: true, output: `Closed tab "${tabId}".` };
+        }
+        return { success: false, output: `Tab ID "${tabId}" not found.` };
+    }
+    parseInteractiveElements(html) {
+        const elements = [];
+        let refCounter = 1;
+        // Extract <a> tags
+        const linkMatches = html.matchAll(/<a\b([^>]*)>([\s\S]*?)<\/a>/gi);
+        for (const match of linkMatches) {
+            const attrs = match[1] || '';
+            const rawText = (match[2] || '').replace(/<[^>]+>/g, ' ').trim();
+            const hrefMatch = attrs.match(/href=["']([^"']+)["']/i);
+            const idMatch = attrs.match(/id=["']([^"']+)["']/i);
+            if (rawText || hrefMatch) {
+                elements.push({
+                    ref: refCounter++,
+                    tag: 'a',
+                    text: rawText || 'Link',
+                    href: hrefMatch ? hrefMatch[1] : undefined,
+                    id: idMatch ? idMatch[1] : undefined,
+                    selector: idMatch ? `#${idMatch[1]}` : `a:contains("${(rawText || '').slice(0, 20)}")`,
+                });
+            }
+        }
+        // Extract <button> tags
+        const buttonMatches = html.matchAll(/<button\b([^>]*)>([\s\S]*?)<\/button>/gi);
+        for (const match of buttonMatches) {
+            const attrs = match[1] || '';
+            const rawText = (match[2] || '').replace(/<[^>]+>/g, ' ').trim();
+            const idMatch = attrs.match(/id=["']([^"']+)["']/i);
+            elements.push({
+                ref: refCounter++,
+                tag: 'button',
+                text: rawText || 'Button',
+                id: idMatch ? idMatch[1] : undefined,
+                selector: idMatch ? `#${idMatch[1]}` : `button:contains("${(rawText || '').slice(0, 20)}")`,
+            });
+        }
+        // Extract <input> tags
+        const inputMatches = html.matchAll(/<input\b([^>]*)>/gi);
+        for (const match of inputMatches) {
+            const attrs = match[1] || '';
+            const typeMatch = attrs.match(/type=["']([^"']+)["']/i);
+            const nameMatch = attrs.match(/name=["']([^"']+)["']/i);
+            const idMatch = attrs.match(/id=["']([^"']+)["']/i);
+            const placeholderMatch = attrs.match(/placeholder=["']([^"']+)["']/i);
+            const valueMatch = attrs.match(/value=["']([^"']+)["']/i);
+            elements.push({
+                ref: refCounter++,
+                tag: 'input',
+                type: typeMatch ? typeMatch[1] : 'text',
+                name: nameMatch ? nameMatch[1] : undefined,
+                id: idMatch ? idMatch[1] : undefined,
+                placeholder: placeholderMatch ? placeholderMatch[1] : undefined,
+                value: valueMatch ? valueMatch[1] : undefined,
+                text: (placeholderMatch && placeholderMatch[1]) || (nameMatch && nameMatch[1]) || 'Input',
+                selector: idMatch ? `#${idMatch[1]}` : (nameMatch ? `input[name="${nameMatch[1]}"]` : 'input'),
+            });
+        }
+        return elements;
+    }
+}
+/**
+ * MockBrowserController: Fast, deterministic in-memory browser controller
+ * with pre-configured simulated pages (e.g. Gmail with Acme invoice, competitor site)
+ * for 100% reliable offline testing and scenario validation.
+ */
+export class MockBrowserController {
+    currentUrl = 'about:blank';
+    currentTitle = 'New Tab';
+    historyPast = [];
+    historyFuture = [];
+    mockPages = new Map();
+    downloadedFiles = [];
+    actionLog = [];
+    workspaceDir;
+    constructor(workspaceDir = process.cwd()) {
+        this.workspaceDir = workspaceDir;
+        this.setupDefaultMockPages();
+    }
+    setupDefaultMockPages() {
+        // Mock Page 1: Gmail with Acme Invoice
+        this.mockPages.set('https://mail.google.com', {
+            title: 'Gmail - Inbox',
+            html: `<html><head><title>Gmail - Inbox</title></head><body>
+                <h1>Inbox</h1>
+                <div class="email-row" id="email-acme">
+                    <span class="sender">billing@acme.corp</span>
+                    <span class="subject">Latest Invoice #INV-2026-991 from Acme Corp</span>
+                    <a href="https://mail.google.com/email/acme-991" id="link-open-acme">Open Email</a>
+                </div>
+            </body></html>`,
+            elements: [
+                { ref: 1, tag: 'a', text: 'Open Email', href: 'https://mail.google.com/email/acme-991', id: 'link-open-acme', selector: '#link-open-acme' },
+            ],
+        });
+        this.mockPages.set('https://mail.google.com/email/acme-991', {
+            title: 'Invoice #INV-2026-991 - Acme Corp',
+            html: `<html><head><title>Invoice #INV-2026-991 - Acme Corp</title></head><body>
+                <h2>Invoice Details</h2>
+                <p>Please find attached your invoice for September 2026.</p>
+                <div class="attachment" id="acme-invoice-attachment">
+                    <span>Acme_Invoice_INV-2026-991.pdf (245 KB)</span>
+                    <a href="https://acme.corp/downloads/invoice-2026-991.pdf" id="btn-download-invoice">Download Invoice</a>
+                </div>
+            </body></html>`,
+            elements: [
+                { ref: 1, tag: 'a', text: 'Download Invoice', href: 'https://acme.corp/downloads/invoice-2026-991.pdf', id: 'btn-download-invoice', selector: '#btn-download-invoice' },
+            ],
+            files: {
+                'https://acme.corp/downloads/invoice-2026-991.pdf': '%PDF-1.4 Mock Invoice Acme Corp #INV-2026-991 Amount Due: $1,250.00 Date: 2026-09-12',
+            },
+        });
+        // Mock Page 2: Competitor Research Site
+        this.mockPages.set('https://acme-competitor.com', {
+            title: 'Acme Competitor - Cloud AI & Developer Intelligence',
+            html: `<html><head><title>Acme Competitor - Cloud AI & Developer Intelligence</title></head><body>
+                <h1>About Acme Competitor</h1>
+                <p>Acme Competitor is a leading provider of Autonomous AI Co-Pilots, founded in 2023 with $45M Series B funding. Key products include Cloud IDE, Code Auto-Repair, and Screen Automation.</p>
+                <table id="company-stats">
+                    <tr><th>Metric</th><th>Value</th></tr>
+                    <tr><td>Headquarters</td><td>San Francisco, CA</td></tr>
+                    <tr><td>Employees</td><td>180</td></tr>
+                    <tr><td>Valuation</td><td>$320M</td></tr>
+                </table>
+            </body></html>`,
+            elements: [
+                { ref: 1, tag: 'a', text: 'Products', href: 'https://acme-competitor.com/products', selector: 'a[href="/products"]' },
+                { ref: 2, tag: 'button', text: 'Contact Sales', selector: '#btn-contact' },
+            ],
+        });
+        // Mock Page 3: Competitor Pricing Portal
+        this.mockPages.set('https://competitor.example.com', {
+            title: 'Competitor Intelligence Portal',
+            html: `<html><head><title>Competitor Intelligence Portal</title></head><body>
+                <h1>Competitor Pricing & Tiers</h1>
+                <table class="pricing-table">
+                    <tr><th>Tier</th><th>Price</th><th>Features</th></tr>
+                    <tr><td>Starter</td><td>$29/mo</td><td>1 user, 10 tasks</td></tr>
+                    <tr><td>Pro</td><td>$99/mo</td><td>5 users, unlimited tasks</td></tr>
+                    <tr><td>Enterprise</td><td>$499/mo</td><td>Dedicated SLA, custom AI models</td></tr>
+                </table>
+                <button class="btn-signup-pro">Sign Up Pro</button>
+            </body></html>`,
+            elements: [
+                { ref: 1, tag: 'table', text: 'Pricing Tiers: Starter ($29/mo), Pro ($99/mo), Enterprise ($499/mo)', selector: 'table.pricing-table' },
+                { ref: 2, tag: 'button', text: 'Sign Up Pro', selector: 'button.btn-signup-pro' },
+            ],
+        });
+        // Mock Page 4: Vendor Invoices Portal
+        this.mockPages.set('https://portal.example.com/invoices', {
+            title: 'Vendor Invoices Portal',
+            html: `<html><head><title>Vendor Invoices Portal</title></head><body>
+                <h1>Vendor Invoices</h1>
+                <a class="download-invoice-btn" href="https://portal.example.com/downloads/INVOICE_2026_ACME.pdf">Download Invoice</a>
+            </body></html>`,
+            elements: [
+                { ref: 1, tag: 'a', text: 'Download Monthly Invoice', href: 'https://portal.example.com/downloads/INVOICE_2026_ACME.pdf', selector: 'a.download-invoice-btn' },
+            ],
+            files: {
+                'https://portal.example.com/downloads/INVOICE_2026_ACME.pdf': '%PDF-1.4 Mock Vendor Invoice September 2026 Amount Due: $3,450.00 Date: 2026-09-12',
+                'a.download-invoice-btn': '%PDF-1.4 Mock Vendor Invoice September 2026 Amount Due: $3,450.00 Date: 2026-09-12',
+            },
+        });
+        // Mock Page 5: Leads Portal
+        this.mockPages.set('https://portal.example.com/leads', {
+            title: 'Sales Leads Portal',
+            html: `<html><head><title>Sales Leads Portal</title></head><body>
+                <h1>Qualified Leads</h1>
+                <table class="leads-table">
+                    <tr><th>Name</th><th>Company</th><th>Status</th><th>MRR</th></tr>
+                    <tr><td>Alice Smith</td><td>Acme Corp</td><td>Qualified</td><td>$4,500</td></tr>
+                    <tr><td>Bob Jones</td><td>TechLabs</td><td>Proposal Sent</td><td>$8,200</td></tr>
+                    <tr><td>Carol White</td><td>GlobalCorp</td><td>Contract Signed</td><td>$12,000</td></tr>
+                </table>
+            </body></html>`,
+            elements: [
+                { ref: 1, tag: 'table', text: 'Leads: Alice Smith (Acme Corp), Bob Jones (TechLabs), Carol White (GlobalCorp)', selector: 'table.leads-table' },
+            ],
+        });
+    }
+    async navigate(url) {
+        this.actionLog.push({ action: 'navigate', params: { url } });
+        const clean = url.replace(/\/$/, '');
+        if (this.currentUrl !== 'about:blank') {
+            this.historyPast.push(this.currentUrl);
+            this.historyFuture = [];
+        }
+        this.currentUrl = url;
+        const page = this.mockPages.get(clean) || this.mockPages.get(url);
+        if (page) {
+            this.currentTitle = page.title;
+            return {
+                success: true,
+                status: 200,
+                output: `Mock navigated to "${url}". Title: "${page.title}". Found ${page.elements.length} interactive elements.`,
+                url,
+                title: page.title,
+                details: { elementsCount: page.elements.length },
+            };
+        }
+        this.currentTitle = 'Page Loaded';
+        return {
+            success: true,
+            status: 200,
+            output: `Mock navigated to "${url}". Standard web page loaded.`,
+            url,
+            title: this.currentTitle,
+        };
+    }
+    async go_back() {
+        if (this.historyPast.length === 0)
+            return { success: false, output: 'No back history' };
+        this.historyFuture.push(this.currentUrl);
+        const prev = this.historyPast.pop();
+        return await this.navigate(prev);
+    }
+    async go_forward() {
+        if (this.historyFuture.length === 0)
+            return { success: false, output: 'No forward history' };
+        this.historyPast.push(this.currentUrl);
+        const next = this.historyFuture.pop();
+        return await this.navigate(next);
+    }
+    async refresh() {
+        return await this.navigate(this.currentUrl);
+    }
+    async screenshot() {
+        return {
+            success: true,
+            output: `Mock screenshot of "${this.currentTitle}" at ${this.currentUrl}`,
+            url: this.currentUrl,
+            title: this.currentTitle,
+        };
+    }
+    async click(selectorOrText) {
+        this.actionLog.push({ action: 'click', params: { selectorOrText } });
+        const clean = this.currentUrl.replace(/\/$/, '');
+        const page = this.mockPages.get(clean) || this.mockPages.get(this.currentUrl);
+        if (!page) {
+            return { success: false, output: `Element not found matching "${selectorOrText}".` };
+        }
+        let el;
+        if (typeof selectorOrText === 'number') {
+            el = page.elements.find((e) => e.ref === selectorOrText);
+        }
+        else {
+            const target = selectorOrText.toLowerCase().trim();
+            el = page.elements.find((e) => e.selector.toLowerCase() === target ||
+                e.text.toLowerCase().includes(target) ||
+                `[ref=${e.ref}]` === target ||
+                (e.id && e.id.toLowerCase() === target));
+        }
+        if (!el) {
+            return {
+                success: false,
+                output: `Element not found matching "${selectorOrText}".`,
+            };
+        }
+        if (el.selector.includes('download') || (el.href && el.href.includes('.pdf'))) {
+            await this.download_file(el.href || el.selector);
+        }
+        if (el.href && !el.href.endsWith('.pdf')) {
+            return await this.navigate(el.href);
+        }
+        return {
+            success: true,
+            output: `Mock clicked element <${el.tag}> "${el.text}".`,
+            details: { element: el },
+        };
+    }
+    async type(selectorOrText, text) {
+        this.actionLog.push({ action: 'type', params: { selectorOrText, text } });
+        return {
+            success: true,
+            output: `Mock typed "${text}" into "${selectorOrText}".`,
+            details: { selectorOrText, text },
+        };
+    }
+    async select(selector, value) {
+        return { success: true, output: `Mock selected "${value}" for "${selector}".` };
+    }
+    async scroll(direction, amount = 4) {
+        return { success: true, output: `Mock scrolled ${direction} by ${amount}.` };
+    }
+    async extract_content(selector) {
+        const page = this.mockPages.get(this.currentUrl);
+        const text = page
+            ? page.html.replace(/<[^>]+>/g, ' ').replace(/\s+/g, ' ').trim()
+            : `Content of ${this.currentUrl}`;
+        return {
+            success: true,
+            output: text,
+            url: this.currentUrl,
+            title: this.currentTitle,
+        };
+    }
+    async download_file(urlOrSelector, destPath) {
+        this.actionLog.push({ action: 'download_file', params: { urlOrSelector, destPath } });
+        const page = this.mockPages.get(this.currentUrl);
+        let fileContent = 'Mock file content data stream';
+        let targetUrl = urlOrSelector;
+        if (page && page.files && page.files[urlOrSelector]) {
+            fileContent = page.files[urlOrSelector];
+        }
+        else if (page) {
+            const el = page.elements.find((e) => e.href && (e.text.includes(urlOrSelector) || e.selector === urlOrSelector));
+            if (el && el.href && page.files && page.files[el.href]) {
+                fileContent = page.files[el.href];
+                targetUrl = el.href;
+            }
+        }
+        const fileName = path.basename(targetUrl).includes('.') ? path.basename(targetUrl) : 'downloaded_invoice.pdf';
+        const finalPath = destPath
+            ? (path.isAbsolute(destPath) ? destPath : path.resolve(this.workspaceDir, destPath))
+            : path.resolve(this.workspaceDir, 'downloads', fileName);
+        fs.mkdirSync(path.dirname(finalPath), { recursive: true });
+        fs.writeFileSync(finalPath, fileContent, 'utf-8');
+        this.downloadedFiles.push({ filename: fileName, path: finalPath, content: fileContent });
+        return {
+            success: true,
+            output: `Mock downloaded file "${fileName}" to "${finalPath}" (${fileContent.length} bytes).`,
+            details: { path: finalPath, filename: fileName, sizeBytes: fileContent.length },
+        };
+    }
+    async upload_file(selector, filePath) {
+        return { success: true, output: `Mock uploaded file "${filePath}" to "${selector}".` };
+    }
+    async inspect_page() {
+        const page = this.mockPages.get(this.currentUrl) || {
+            title: this.currentTitle,
+            html: '<html><body>Mock Page</body></html>',
+            elements: [],
+        };
+        let summary = `Page: "${page.title}" (${this.currentUrl})\nInteractive elements (${page.elements.length}):\n`;
+        for (const el of page.elements) {
+            summary += `  [ref=${el.ref}] <${el.tag}> "${el.text}" (selector: ${el.selector})${el.href ? ` -> ${el.href}` : ''}\n`;
+        }
+        return {
+            success: true,
+            url: this.currentUrl,
+            title: page.title,
+            elements: page.elements,
+            summary,
+        };
+    }
+    async get_active_tab() {
+        return {
+            id: 'mock_tab_1',
+            url: this.currentUrl,
+            title: this.currentTitle,
+        };
+    }
+    async get_tabs() {
+        return [{ id: 'mock_tab_1', url: this.currentUrl, title: this.currentTitle }];
+    }
+    async switch_tab(tabId) {
+        return { success: true, output: `Switched to tab ${tabId}.` };
+    }
+    async close_tab(tabId) {
+        return { success: true, output: `Closed tab ${tabId}.` };
+    }
+    async getDOM() {
+        const clean = this.currentUrl.replace(/\/$/, '');
+        const page = this.mockPages.get(clean) || this.mockPages.get(this.currentUrl);
+        return {
+            url: this.currentUrl,
+            title: page ? page.title : this.currentTitle,
+            elements: page ? page.elements : [],
+        };
+    }
+    async clickElement(selectorOrText) {
+        return this.click(selectorOrText);
+    }
+    async getDownloadedFiles() {
+        return [...this.downloadedFiles];
+    }
+}
+//# sourceMappingURL=browserController.js.map