@marktoflow/integrations 2.0.0-alpha.12

package/dist/services/playwright.js

@@ -0,0 +1,1141 @@
+/**
+ * Playwright Integration
+ *
+ * Browser automation for web scraping, testing, and automation tasks.
+ * Supports Chromium, Firefox, and WebKit browsers.
+ */
+// ============================================================================
+// Playwright Client
+// ============================================================================
+/**
+ * Playwright browser automation client with session persistence and AI support
+ */
+export class PlaywrightClient {
+    playwright = null;
+    browser = null;
+    context = null;
+    page = null;
+    config;
+    stagehand = null;
+    aiBrowser = null;
+    sessionPath = null;
+    constructor(config = {}) {
+        this.config = {
+            browserType: 'chromium',
+            headless: true,
+            timeout: 30000,
+            viewport: { width: 1280, height: 720 },
+            sessionsDir: './sessions',
+            autoSaveSession: false,
+            ...config,
+        };
+    }
+    /**
+     * Get the session file path for a given session ID
+     */
+    getSessionPath(sessionId) {
+        const fs = require('fs');
+        const path = require('path');
+        const sessionsDir = this.config.sessionsDir || './sessions';
+        // Ensure sessions directory exists
+        if (!fs.existsSync(sessionsDir)) {
+            fs.mkdirSync(sessionsDir, { recursive: true });
+        }
+        return path.join(sessionsDir, `${sessionId}.json`);
+    }
+    /**
+     * Initialize and launch the browser
+     */
+    async launch() {
+        if (this.browser)
+            return;
+        // Dynamically import playwright
+        this.playwright = await import('playwright');
+        const browserType = this.config.browserType || 'chromium';
+        const launchOptions = {
+            headless: this.config.headless,
+            slowMo: this.config.slowMo,
+            timeout: this.config.timeout,
+        };
+        if (this.config.proxy) {
+            launchOptions.proxy = this.config.proxy;
+        }
+        // Connect to existing browser or launch new one
+        if (this.config.wsEndpoint) {
+            this.browser = await this.playwright[browserType].connect(this.config.wsEndpoint);
+        }
+        else {
+            this.browser = await this.playwright[browserType].launch(launchOptions);
+        }
+        // Create browser context with options
+        const contextOptions = {
+            viewport: this.config.viewport,
+            userAgent: this.config.userAgent,
+            locale: this.config.locale,
+            timezoneId: this.config.timezoneId,
+            geolocation: this.config.geolocation,
+            permissions: this.config.permissions,
+            ignoreHTTPSErrors: this.config.ignoreHTTPSErrors,
+            extraHTTPHeaders: this.config.extraHTTPHeaders,
+            recordVideo: this.config.recordVideo,
+        };
+        // Load storage state from session or file
+        if (this.config.sessionId) {
+            const sessionPath = this.getSessionPath(this.config.sessionId);
+            const fs = require('fs');
+            if (fs.existsSync(sessionPath)) {
+                contextOptions.storageState = sessionPath;
+                this.sessionPath = sessionPath;
+            }
+        }
+        else if (this.config.storageState) {
+            contextOptions.storageState = this.config.storageState;
+            this.sessionPath = this.config.storageState;
+        }
+        // Handle device emulation
+        if (this.config.deviceName && this.playwright.devices[this.config.deviceName]) {
+            Object.assign(contextOptions, this.playwright.devices[this.config.deviceName]);
+        }
+        this.context = await this.browser.newContext(contextOptions);
+        this.page = await this.context.newPage();
+    }
+    /**
+     * Ensure browser is launched
+     */
+    async ensureLaunched() {
+        if (!this.page) {
+            await this.launch();
+        }
+        return this.page;
+    }
+    /**
+     * Navigate to a URL
+     */
+    async navigate(options) {
+        const page = await this.ensureLaunched();
+        await page.goto(options.url, {
+            waitUntil: options.waitUntil || 'load',
+            timeout: options.timeout,
+            referer: options.referer,
+        });
+        return {
+            url: page.url(),
+            title: await page.title(),
+        };
+    }
+    /**
+     * Click an element
+     */
+    async click(options) {
+        const page = await this.ensureLaunched();
+        await page.click(options.selector, {
+            button: options.button,
+            clickCount: options.clickCount,
+            delay: options.delay,
+            modifiers: options.modifiers,
+            position: options.position,
+            force: options.force,
+            timeout: options.timeout,
+        });
+    }
+    /**
+     * Double click an element
+     */
+    async dblclick(options) {
+        const page = await this.ensureLaunched();
+        await page.dblclick(options.selector, {
+            button: options.button,
+            delay: options.delay,
+            modifiers: options.modifiers,
+            position: options.position,
+            force: options.force,
+            timeout: options.timeout,
+        });
+    }
+    /**
+     * Type text into an element
+     */
+    async type(options) {
+        const page = await this.ensureLaunched();
+        if (options.clear) {
+            await page.fill(options.selector, '');
+        }
+        await page.type(options.selector, options.text, {
+            delay: options.delay,
+            timeout: options.timeout,
+        });
+    }
+    /**
+     * Fill an input element with a value
+     */
+    async fill(options) {
+        const page = await this.ensureLaunched();
+        await page.fill(options.selector, options.value, {
+            force: options.force,
+            timeout: options.timeout,
+        });
+    }
+    /**
+     * Select options from a dropdown
+     */
+    async select(options) {
+        const page = await this.ensureLaunched();
+        const values = Array.isArray(options.values) ? options.values : [options.values];
+        return page.selectOption(options.selector, values, {
+            timeout: options.timeout,
+        });
+    }
+    /**
+     * Check a checkbox
+     */
+    async check(selector, options) {
+        const page = await this.ensureLaunched();
+        await page.check(selector, options);
+    }
+    /**
+     * Uncheck a checkbox
+     */
+    async uncheck(selector, options) {
+        const page = await this.ensureLaunched();
+        await page.uncheck(selector, options);
+    }
+    /**
+     * Hover over an element
+     */
+    async hover(selector, options) {
+        const page = await this.ensureLaunched();
+        await page.hover(selector, options);
+    }
+    /**
+     * Focus an element
+     */
+    async focus(selector, options) {
+        const page = await this.ensureLaunched();
+        await page.focus(selector, options);
+    }
+    /**
+     * Press a key or key combination
+     */
+    async press(selector, key, options) {
+        const page = await this.ensureLaunched();
+        await page.press(selector, key, options);
+    }
+    /**
+     * Press keyboard keys without focusing an element
+     */
+    async keyboard(key, options) {
+        const page = await this.ensureLaunched();
+        await page.keyboard.press(key, options);
+    }
+    /**
+     * Take a screenshot
+     */
+    async screenshot(options = {}) {
+        const page = await this.ensureLaunched();
+        let element = null;
+        if (options.selector) {
+            element = await page.$(options.selector);
+            if (!element) {
+                throw new Error(`Element not found: ${options.selector}`);
+            }
+        }
+        const screenshotOptions = {
+            path: options.path,
+            type: options.type || 'png',
+            quality: options.type === 'jpeg' ? options.quality : undefined,
+            fullPage: options.fullPage,
+            clip: options.clip,
+            omitBackground: options.omitBackground,
+        };
+        const buffer = element
+            ? await element.screenshot(screenshotOptions)
+            : await page.screenshot(screenshotOptions);
+        return {
+            data: buffer.toString('base64'),
+            path: options.path,
+            type: options.type || 'png',
+        };
+    }
+    /**
+     * Generate a PDF of the page (Chromium only)
+     */
+    async pdf(options = {}) {
+        const page = await this.ensureLaunched();
+        const buffer = await page.pdf({
+            path: options.path,
+            format: options.format,
+            scale: options.scale,
+            displayHeaderFooter: options.displayHeaderFooter,
+            headerTemplate: options.headerTemplate,
+            footerTemplate: options.footerTemplate,
+            printBackground: options.printBackground,
+            landscape: options.landscape,
+            pageRanges: options.pageRanges,
+            width: options.width,
+            height: options.height,
+            margin: options.margin,
+        });
+        return {
+            data: buffer.toString('base64'),
+            path: options.path,
+        };
+    }
+    /**
+     * Evaluate JavaScript in the page context
+     */
+    async evaluate(options) {
+        const page = await this.ensureLaunched();
+        // For simple expressions, evaluate directly
+        // For function expressions, wrap and call
+        if (options.expression.trim().startsWith('(') || options.expression.trim().startsWith('function')) {
+            // It's a function expression, evaluate it directly
+            return page.evaluate(options.expression, options.args);
+        }
+        else {
+            // Wrap expression in a function
+            const wrappedExpression = `() => (${options.expression})`;
+            return page.evaluate(wrappedExpression);
+        }
+    }
+    /**
+     * Wait for various conditions
+     */
+    async wait(options) {
+        const page = await this.ensureLaunched();
+        if (options.selector) {
+            await page.waitForSelector(options.selector, {
+                state: options.state,
+                timeout: options.timeout,
+            });
+        }
+        else if (options.url) {
+            await page.waitForURL(options.url, { timeout: options.timeout });
+        }
+        else if (options.function) {
+            // Wrap the function expression for evaluation
+            const wrappedFn = `() => (${options.function})`;
+            await page.waitForFunction(wrappedFn, { timeout: options.timeout });
+        }
+        else if (options.loadState) {
+            await page.waitForLoadState(options.loadState, { timeout: options.timeout });
+        }
+        else if (options.networkIdle) {
+            await page.waitForLoadState('networkidle', { timeout: options.timeout });
+        }
+        else if (options.timeout) {
+            await page.waitForTimeout(options.timeout);
+        }
+    }
+    /**
+     * Extract data from the page
+     */
+    async extract(options) {
+        const page = await this.ensureLaunched();
+        const elements = await page.$$(options.selector);
+        if (elements.length === 0) {
+            return { data: options.all ? [] : null, count: 0 };
+        }
+        const extractElement = async (el) => {
+            const result = {};
+            if (options.text) {
+                result.text = await el.textContent();
+            }
+            if (options.html) {
+                result.html = await el.innerHTML();
+            }
+            if (options.attributes) {
+                for (const attr of options.attributes) {
+                    result[attr] = await el.getAttribute(attr);
+                }
+            }
+            if (options.properties) {
+                for (const prop of options.properties) {
+                    result[prop] = await el.evaluate((e, p) => e[p], prop);
+                }
+            }
+            // If only one type of data requested, return it directly
+            const keys = Object.keys(result);
+            if (keys.length === 1) {
+                return result[keys[0]];
+            }
+            return result;
+        };
+        if (options.all) {
+            const data = await Promise.all(elements.map(extractElement));
+            return { data, count: elements.length };
+        }
+        else {
+            const data = await extractElement(elements[0]);
+            return { data, count: 1 };
+        }
+    }
+    /**
+     * Fill a form with multiple fields
+     */
+    async fillForm(options) {
+        const page = await this.ensureLaunched();
+        const formSelector = options.formSelector || 'form';
+        for (const [name, value] of Object.entries(options.fields)) {
+            const selector = `${formSelector} [name="${name}"]`;
+            if (typeof value === 'boolean') {
+                if (value) {
+                    await page.check(selector);
+                }
+                else {
+                    await page.uncheck(selector);
+                }
+            }
+            else if (Array.isArray(value)) {
+                await page.selectOption(selector, value);
+            }
+            else {
+                await page.fill(selector, value);
+            }
+        }
+        if (options.submit) {
+            await page.click(`${formSelector} [type="submit"]`);
+        }
+    }
+    /**
+     * Get or set cookies
+     */
+    async cookies(options = {}) {
+        const context = this.context;
+        if (!context) {
+            await this.ensureLaunched();
+        }
+        if (options.cookies) {
+            await this.context.addCookies(options.cookies);
+        }
+        return this.context.cookies(options.urls);
+    }
+    /**
+     * Clear cookies
+     */
+    async clearCookies() {
+        if (this.context) {
+            await this.context.clearCookies();
+        }
+    }
+    /**
+     * Manage local and session storage
+     */
+    async storage(options) {
+        const page = await this.ensureLaunched();
+        const result = {};
+        // Set local storage
+        if (options.localStorage) {
+            await page.evaluate((items) => {
+                for (const [key, value] of Object.entries(items)) {
+                    localStorage.setItem(key, value);
+                }
+            }, options.localStorage);
+        }
+        // Set session storage
+        if (options.sessionStorage) {
+            await page.evaluate((items) => {
+                for (const [key, value] of Object.entries(items)) {
+                    sessionStorage.setItem(key, value);
+                }
+            }, options.sessionStorage);
+        }
+        // Get storage
+        if (options.getStorage === 'local' || options.getStorage === 'both') {
+            result.localStorage = await page.evaluate(() => {
+                const items = {};
+                for (let i = 0; i < localStorage.length; i++) {
+                    const key = localStorage.key(i);
+                    if (key)
+                        items[key] = localStorage.getItem(key) || '';
+                }
+                return items;
+            });
+        }
+        if (options.getStorage === 'session' || options.getStorage === 'both') {
+            result.sessionStorage = await page.evaluate(() => {
+                const items = {};
+                for (let i = 0; i < sessionStorage.length; i++) {
+                    const key = sessionStorage.key(i);
+                    if (key)
+                        items[key] = sessionStorage.getItem(key) || '';
+                }
+                return items;
+            });
+        }
+        return result;
+    }
+    /**
+     * Block network requests matching patterns
+     */
+    async blockRequests(patterns) {
+        const page = await this.ensureLaunched();
+        await page.route((url) => patterns.some((p) => url.href.includes(p)), (route) => route.abort());
+    }
+    /**
+     * Intercept and modify network requests
+     */
+    async interceptRequests(handler) {
+        const page = await this.ensureLaunched();
+        await page.route('**/*', handler);
+    }
+    /**
+     * Get page content
+     */
+    async content() {
+        const page = await this.ensureLaunched();
+        return page.content();
+    }
+    /**
+     * Get page info
+     */
+    async pageInfo(includeContent = false) {
+        const page = await this.ensureLaunched();
+        return {
+            url: page.url(),
+            title: await page.title(),
+            content: includeContent ? await page.content() : undefined,
+        };
+    }
+    /**
+     * Go back in browser history
+     */
+    async goBack(options) {
+        const page = await this.ensureLaunched();
+        await page.goBack(options);
+    }
+    /**
+     * Go forward in browser history
+     */
+    async goForward(options) {
+        const page = await this.ensureLaunched();
+        await page.goForward(options);
+    }
+    /**
+     * Reload the page
+     */
+    async reload(options) {
+        const page = await this.ensureLaunched();
+        await page.reload(options);
+    }
+    /**
+     * Open a new page/tab
+     */
+    async newPage() {
+        if (!this.context) {
+            await this.ensureLaunched();
+        }
+        this.page = await this.context.newPage();
+    }
+    /**
+     * Get all open pages
+     */
+    async getPages() {
+        if (!this.context) {
+            return [];
+        }
+        const pages = this.context.pages();
+        return Promise.all(pages.map(async (p) => ({
+            url: p.url(),
+            title: await p.title(),
+        })));
+    }
+    /**
+     * Switch to a page by index or URL
+     */
+    async switchToPage(indexOrUrl) {
+        if (!this.context) {
+            throw new Error('No browser context');
+        }
+        const pages = this.context.pages();
+        let targetPage;
+        if (typeof indexOrUrl === 'number') {
+            targetPage = pages[indexOrUrl];
+        }
+        else {
+            targetPage = pages.find((p) => p.url().includes(indexOrUrl));
+        }
+        if (!targetPage) {
+            throw new Error(`Page not found: ${indexOrUrl}`);
+        }
+        this.page = targetPage;
+        return {
+            url: this.page.url(),
+            title: await this.page.title(),
+        };
+    }
+    /**
+     * Close the current page
+     */
+    async closePage() {
+        if (this.page) {
+            await this.page.close();
+            const pages = this.context?.pages() || [];
+            this.page = pages.length > 0 ? pages[pages.length - 1] : null;
+        }
+    }
+    /**
+     * Upload a file to an input element
+     */
+    async uploadFile(selector, files) {
+        const page = await this.ensureLaunched();
+        await page.setInputFiles(selector, files);
+    }
+    /**
+     * Download a file
+     */
+    async download(options) {
+        const page = await this.ensureLaunched();
+        const downloadPromise = page.waitForEvent('download');
+        if (options.selector) {
+            await page.click(options.selector);
+        }
+        else if (options.url) {
+            await page.goto(options.url);
+        }
+        const download = await downloadPromise;
+        const path = options.path || (await download.path());
+        if (options.path) {
+            await download.saveAs(options.path);
+        }
+        return {
+            path: path || '',
+            suggestedFilename: download.suggestedFilename(),
+        };
+    }
+    /**
+     * Handle dialog (alert, confirm, prompt)
+     */
+    async handleDialog(action, promptText) {
+        const page = await this.ensureLaunched();
+        page.once('dialog', async (dialog) => {
+            if (action === 'accept') {
+                await dialog.accept(promptText);
+            }
+            else {
+                await dialog.dismiss();
+            }
+        });
+    }
+    /**
+     * Emulate media type or color scheme
+     */
+    async emulateMedia(options) {
+        const page = await this.ensureLaunched();
+        await page.emulateMedia(options);
+    }
+    /**
+     * Close the browser
+     */
+    async close() {
+        // Auto-save session if configured
+        if (this.config.autoSaveSession && this.config.sessionId && this.context) {
+            await this.saveSession().catch(() => { });
+        }
+        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;
+        }
+        this.stagehand = null;
+    }
+    /**
+     * Get the underlying Playwright page for advanced usage
+     */
+    getPage() {
+        return this.page;
+    }
+    /**
+     * Get the underlying Playwright browser for advanced usage
+     */
+    getBrowser() {
+        return this.browser;
+    }
+    /**
+     * Get the underlying Playwright context for advanced usage
+     */
+    getContext() {
+        return this.context;
+    }
+    // ==========================================================================
+    // Session Management
+    // ==========================================================================
+    /**
+     * Save the current session state (cookies, localStorage, sessionStorage)
+     */
+    async saveSession(sessionIdOrPath) {
+        if (!this.context) {
+            throw new Error('No browser context to save session from');
+        }
+        let savePath;
+        if (sessionIdOrPath) {
+            // Check if it's a path or session ID
+            if (sessionIdOrPath.includes('/') || sessionIdOrPath.includes('\\') || sessionIdOrPath.endsWith('.json')) {
+                savePath = sessionIdOrPath;
+            }
+            else {
+                savePath = this.getSessionPath(sessionIdOrPath);
+            }
+        }
+        else if (this.config.sessionId) {
+            savePath = this.getSessionPath(this.config.sessionId);
+        }
+        else if (this.sessionPath) {
+            savePath = this.sessionPath;
+        }
+        else {
+            throw new Error('No session ID or path specified');
+        }
+        // Save the storage state
+        await this.context.storageState({ path: savePath });
+        this.sessionPath = savePath;
+        // Get domains from cookies
+        const cookies = await this.context.cookies();
+        const domains = [...new Set(cookies.map(c => c.domain))];
+        // Create session info
+        const sessionId = savePath.split('/').pop()?.replace('.json', '') || 'unknown';
+        const now = new Date().toISOString();
+        const sessionInfo = {
+            id: sessionId,
+            path: savePath,
+            createdAt: now,
+            lastUsedAt: now,
+            domains,
+        };
+        return sessionInfo;
+    }
+    /**
+     * Load a session state from file
+     */
+    async loadSession(sessionIdOrPath) {
+        const fs = require('fs');
+        let loadPath;
+        // Check if it's a path or session ID
+        if (sessionIdOrPath.includes('/') || sessionIdOrPath.includes('\\') || sessionIdOrPath.endsWith('.json')) {
+            loadPath = sessionIdOrPath;
+        }
+        else {
+            loadPath = this.getSessionPath(sessionIdOrPath);
+        }
+        if (!fs.existsSync(loadPath)) {
+            throw new Error(`Session file not found: ${loadPath}`);
+        }
+        // If browser is already running, we need to create a new context
+        if (this.browser) {
+            // Close existing context
+            if (this.context) {
+                await this.context.close();
+            }
+            // Create new context with session state
+            const contextOptions = {
+                viewport: this.config.viewport,
+                userAgent: this.config.userAgent,
+                locale: this.config.locale,
+                timezoneId: this.config.timezoneId,
+                storageState: loadPath,
+            };
+            this.context = await this.browser.newContext(contextOptions);
+            this.page = await this.context.newPage();
+        }
+        else {
+            // Store path for when browser is launched
+            this.config.storageState = loadPath;
+        }
+        this.sessionPath = loadPath;
+        // Read session to get info
+        const sessionData = JSON.parse(fs.readFileSync(loadPath, 'utf-8'));
+        const domains = [...new Set((sessionData.cookies || []).map((c) => c.domain))];
+        const sessionId = loadPath.split('/').pop()?.replace('.json', '') || 'unknown';
+        return {
+            id: sessionId,
+            path: loadPath,
+            createdAt: new Date().toISOString(),
+            lastUsedAt: new Date().toISOString(),
+            domains: domains,
+        };
+    }
+    /**
+     * List all saved sessions
+     */
+    async listSessions() {
+        const fs = require('fs');
+        const path = require('path');
+        const sessionsDir = this.config.sessionsDir || './sessions';
+        if (!fs.existsSync(sessionsDir)) {
+            return [];
+        }
+        const files = fs.readdirSync(sessionsDir).filter((f) => f.endsWith('.json'));
+        const sessions = [];
+        for (const file of files) {
+            const filePath = path.join(sessionsDir, file);
+            try {
+                const stat = fs.statSync(filePath);
+                const sessionData = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                const domains = [...new Set((sessionData.cookies || []).map((c) => c.domain))];
+                sessions.push({
+                    id: file.replace('.json', ''),
+                    path: filePath,
+                    createdAt: stat.birthtime.toISOString(),
+                    lastUsedAt: stat.mtime.toISOString(),
+                    domains: domains,
+                });
+            }
+            catch {
+                // Skip invalid files
+            }
+        }
+        return sessions;
+    }
+    /**
+     * Delete a saved session
+     */
+    async deleteSession(sessionId) {
+        const fs = require('fs');
+        const sessionPath = this.getSessionPath(sessionId);
+        if (fs.existsSync(sessionPath)) {
+            fs.unlinkSync(sessionPath);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if a session exists
+     */
+    hasSession(sessionId) {
+        const fs = require('fs');
+        return fs.existsSync(this.getSessionPath(sessionId));
+    }
+    // ==========================================================================
+    // AI-Powered Automation
+    // ==========================================================================
+    /**
+     * Initialize custom AI browser automation (Copilot/Claude Code)
+     */
+    async initAIBrowser() {
+        if (this.aiBrowser) {
+            return this.aiBrowser;
+        }
+        if (!this.config.enableAI) {
+            throw new Error('AI automation is not enabled. Set enableAI: true in config.');
+        }
+        if (!this.config.aiBackend || this.config.aiBackend === 'stagehand') {
+            throw new Error('Custom AI backend not configured. Set aiBackend to "copilot" or "claude-code"');
+        }
+        if (!this.config.aiClient) {
+            throw new Error(`AI client not provided. Initialize ${this.config.aiBackend} client first.`);
+        }
+        try {
+            const { AIBrowserClient } = await import('./ai-browser.js');
+            this.aiBrowser = new AIBrowserClient({
+                backend: this.config.aiBackend,
+                aiClient: this.config.aiClient,
+                playwrightClient: this,
+                debug: this.config.aiDebug,
+            });
+            return this.aiBrowser;
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize AI browser automation: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Initialize Stagehand for AI-powered automation (legacy support)
+     */
+    async initStagehand() {
+        if (this.stagehand) {
+            return this.stagehand;
+        }
+        if (!this.config.enableAI) {
+            throw new Error('AI automation is not enabled. Set enableAI: true in config.');
+        }
+        try {
+            // Dynamically import Stagehand (optional dependency)
+            // Use string variable to bypass TypeScript module resolution
+            const stagehandPackage = '@browserbasehq/stagehand';
+            let stagehandModule = null;
+            try {
+                stagehandModule = await import(stagehandPackage);
+            }
+            catch {
+                throw new Error('Stagehand is not installed. Install it with: npm install @browserbasehq/stagehand');
+            }
+            const { Stagehand } = stagehandModule;
+            // Ensure browser is launched
+            await this.ensureLaunched();
+            // Configure Stagehand
+            const stagehandConfig = {
+                env: 'LOCAL',
+                enableCaching: true,
+                debugDom: this.config.aiDebug,
+            };
+            // Set model configuration
+            if (this.config.aiProvider === 'anthropic') {
+                stagehandConfig.modelName = this.config.aiModel || 'claude-3-5-sonnet-latest';
+                stagehandConfig.modelClientOptions = {
+                    apiKey: this.config.aiApiKey || process.env.ANTHROPIC_API_KEY,
+                };
+            }
+            else {
+                // Default to OpenAI
+                stagehandConfig.modelName = this.config.aiModel || 'gpt-4o';
+                stagehandConfig.modelClientOptions = {
+                    apiKey: this.config.aiApiKey || process.env.OPENAI_API_KEY,
+                };
+            }
+            this.stagehand = new Stagehand(stagehandConfig);
+            await this.stagehand.init({ page: this.page });
+            return this.stagehand;
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize Stagehand AI. Make sure @browserbasehq/stagehand is installed: npm install @browserbasehq/stagehand\n` +
+                `Original error: ${error}`);
+        }
+    }
+    /**
+     * Perform an action using natural language (AI-powered)
+     *
+     * @example
+     * await browser.act({ instruction: 'Click the login button' })
+     * await browser.act({ instruction: 'Fill in the email field with test@example.com' })
+     */
+    async act(options) {
+        // Use custom AI backend if configured
+        if (this.config.aiBackend && this.config.aiBackend !== 'stagehand') {
+            const aiBrowser = await this.initAIBrowser();
+            try {
+                const result = await aiBrowser.act({ action: options.instruction });
+                return {
+                    success: result.success,
+                    action: result.action,
+                    element: result.message,
+                };
+            }
+            catch (error) {
+                if (options.optional) {
+                    return {
+                        success: false,
+                        error: String(error),
+                    };
+                }
+                throw error;
+            }
+        }
+        // Fall back to Stagehand
+        const stagehand = await this.initStagehand();
+        try {
+            const result = await stagehand.act({
+                action: options.instruction,
+            });
+            return {
+                success: result.success !== false,
+                action: result.action || options.instruction,
+                element: result.message,
+            };
+        }
+        catch (error) {
+            if (options.optional) {
+                return {
+                    success: false,
+                    error: String(error),
+                };
+            }
+            throw error;
+        }
+    }
+    /**
+     * Observe available actions on the page (AI-powered)
+     *
+     * @example
+     * const result = await browser.observe({ instruction: 'Find all buttons' })
+     */
+    async observe(options = {}) {
+        // Use custom AI backend if configured
+        if (this.config.aiBackend && this.config.aiBackend !== 'stagehand') {
+            const aiBrowser = await this.initAIBrowser();
+            const elements = await aiBrowser.observe({ instruction: options.instruction });
+            return {
+                elements: elements.map(el => ({
+                    description: el.description || '',
+                    selector: el.selector || '',
+                    tagName: el.tagName || 'unknown',
+                    text: el.text,
+                    actions: el.actions || ['click'],
+                })),
+            };
+        }
+        // Fall back to Stagehand
+        const stagehand = await this.initStagehand();
+        const result = await stagehand.observe({
+            instruction: options.instruction,
+        });
+        return {
+            elements: (result || []).map(el => ({
+                description: el.description || '',
+                selector: el.selector || '',
+                tagName: el.tagName || 'unknown',
+                actions: el.actions || ['click'],
+            })),
+        };
+    }
+    /**
+     * Extract structured data from the page using AI
+     *
+     * @example
+     * const data = await browser.aiExtract({
+     *   instruction: 'Extract the product name and price',
+     *   schema: { name: 'string', price: 'number' }
+     * })
+     */
+    async aiExtract(options) {
+        // Use custom AI backend if configured
+        if (this.config.aiBackend && this.config.aiBackend !== 'stagehand') {
+            const aiBrowser = await this.initAIBrowser();
+            const result = await aiBrowser.aiExtract({
+                instruction: options.instruction,
+                schema: options.schema,
+            });
+            return result.data;
+        }
+        // Fall back to Stagehand
+        const stagehand = await this.initStagehand();
+        // Convert simple schema description to format Stagehand expects
+        let schema = undefined;
+        if (options.schema) {
+            // For now, pass the schema description as-is
+            // Users can use Zod schemas if they import @browserbasehq/stagehand directly
+            schema = options.schema;
+        }
+        const result = await stagehand.extract({
+            instruction: options.instruction,
+            schema,
+        });
+        return result;
+    }
+    /**
+     * Check if AI automation is available
+     */
+    isAIEnabled() {
+        return this.config.enableAI === true;
+    }
+}
+// ============================================================================
+// SDK Initializer
+// ============================================================================
+export const PlaywrightInitializer = {
+    async initialize(_module, config) {
+        const options = config.options || {};
+        // Helper to get option with fallback key
+        const getOption = (key1, key2) => {
+            const value = options[key1] ?? (key2 ? options[key2] : undefined);
+            return value;
+        };
+        const playwrightConfig = {
+            browserType: getOption('browser_type', 'browserType'),
+            headless: getOption('headless'),
+            slowMo: getOption('slow_mo', 'slowMo'),
+            timeout: getOption('timeout'),
+            viewport: getOption('viewport'),
+            userAgent: getOption('user_agent', 'userAgent'),
+            locale: getOption('locale'),
+            timezoneId: getOption('timezone_id', 'timezoneId'),
+            geolocation: getOption('geolocation'),
+            permissions: getOption('permissions'),
+            ignoreHTTPSErrors: getOption('ignore_https_errors', 'ignoreHTTPSErrors'),
+            deviceName: getOption('device_name', 'deviceName'),
+            proxy: getOption('proxy'),
+            extraHTTPHeaders: getOption('extra_http_headers', 'extraHTTPHeaders'),
+            recordVideo: getOption('record_video', 'recordVideo'),
+            wsEndpoint: getOption('ws_endpoint', 'wsEndpoint'),
+            // Session persistence
+            storageState: getOption('storage_state', 'storageState'),
+            sessionId: getOption('session_id', 'sessionId'),
+            sessionsDir: getOption('sessions_dir', 'sessionsDir'),
+            autoSaveSession: getOption('auto_save_session', 'autoSaveSession'),
+            // AI automation
+            enableAI: getOption('enable_ai', 'enableAI'),
+            aiBackend: getOption('ai_backend', 'aiBackend'),
+            aiClient: getOption('ai_client', 'aiClient'),
+            aiProvider: getOption('ai_provider', 'aiProvider'),
+            aiModel: getOption('ai_model', 'aiModel'),
+            aiApiKey: getOption('ai_api_key', 'aiApiKey'),
+            aiDebug: getOption('ai_debug', 'aiDebug'),
+        };
+        const client = new PlaywrightClient(playwrightConfig);
+        return client;
+    },
+};
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * Create a Playwright client with default options
+ */
+export function createPlaywrightClient(config) {
+    return new PlaywrightClient(config);
+}
+/**
+ * Quick web scraping helper
+ */
+export async function scrape(url, selectors, options) {
+    const client = new PlaywrightClient(options);
+    try {
+        await client.navigate({ url });
+        const result = {};
+        for (const [key, selector] of Object.entries(selectors)) {
+            const extracted = await client.extract({ selector, text: true, all: true });
+            result[key] = extracted.data;
+        }
+        return result;
+    }
+    finally {
+        await client.close();
+    }
+}
+/**
+ * Quick screenshot helper
+ */
+export async function screenshotUrl(url, options) {
+    const { path, type, quality, fullPage, selector, clip, omitBackground, ...config } = options || {};
+    const client = new PlaywrightClient(config);
+    try {
+        await client.navigate({ url });
+        return client.screenshot({ path, type, quality, fullPage, selector, clip, omitBackground });
+    }
+    finally {
+        await client.close();
+    }
+}
+/**
+ * Quick PDF generation helper
+ */
+export async function pdfUrl(url, options) {
+    const { path, format, scale, displayHeaderFooter, headerTemplate, footerTemplate, printBackground, landscape, pageRanges, width, height, margin, ...config } = options || {};
+    const client = new PlaywrightClient({ ...config, browserType: 'chromium' }); // PDF only works in Chromium
+    try {
+        await client.navigate({ url });
+        return client.pdf({
+            path,
+            format,
+            scale,
+            displayHeaderFooter,
+            headerTemplate,
+            footerTemplate,
+            printBackground,
+            landscape,
+            pageRanges,
+            width,
+            height,
+            margin,
+        });
+    }
+    finally {
+        await client.close();
+    }
+}
+//# sourceMappingURL=playwright.js.map