cowork-os 0.3.21

package/dist/electron/electron/agent/browser/browser-service.js

@@ -0,0 +1,639 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserService = void 0;
+const playwright_1 = require("playwright");
+const path = __importStar(require("path"));
+const guardrail_manager_1 = require("../../guardrails/guardrail-manager");
+/**
+ * BrowserService provides browser automation capabilities using Playwright
+ */
+class BrowserService {
+    constructor(workspace, options = {}) {
+        this.browser = null;
+        this.context = null;
+        this.page = null;
+        this.workspace = workspace;
+        this.options = {
+            headless: options.headless ?? true,
+            timeout: options.timeout ?? 30000,
+            viewport: options.viewport ?? { width: 1280, height: 720 }
+        };
+    }
+    /**
+     * Initialize the browser
+     * Uses try-finally to ensure cleanup on errors
+     */
+    async init() {
+        if (this.browser)
+            return;
+        let browser = null;
+        let context = null;
+        try {
+            browser = await playwright_1.chromium.launch({
+                headless: this.options.headless
+            });
+            context = await browser.newContext({
+                viewport: this.options.viewport,
+                userAgent: 'CoWork OS Browser Automation'
+            });
+            const page = await context.newPage();
+            page.setDefaultTimeout(this.options.timeout);
+            // Only assign to instance variables after all operations succeed
+            this.browser = browser;
+            this.context = context;
+            this.page = page;
+        }
+        catch (error) {
+            // Cleanup partial initialization on error
+            if (context) {
+                await context.close().catch(() => { });
+            }
+            if (browser) {
+                await browser.close().catch(() => { });
+            }
+            throw error;
+        }
+    }
+    /**
+     * Navigate to a URL
+     */
+    async navigate(url, waitUntil = 'load') {
+        // Check if domain is allowed by guardrails
+        if (!guardrail_manager_1.GuardrailManager.isDomainAllowed(url)) {
+            const settings = guardrail_manager_1.GuardrailManager.loadSettings();
+            const allowedDomainsStr = settings.allowedDomains.length > 0
+                ? settings.allowedDomains.join(', ')
+                : '(none configured)';
+            throw new Error(`Domain not allowed: "${url}"\n` +
+                `Allowed domains: ${allowedDomainsStr}\n` +
+                `You can modify allowed domains in Settings > Guardrails.`);
+        }
+        await this.ensurePage();
+        const response = await this.page.goto(url, { waitUntil });
+        const status = response?.status() ?? null;
+        // Validate HTTP status code - warn on client/server errors
+        if (status && status >= 400) {
+            const statusMessage = status >= 500
+                ? `Server error (${status})`
+                : `Client error (${status})`;
+            console.warn(`[BrowserService] Navigation to ${url} returned ${statusMessage}`);
+        }
+        // Auto-dismiss cookie consent popups
+        await this.dismissConsentPopups();
+        return {
+            url: this.page.url(),
+            title: await this.page.title(),
+            status,
+            // Include error flag for status codes >= 400
+            isError: status !== null && status >= 400
+        };
+    }
+    /**
+     * Attempt to dismiss cookie consent popups
+     * Tries common patterns found on most websites
+     */
+    async dismissConsentPopups() {
+        if (!this.page)
+            return;
+        try {
+            // Common consent button selectors and text patterns
+            const consentButtonSelectors = [
+                // Common button IDs and classes
+                '#L2AGLb', // Google consent "Accept all"
+                '#onetrust-accept-btn-handler',
+                '#accept-all-cookies',
+                '#acceptAllCookies',
+                '.accept-cookies',
+                '.accept-all',
+                '[data-testid="cookie-policy-dialog-accept-button"]',
+                '[data-testid="GDPR-accept"]',
+                '.cookie-consent-accept',
+                '.cookie-banner-accept',
+                '.consent-accept',
+                '#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll',
+                '.cc-accept',
+                '.cc-btn.cc-allow',
+                '#didomi-notice-agree-button',
+                '.evidon-barrier-acceptall',
+                // Aria labels
+                '[aria-label="Accept all cookies"]',
+                '[aria-label="Accept cookies"]',
+                '[aria-label="Accept all"]',
+                '[aria-label="Aceitar tudo"]',
+                '[aria-label="Rejeitar tudo"]',
+                '[aria-label="Reject all"]',
+                // Data attributes
+                '[data-action="accept"]',
+                '[data-consent="accept"]',
+            ];
+            // Try each selector
+            for (const selector of consentButtonSelectors) {
+                try {
+                    const button = await this.page.$(selector);
+                    if (button) {
+                        await button.click();
+                        console.log(`[BrowserService] Dismissed consent popup using selector: ${selector}`);
+                        // Wait a bit for the popup to close
+                        await this.page.waitForTimeout(500);
+                        return;
+                    }
+                }
+                catch {
+                    // Selector not found or not clickable, continue
+                }
+            }
+            // Try text-based matching for common button texts
+            const buttonTexts = [
+                'Accept all',
+                'Accept All',
+                'Accept all cookies',
+                'Accept All Cookies',
+                'Allow all',
+                'Allow All',
+                'Allow all cookies',
+                'I agree',
+                'I Accept',
+                'Got it',
+                'OK',
+                'Agree',
+                'Accept',
+                'Consent',
+                'Continue',
+                'Yes, I agree',
+                'Reject all',
+                'Reject All',
+                'Rejeitar tudo',
+                'Aceitar tudo',
+                'Recusar tudo',
+                'Accetto',
+                'Akzeptieren',
+                'Accepter',
+                'Aceptar',
+            ];
+            for (const text of buttonTexts) {
+                try {
+                    // Look for buttons with exact or partial text match
+                    const button = await this.page.$(`button:has-text("${text}"), a:has-text("${text}"), [role="button"]:has-text("${text}")`);
+                    if (button) {
+                        // Verify the button is visible and in a consent-like context
+                        const isVisible = await button.isVisible();
+                        if (isVisible) {
+                            await button.click();
+                            console.log(`[BrowserService] Dismissed consent popup with button text: "${text}"`);
+                            await this.page.waitForTimeout(500);
+                            return;
+                        }
+                    }
+                }
+                catch {
+                    // Not found, continue
+                }
+            }
+            // As a last resort, try to remove common overlay elements via JavaScript
+            await this.page.evaluate(`
+        (() => {
+          // Common consent popup container selectors
+          const overlaySelectors = [
+            '#onetrust-consent-sdk',
+            '#onetrust-banner-sdk',
+            '.cookie-consent',
+            '.cookie-banner',
+            '.consent-banner',
+            '.gdpr-consent',
+            '.privacy-consent',
+            '[class*="cookie-consent"]',
+            '[class*="cookie-banner"]',
+            '[class*="consent-modal"]',
+            '[id*="cookie-consent"]',
+            '[id*="cookie-banner"]',
+            '#CybotCookiebotDialog',
+            '.cc-window',
+            '#didomi-host',
+            '.evidon-consent-banner',
+          ];
+
+          for (const selector of overlaySelectors) {
+            const elements = document.querySelectorAll(selector);
+            elements.forEach(el => el.remove());
+          }
+
+          // Also remove any fixed/sticky overlays that might be blocking
+          document.querySelectorAll('[style*="position: fixed"], [style*="position:fixed"]').forEach(el => {
+            const text = el.textContent?.toLowerCase() || '';
+            if (text.includes('cookie') || text.includes('consent') || text.includes('privacy') || text.includes('gdpr')) {
+              el.remove();
+            }
+          });
+
+          // Re-enable scrolling if it was disabled
+          document.body.style.overflow = '';
+          document.documentElement.style.overflow = '';
+        })()
+      `);
+        }
+        catch (error) {
+            // Silently fail - consent popup handling is best-effort
+            console.log('[BrowserService] Could not dismiss consent popup:', error);
+        }
+    }
+    /**
+     * Take a screenshot
+     */
+    async screenshot(filename, fullPage = false) {
+        await this.ensurePage();
+        const screenshotName = filename || `screenshot-${Date.now()}.png`;
+        const screenshotPath = path.join(this.workspace.path, screenshotName);
+        await this.page.screenshot({
+            path: screenshotPath,
+            fullPage
+        });
+        const viewport = this.page.viewportSize();
+        const pageHeight = fullPage
+            ? await this.page.evaluate('document.body.scrollHeight')
+            : (viewport?.height ?? this.options.viewport.height);
+        return {
+            path: screenshotName,
+            width: viewport?.width ?? this.options.viewport.width,
+            height: pageHeight
+        };
+    }
+    /**
+     * Get the current page URL
+     */
+    async getCurrentUrl() {
+        await this.ensurePage();
+        return this.page.url();
+    }
+    /**
+     * Get page content as text
+     */
+    async getContent() {
+        await this.ensurePage();
+        const url = this.page.url();
+        const title = await this.page.title();
+        // Get visible text content
+        const text = await this.page.evaluate(`
+      (() => {
+        const body = document.body;
+        const clone = body.cloneNode(true);
+        clone.querySelectorAll('script, style, noscript').forEach(el => el.remove());
+        return clone.innerText.replace(/\\s+/g, ' ').trim().slice(0, 10000);
+      })()
+    `);
+        // Get links
+        const links = await this.page.evaluate(`
+      (() => {
+        const anchors = document.querySelectorAll('a[href]');
+        return Array.from(anchors).slice(0, 50).map(a => ({
+          text: (a.textContent || '').trim().slice(0, 100),
+          href: a.href
+        })).filter(l => l.text && l.href);
+      })()
+    `);
+        // Get forms
+        const forms = await this.page.evaluate(`
+      (() => {
+        const formElements = document.querySelectorAll('form');
+        return Array.from(formElements).slice(0, 10).map(form => ({
+          action: form.action || '',
+          method: form.method || 'get',
+          inputs: Array.from(form.querySelectorAll('input, textarea, select')).slice(0, 20).map(input => {
+            return input.tagName.toLowerCase() + '[name="' + (input.name || '') + '"][type="' + (input.type || 'text') + '"]';
+          })
+        }));
+      })()
+    `);
+        return { url, title, text, links, forms };
+    }
+    /**
+     * Click on an element
+     */
+    async click(selector) {
+        await this.ensurePage();
+        try {
+            await this.page.click(selector, { timeout: this.options.timeout });
+            const element = await this.page.$(selector);
+            const text = element ? await element.textContent() : '';
+            return {
+                success: true,
+                element: text?.trim().slice(0, 100)
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                element: error.message
+            };
+        }
+    }
+    /**
+     * Fill a form field
+     */
+    async fill(selector, value) {
+        await this.ensurePage();
+        try {
+            await this.page.fill(selector, value, { timeout: this.options.timeout });
+            return {
+                success: true,
+                selector,
+                value
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                selector,
+                value: error.message
+            };
+        }
+    }
+    /**
+     * Type text (with key events)
+     */
+    async type(selector, text, delay = 50) {
+        await this.ensurePage();
+        try {
+            await this.page.type(selector, text, { delay });
+            return {
+                success: true,
+                selector,
+                value: text
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                selector,
+                value: error.message
+            };
+        }
+    }
+    /**
+     * Press a key
+     */
+    async press(key) {
+        await this.ensurePage();
+        try {
+            await this.page.keyboard.press(key);
+            return { success: true, key };
+        }
+        catch (error) {
+            return { success: false, key: error.message };
+        }
+    }
+    /**
+     * Wait for an element to appear
+     */
+    async waitForSelector(selector, timeout) {
+        await this.ensurePage();
+        try {
+            await this.page.waitForSelector(selector, { timeout: timeout ?? this.options.timeout });
+            return { success: true, selector };
+        }
+        catch (error) {
+            return { success: false, selector: error.message };
+        }
+    }
+    /**
+     * Wait for navigation
+     */
+    async waitForNavigation(timeout) {
+        await this.ensurePage();
+        try {
+            await this.page.waitForLoadState('load', { timeout: timeout ?? this.options.timeout });
+            return { success: true, url: this.page.url() };
+        }
+        catch (error) {
+            return { success: false, url: error.message };
+        }
+    }
+    /**
+     * Get element text
+     */
+    async getText(selector) {
+        await this.ensurePage();
+        try {
+            const element = await this.page.$(selector);
+            if (!element) {
+                return { success: false, text: 'Element not found' };
+            }
+            const text = await element.textContent();
+            return { success: true, text: text?.trim() ?? '' };
+        }
+        catch (error) {
+            return { success: false, text: error.message };
+        }
+    }
+    /**
+     * Get element attribute
+     */
+    async getAttribute(selector, attribute) {
+        await this.ensurePage();
+        try {
+            const value = await this.page.getAttribute(selector, attribute);
+            return { success: true, value };
+        }
+        catch (error) {
+            return { success: false, value: error.message };
+        }
+    }
+    /**
+     * Evaluate JavaScript in the page
+     */
+    async evaluate(script) {
+        await this.ensurePage();
+        try {
+            const result = await this.page.evaluate((code) => {
+                return eval(code);
+            }, script);
+            return { success: true, result };
+        }
+        catch (error) {
+            return { success: false, result: error.message };
+        }
+    }
+    /**
+     * Select option from dropdown
+     */
+    async select(selector, value) {
+        await this.ensurePage();
+        try {
+            await this.page.selectOption(selector, value);
+            return { success: true, selector, value };
+        }
+        catch (error) {
+            return { success: false, selector, value: error.message };
+        }
+    }
+    /**
+     * Check or uncheck a checkbox
+     */
+    async check(selector, checked = true) {
+        await this.ensurePage();
+        try {
+            if (checked) {
+                await this.page.check(selector);
+            }
+            else {
+                await this.page.uncheck(selector);
+            }
+            return { success: true, selector, checked };
+        }
+        catch (error) {
+            return { success: false, selector, checked: false };
+        }
+    }
+    /**
+     * Scroll the page
+     */
+    async scroll(direction, amount) {
+        await this.ensurePage();
+        try {
+            const scrollAmount = amount || 500;
+            let script;
+            switch (direction) {
+                case 'up':
+                    script = `window.scrollBy(0, -${scrollAmount})`;
+                    break;
+                case 'down':
+                    script = `window.scrollBy(0, ${scrollAmount})`;
+                    break;
+                case 'top':
+                    script = `window.scrollTo(0, 0)`;
+                    break;
+                case 'bottom':
+                    script = `window.scrollTo(0, document.body.scrollHeight)`;
+                    break;
+            }
+            await this.page.evaluate(script);
+            return { success: true };
+        }
+        catch (error) {
+            return { success: false };
+        }
+    }
+    /**
+     * Go back in browser history
+     */
+    async goBack() {
+        await this.ensurePage();
+        await this.page.goBack();
+        return {
+            url: this.page.url(),
+            title: await this.page.title(),
+            status: null
+        };
+    }
+    /**
+     * Go forward in browser history
+     */
+    async goForward() {
+        await this.ensurePage();
+        await this.page.goForward();
+        return {
+            url: this.page.url(),
+            title: await this.page.title(),
+            status: null
+        };
+    }
+    /**
+     * Reload the page
+     */
+    async reload() {
+        await this.ensurePage();
+        const response = await this.page.reload();
+        return {
+            url: this.page.url(),
+            title: await this.page.title(),
+            status: response?.status() ?? null
+        };
+    }
+    /**
+     * Get page HTML
+     */
+    async getHtml() {
+        await this.ensurePage();
+        return await this.page.content();
+    }
+    /**
+     * Save page as PDF
+     */
+    async savePdf(filename) {
+        await this.ensurePage();
+        const pdfName = filename || `page-${Date.now()}.pdf`;
+        const pdfPath = path.join(this.workspace.path, pdfName);
+        await this.page.pdf({ path: pdfPath, format: 'A4' });
+        return { path: pdfName };
+    }
+    /**
+     * Get current URL
+     */
+    getUrl() {
+        return this.page?.url() ?? '';
+    }
+    /**
+     * Check if browser is open
+     */
+    isOpen() {
+        return this.browser !== null && this.page !== null;
+    }
+    /**
+     * Close the browser
+     */
+    async close() {
+        if (this.page) {
+            await this.page.close().catch(() => { });
+            this.page = null;
+        }
+        if (this.context) {
+            await this.context.close().catch(() => { });
+            this.context = null;
+        }
+        if (this.browser) {
+            await this.browser.close().catch(() => { });
+            this.browser = null;
+        }
+    }
+    /**
+     * Ensure page is initialized
+     */
+    async ensurePage() {
+        if (!this.page) {
+            await this.init();
+        }
+    }
+}
+exports.BrowserService = BrowserService;