@olib-ai/owl-browser-sdk 1.0.0

package/dist/context.js

@@ -0,0 +1,1017 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserContext = void 0;
+/**
+ * Browser context (tab/window) for automation
+ */
+class BrowserContext {
+    constructor(contextId, core) {
+        this.contextId = contextId;
+        this.core = core;
+    }
+    /**
+     * Get the context ID
+     */
+    getId() {
+        return this.contextId;
+    }
+    // ==================== NAVIGATION ====================
+    /**
+     * Navigate to a URL
+     * @param url - URL to navigate to
+     * @param options - Navigation options
+     */
+    async goto(url, options) {
+        // Auto-add protocol if missing
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            url = 'https://' + url;
+        }
+        await this.core.sendCommand('navigate', {
+            context_id: this.contextId,
+            url,
+        });
+    }
+    /**
+     * Reload the current page
+     * @param ignoreCache - Bypass cache (hard reload)
+     */
+    async reload(ignoreCache = false) {
+        await this.core.sendCommand('reload', {
+            context_id: this.contextId,
+            ignore_cache: ignoreCache,
+        });
+    }
+    /**
+     * Navigate back in history
+     */
+    async goBack() {
+        await this.core.sendCommand('goBack', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Navigate forward in history
+     */
+    async goForward() {
+        await this.core.sendCommand('goForward', {
+            context_id: this.contextId,
+        });
+    }
+    // ==================== INTERACTIONS ====================
+    /**
+     * Click an element using CSS selector, position coordinates, or natural language description
+     * @param selector - CSS selector, position coordinates (e.g., "100x200"), or natural description (e.g., "search button", "login link")
+     */
+    async click(selector) {
+        await this.core.sendCommand('click', {
+            context_id: this.contextId,
+            selector,
+        });
+    }
+    /**
+     * Type text into an input field
+     * @param selector - CSS selector, position coordinates (e.g., "100x200"), or natural description (e.g., "search box", "email input")
+     * @param text - Text to type
+     */
+    async type(selector, text) {
+        await this.core.sendCommand('type', {
+            context_id: this.contextId,
+            selector,
+            text,
+        });
+    }
+    /**
+     * Select an option from a dropdown/select element
+     * @param selector - CSS selector or natural description (e.g., "country dropdown", "state list")
+     * @param value - Value or visible text of the option to select (e.g., "Morocco", "California")
+     */
+    async pick(selector, value) {
+        await this.core.sendCommand('pick', {
+            context_id: this.contextId,
+            selector,
+            value,
+        });
+    }
+    /**
+     * Press a special key
+     * @param key - Key name (e.g., 'Enter', 'Tab', 'Escape')
+     */
+    async pressKey(key) {
+        await this.core.sendCommand('pressKey', {
+            context_id: this.contextId,
+            key,
+        });
+    }
+    /**
+     * Submit the currently focused form by pressing Enter
+     * Useful for search boxes and forms that submit on Enter
+     */
+    async submitForm() {
+        await this.core.sendCommand('submitForm', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Highlight an element for debugging
+     * @param selector - CSS selector or natural description
+     * @param borderColor - Border color (default: "#FF0000")
+     * @param backgroundColor - Background color (default: "rgba(255, 0, 0, 0.2)")
+     */
+    async highlight(selector, borderColor = '#FF0000', backgroundColor = 'rgba(255, 0, 0, 0.2)') {
+        await this.core.sendCommand('highlight', {
+            context_id: this.contextId,
+            selector,
+            border_color: borderColor,
+            background_color: backgroundColor,
+        });
+    }
+    // ==================== CONTENT EXTRACTION ====================
+    /**
+     * Extract text content from the page
+     * @param selector - CSS selector or natural description (default: 'body')
+     */
+    async extractText(selector = 'body') {
+        return await this.core.sendCommand('extractText', {
+            context_id: this.contextId,
+            selector,
+        });
+    }
+    /**
+     * Get HTML content from the page
+     * @param cleanLevel - Cleaning level: 'minimal', 'basic', or 'aggressive'
+     */
+    async getHTML(cleanLevel = 'basic') {
+        return await this.core.sendCommand('getHTML', {
+            context_id: this.contextId,
+            clean_level: cleanLevel,
+        });
+    }
+    /**
+     * Get page content as Markdown
+     * @param options - Markdown extraction options
+     */
+    async getMarkdown(options) {
+        return await this.core.sendCommand('getMarkdown', {
+            context_id: this.contextId,
+            include_links: options?.includeLinks ?? true,
+            include_images: options?.includeImages ?? true,
+            max_length: options?.maxLength ?? -1,
+        });
+    }
+    /**
+     * Extract structured JSON data using templates
+     * @param template - Template name or empty for auto-detection
+     */
+    async extractJSON(template = '') {
+        const result = await this.core.sendCommand('extractJSON', {
+            context_id: this.contextId,
+            template_name: template,
+        });
+        return result;
+    }
+    /**
+     * Detect website type
+     */
+    async detectWebsiteType() {
+        return await this.core.sendCommand('detectWebsiteType', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Get intelligent, structured summary of the current page using LLM
+     * The summary is cached per URL for fast repeat access
+     * @param forceRefresh - Force refresh the summary (ignore cache)
+     */
+    async summarizePage(forceRefresh = false) {
+        return await this.core.sendCommand('summarizePage', {
+            context_id: this.contextId,
+            force_refresh: forceRefresh,
+        });
+    }
+    /**
+     * List all available extraction templates
+     */
+    async listTemplates() {
+        return await this.core.sendCommand('listTemplates', {});
+    }
+    // ==================== AI FEATURES ====================
+    /**
+     * Query the page using on-device LLM
+     * @param query - Natural language question about the page
+     */
+    async queryPage(query) {
+        // Let the browser handle LLM readiness - it will wait internally
+        return await this.core.sendCommand('queryPage', {
+            context_id: this.contextId,
+            query,
+        });
+    }
+    /**
+     * Check if the on-device LLM is ready to use
+     * @returns Status: "ready", "loading", or "unavailable"
+     */
+    async llmStatus() {
+        return await this.core.sendCommand('llmStatus', {});
+    }
+    /**
+     * Execute natural language automation command
+     * @param command - Natural language command (e.g., "go to google.com and search for banana")
+     */
+    async executeNLA(command) {
+        // Let the browser handle LLM readiness and execution - it will wait internally
+        return await this.core.sendCommand('executeNLA', {
+            context_id: this.contextId,
+            query: command,
+        });
+    }
+    // ==================== SCREENSHOT & VIDEO ====================
+    /**
+     * Take a screenshot
+     * @param options - Screenshot options
+     * @returns Buffer (or void if path is specified)
+     */
+    async screenshot(options) {
+        const result = await this.core.sendCommand('screenshot', {
+            context_id: this.contextId,
+        });
+        const buffer = Buffer.from(result, 'base64');
+        // If path is specified, save to file
+        if (options?.path) {
+            const fs = require('fs');
+            fs.writeFileSync(options.path, buffer);
+            return;
+        }
+        return buffer;
+    }
+    /**
+     * Start video recording
+     * @param options - Video recording options
+     */
+    async startVideoRecording(options) {
+        await this.core.sendCommand('startVideoRecording', {
+            context_id: this.contextId,
+            fps: options?.fps ?? 30,
+            codec: options?.codec ?? 'libx264',
+        });
+    }
+    /**
+     * Pause video recording
+     */
+    async pauseVideoRecording() {
+        await this.core.sendCommand('pauseVideoRecording', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Resume video recording
+     */
+    async resumeVideoRecording() {
+        await this.core.sendCommand('resumeVideoRecording', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Stop video recording and get video path
+     */
+    async stopVideoRecording() {
+        return await this.core.sendCommand('stopVideoRecording', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Get video recording statistics
+     */
+    async getVideoStats() {
+        return await this.core.sendCommand('getVideoRecordingStats', {
+            context_id: this.contextId,
+        });
+    }
+    // ==================== SCROLLING ====================
+    /**
+     * Scroll by specified pixels
+     * @param x - Horizontal scroll amount
+     * @param y - Vertical scroll amount
+     */
+    async scrollBy(x, y) {
+        await this.core.sendCommand('scrollBy', {
+            context_id: this.contextId,
+            x,
+            y,
+        });
+    }
+    /**
+     * Scroll to absolute position
+     * @param x - Horizontal position
+     * @param y - Vertical position
+     */
+    async scrollTo(x, y) {
+        await this.core.sendCommand('scrollTo', {
+            context_id: this.contextId,
+            x,
+            y,
+        });
+    }
+    /**
+     * Scroll element into view
+     * @param selector - CSS selector or natural description
+     */
+    async scrollToElement(selector) {
+        await this.core.sendCommand('scrollToElement', {
+            context_id: this.contextId,
+            selector,
+        });
+    }
+    /**
+     * Scroll to top of page
+     */
+    async scrollToTop() {
+        await this.core.sendCommand('scrollToTop', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Scroll to bottom of page
+     */
+    async scrollToBottom() {
+        await this.core.sendCommand('scrollToBottom', {
+            context_id: this.contextId,
+        });
+    }
+    // ==================== WAITING ====================
+    /**
+     * Wait for element to appear
+     * @param selector - CSS selector or natural description
+     * @param options - Wait options
+     */
+    async waitForSelector(selector, options) {
+        await this.core.sendCommand('waitForSelector', {
+            context_id: this.contextId,
+            selector,
+            timeout: options?.timeout ?? 5000,
+        });
+    }
+    /**
+     * Wait for specified time (use sparingly - prefer waitForSelector)
+     * @param timeout - Time to wait in milliseconds
+     */
+    async wait(timeout) {
+        // Only use when explicitly needed by user
+        await this.core.sendCommand('waitForTimeout', {
+            context_id: this.contextId,
+            timeout,
+        });
+    }
+    // ==================== PAGE STATE ====================
+    /**
+     * Get current URL
+     */
+    async getCurrentURL() {
+        return await this.core.sendCommand('getCurrentURL', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Get page title
+     */
+    async getTitle() {
+        return await this.core.sendCommand('getPageTitle', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Get comprehensive page information
+     */
+    async getPageInfo() {
+        return await this.core.sendCommand('getPageInfo', {
+            context_id: this.contextId,
+        });
+    }
+    // ==================== VIEWPORT ====================
+    /**
+     * Set viewport size
+     * @param viewport - Viewport dimensions
+     */
+    async setViewport(viewport) {
+        await this.core.sendCommand('setViewport', {
+            context_id: this.contextId,
+            width: viewport.width,
+            height: viewport.height,
+        });
+    }
+    /**
+     * Get current viewport size
+     */
+    async getViewport() {
+        return await this.core.sendCommand('getViewport', {
+            context_id: this.contextId,
+        });
+    }
+    // ==================== DEMOGRAPHICS ====================
+    /**
+     * Get user demographics and context (location, time, weather)
+     * Useful for location-aware searches like "find me a restaurant" or "book a hotel"
+     */
+    async getDemographics() {
+        return await this.core.sendCommand('getDemographics', {});
+    }
+    /**
+     * Get user's current location based on IP address
+     */
+    async getLocation() {
+        return await this.core.sendCommand('getLocation', {});
+    }
+    /**
+     * Get current date and time information
+     */
+    async getDateTime() {
+        return await this.core.sendCommand('getDateTime', {});
+    }
+    /**
+     * Get current weather for the user's location
+     */
+    async getWeather() {
+        return await this.core.sendCommand('getWeather', {});
+    }
+    // ==================== CAPTCHA SOLVING ====================
+    /**
+     * Detect if the current page has a CAPTCHA using heuristic analysis
+     * @returns Detection result with confidence score
+     */
+    async detectCaptcha() {
+        return await this.core.sendCommand('detectCaptcha', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Classify the type of CAPTCHA on the page
+     * @returns Classification result with CAPTCHA type and element selectors
+     */
+    async classifyCaptcha() {
+        return await this.core.sendCommand('classifyCaptcha', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Solve a text-based CAPTCHA using vision model
+     * @param maxAttempts - Maximum number of attempts (default: 3)
+     */
+    async solveTextCaptcha(maxAttempts = 3) {
+        return await this.core.sendCommand('solveTextCaptcha', {
+            context_id: this.contextId,
+            max_attempts: maxAttempts,
+        });
+    }
+    /**
+     * Solve an image-selection CAPTCHA (e.g., "select all images with traffic lights")
+     * @param maxAttempts - Maximum number of attempts (default: 3)
+     */
+    async solveImageCaptcha(maxAttempts = 3) {
+        return await this.core.sendCommand('solveImageCaptcha', {
+            context_id: this.contextId,
+            max_attempts: maxAttempts,
+        });
+    }
+    /**
+     * Auto-detect and solve any supported CAPTCHA type
+     * Automatically detects, classifies, and solves the CAPTCHA
+     * @param maxAttempts - Maximum number of attempts (default: 3)
+     */
+    async solveCaptcha(maxAttempts = 3) {
+        return await this.core.sendCommand('solveCaptcha', {
+            context_id: this.contextId,
+            max_attempts: maxAttempts,
+        });
+    }
+    // ==================== TEST EXECUTION ====================
+    /**
+     * Execute a test from Developer Playground JSON template
+     * @param test - Test template (JSON object or file path)
+     * @param options - Execution options
+     * @returns Test execution result
+     *
+     * @example
+     * ```typescript
+     * // Load test from JSON file
+     * const testJson = JSON.parse(fs.readFileSync('test.json', 'utf-8'));
+     * const result = await page.runTest(testJson);
+     * console.log(`Test: ${result.testName}`);
+     * console.log(`Success: ${result.successfulSteps}/${result.totalSteps}`);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Define test inline
+     * const test = {
+     *   name: "Login Test",
+     *   description: "Test user login flow",
+     *   steps: [
+     *     { type: "navigate", url: "https://example.com/login" },
+     *     { type: "type", selector: "#email", text: "user@example.com" },
+     *     { type: "type", selector: "#password", text: "password123" },
+     *     { type: "click", selector: "button[type='submit']" },
+     *     { type: "wait", duration: 2000 },
+     *     { type: "screenshot", filename: "after-login.png" }
+     *   ]
+     * };
+     * const result = await page.runTest(test);
+     * ```
+     */
+    async runTest(test, options) {
+        // Parse test if string (file path)
+        let testData;
+        if (typeof test === 'string') {
+            const fs = require('fs');
+            testData = JSON.parse(fs.readFileSync(test, 'utf-8'));
+        }
+        else {
+            testData = test;
+        }
+        const opts = {
+            continueOnError: options?.continueOnError ?? false,
+            screenshotOnError: options?.screenshotOnError ?? true,
+            verbose: options?.verbose ?? false,
+        };
+        const result = {
+            testName: testData.name,
+            totalSteps: testData.steps.filter(s => s.selected !== false).length,
+            executedSteps: 0,
+            successfulSteps: 0,
+            failedSteps: 0,
+            executionTime: 0,
+            success: true,
+            errors: [],
+        };
+        const startTime = Date.now();
+        if (opts.verbose) {
+            console.log(`[Test] Starting: ${testData.name}`);
+            if (testData.description) {
+                console.log(`[Test] Description: ${testData.description}`);
+            }
+        }
+        for (let i = 0; i < testData.steps.length; i++) {
+            const step = testData.steps[i];
+            // Skip unselected steps
+            if (step.selected === false) {
+                if (opts.verbose) {
+                    console.log(`[Test] Step ${i + 1}: Skipped (not selected)`);
+                }
+                continue;
+            }
+            result.executedSteps++;
+            if (opts.verbose) {
+                console.log(`[Test] Step ${i + 1}/${result.totalSteps}: ${step.type}`);
+            }
+            try {
+                switch (step.type) {
+                    case 'navigate':
+                        if (!step.url)
+                            throw new Error('Navigate step requires url');
+                        await this.goto(step.url);
+                        break;
+                    case 'click':
+                        if (!step.selector)
+                            throw new Error('Click step requires selector');
+                        await this.click(step.selector);
+                        break;
+                    case 'type':
+                        if (!step.selector)
+                            throw new Error('Type step requires selector');
+                        if (!step.text)
+                            throw new Error('Type step requires text');
+                        await this.type(step.selector, step.text);
+                        break;
+                    case 'pick':
+                        if (!step.selector)
+                            throw new Error('Pick step requires selector');
+                        if (!step.value)
+                            throw new Error('Pick step requires value');
+                        await this.pick(step.selector, step.value);
+                        break;
+                    case 'wait':
+                        const duration = step.duration ?? 2000;
+                        await this.wait(duration);
+                        break;
+                    case 'screenshot':
+                        const filename = step.filename ?? 'screenshot.png';
+                        await this.screenshot({ path: filename });
+                        break;
+                    case 'extract':
+                        const selector = step.selector ?? 'body';
+                        const text = await this.extractText(selector);
+                        if (opts.verbose) {
+                            console.log(`[Test] Extracted text: ${text.substring(0, 100)}...`);
+                        }
+                        break;
+                    case 'submit_form':
+                        await this.submitForm();
+                        break;
+                    case 'query':
+                        if (!step.query)
+                            throw new Error('Query step requires query');
+                        const answer = await this.queryPage(step.query);
+                        if (opts.verbose) {
+                            console.log(`[Test] Query result: ${answer}`);
+                        }
+                        break;
+                    case 'nla':
+                        if (!step.command)
+                            throw new Error('NLA step requires command');
+                        const nlaResult = await this.executeNLA(step.command);
+                        if (opts.verbose) {
+                            console.log(`[Test] NLA result: ${nlaResult}`);
+                        }
+                        break;
+                    case 'solve_captcha':
+                        await this.solveCaptcha();
+                        break;
+                    case 'highlight':
+                        if (!step.selector)
+                            throw new Error('Highlight step requires selector');
+                        await this.highlight(step.selector);
+                        break;
+                    case 'scroll_up':
+                        await this.scrollBy(0, -500);
+                        break;
+                    case 'scroll_down':
+                        await this.scrollBy(0, 500);
+                        break;
+                    case 'record_video':
+                        const fps = step.fps ?? 30;
+                        await this.startVideoRecording({ fps });
+                        break;
+                    case 'stop_video':
+                        const videoPath = await this.stopVideoRecording();
+                        if (opts.verbose) {
+                            console.log(`[Test] Video saved: ${videoPath}`);
+                        }
+                        break;
+                    default:
+                        throw new Error(`Unknown step type: ${step.type}`);
+                }
+                result.successfulSteps++;
+                if (opts.verbose) {
+                    console.log(`[Test] Step ${i + 1}: Success`);
+                }
+            }
+            catch (error) {
+                result.failedSteps++;
+                result.success = false;
+                const errorMessage = error.message || String(error);
+                result.errors.push({
+                    step: i + 1,
+                    type: step.type,
+                    message: errorMessage,
+                });
+                console.error(`[Test] Step ${i + 1} failed: ${errorMessage}`);
+                // Take screenshot on error if enabled
+                if (opts.screenshotOnError) {
+                    try {
+                        const errorScreenshot = `error-step-${i + 1}.png`;
+                        await this.screenshot({ path: errorScreenshot });
+                        console.log(`[Test] Error screenshot saved: ${errorScreenshot}`);
+                    }
+                    catch (screenshotError) {
+                        console.error(`[Test] Failed to take error screenshot:`, screenshotError);
+                    }
+                }
+                // Stop execution if continueOnError is false
+                if (!opts.continueOnError) {
+                    console.error(`[Test] Stopping execution due to error`);
+                    break;
+                }
+            }
+        }
+        result.executionTime = Date.now() - startTime;
+        if (opts.verbose) {
+            console.log(`[Test] Completed: ${testData.name}`);
+            console.log(`[Test] Time: ${result.executionTime}ms`);
+            console.log(`[Test] Success: ${result.successfulSteps}/${result.totalSteps}`);
+            if (result.failedSteps > 0) {
+                console.log(`[Test] Failed: ${result.failedSteps}`);
+            }
+        }
+        return result;
+    }
+    // ==================== COOKIE MANAGEMENT ====================
+    /**
+     * Get all cookies from the browser context
+     * @param url - Optional URL to filter cookies (returns all if not specified)
+     * @returns Array of cookies
+     *
+     * @example
+     * ```typescript
+     * // Get all cookies
+     * const allCookies = await page.getCookies();
+     *
+     * // Get cookies for a specific URL
+     * const siteCookies = await page.getCookies('https://example.com');
+     * ```
+     */
+    async getCookies(url) {
+        return await this.core.sendCommand('getCookies', {
+            context_id: this.contextId,
+            url: url || '',
+        });
+    }
+    /**
+     * Set a cookie in the browser context
+     * @param url - URL to associate with the cookie (used for domain validation)
+     * @param name - Cookie name
+     * @param value - Cookie value
+     * @param options - Cookie options (domain, path, secure, httpOnly, sameSite, expires)
+     * @returns true if cookie was set successfully
+     *
+     * @example
+     * ```typescript
+     * // Set a simple cookie
+     * await page.setCookie('https://example.com', 'sessionId', 'abc123');
+     *
+     * // Set a cookie with options
+     * await page.setCookie('https://example.com', 'prefs', 'dark-mode', {
+     *   path: '/',
+     *   secure: true,
+     *   httpOnly: true,
+     *   sameSite: 'strict',
+     *   expires: Date.now() / 1000 + 86400 // 1 day from now
+     * });
+     * ```
+     */
+    async setCookie(url, name, value, options) {
+        return await this.core.sendCommand('setCookie', {
+            context_id: this.contextId,
+            url,
+            name,
+            value,
+            domain: options?.domain || '',
+            path: options?.path || '/',
+            secure: options?.secure || false,
+            httpOnly: options?.httpOnly || false,
+            sameSite: options?.sameSite || 'lax',
+            expires: options?.expires || -1,
+        });
+    }
+    /**
+     * Delete cookies from the browser context
+     * @param url - Optional URL to filter which cookies to delete
+     * @param name - Optional specific cookie name to delete
+     * @returns true if cookies were deleted successfully
+     *
+     * @example
+     * ```typescript
+     * // Delete all cookies
+     * await page.deleteCookies();
+     *
+     * // Delete cookies for a specific URL
+     * await page.deleteCookies('https://example.com');
+     *
+     * // Delete a specific cookie
+     * await page.deleteCookies('https://example.com', 'sessionId');
+     * ```
+     */
+    async deleteCookies(url, name) {
+        return await this.core.sendCommand('deleteCookies', {
+            context_id: this.contextId,
+            url: url || '',
+            cookie_name: name || '',
+        });
+    }
+    // ==================== PROXY MANAGEMENT ====================
+    /**
+     * Configure proxy settings for this browser context
+     * Includes stealth features to prevent proxy/VPN detection
+     * @param config - Proxy configuration
+     * @returns true if proxy was configured successfully
+     *
+     * @example
+     * ```typescript
+     * // Configure SOCKS5 proxy with stealth
+     * await page.setProxy({
+     *   type: 'socks5h',
+     *   host: 'proxy.example.com',
+     *   port: 1080,
+     *   username: 'user',
+     *   password: 'pass',
+     *   stealth: true,
+     *   timezoneOverride: 'America/New_York'
+     * });
+     * ```
+     */
+    async setProxy(config) {
+        return await this.core.sendCommand('setProxy', {
+            context_id: this.contextId,
+            type: config.type,
+            host: config.host,
+            port: config.port,
+            username: config.username || '',
+            password: config.password || '',
+            stealth: config.stealth !== false,
+            block_webrtc: config.blockWebrtc !== false,
+            spoof_timezone: config.spoofTimezone || false,
+            spoof_language: config.spoofLanguage || false,
+            timezone_override: config.timezoneOverride || '',
+            language_override: config.languageOverride || '',
+        });
+    }
+    /**
+     * Get current proxy configuration and connection status
+     * @returns Proxy status object
+     *
+     * @example
+     * ```typescript
+     * const status = await page.getProxyStatus();
+     * if (status.enabled && status.connected) {
+     *   console.log(`Connected to ${status.type}://${status.host}:${status.port}`);
+     * }
+     * ```
+     */
+    async getProxyStatus() {
+        return await this.core.sendCommand('getProxyStatus', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Enable/connect the configured proxy
+     * @returns true if proxy was connected successfully
+     */
+    async connectProxy() {
+        return await this.core.sendCommand('connectProxy', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Disable/disconnect the proxy, reverting to direct connection
+     * @returns true if proxy was disconnected successfully
+     */
+    async disconnectProxy() {
+        return await this.core.sendCommand('disconnectProxy', {
+            context_id: this.contextId,
+        });
+    }
+    // ==================== BROWSER PROFILE MANAGEMENT ====================
+    /**
+     * Save the current context state to a browser profile
+     *
+     * The profile includes fingerprints, cookies, and configuration settings.
+     * This enables persistent browser identities across sessions.
+     *
+     * @param profilePath - Path to save the profile JSON file. If not provided,
+     *                      uses the profile path set during context creation.
+     * @returns BrowserProfile object with the saved state
+     *
+     * @example
+     * ```typescript
+     * // Save profile to file
+     * const profile = await page.saveProfile('/path/to/profile.json');
+     * console.log(`Saved profile: ${profile.profileId}`);
+     * console.log(`Cookies: ${profile.cookies.length}`);
+     * ```
+     */
+    async saveProfile(profilePath) {
+        const result = await this.core.sendCommand('saveProfile', {
+            context_id: this.contextId,
+            profile_path: profilePath || '',
+        });
+        return this.parseProfile(result);
+    }
+    /**
+     * Get the current profile state for this context
+     *
+     * Returns the in-memory profile state without saving to disk.
+     *
+     * @returns BrowserProfile object with current state
+     *
+     * @example
+     * ```typescript
+     * const profile = await page.getProfile();
+     * console.log(`User Agent: ${profile.fingerprint?.userAgent}`);
+     * console.log(`Cookies: ${profile.cookies.length}`);
+     * ```
+     */
+    async getProfile() {
+        const result = await this.core.sendCommand('getProfile', {
+            context_id: this.contextId,
+        });
+        return this.parseProfile(result);
+    }
+    /**
+     * Update the profile file with current cookies from the browser
+     *
+     * This is useful when you want to persist cookie changes without
+     * saving the entire profile state.
+     *
+     * @returns true if cookies were updated successfully
+     *
+     * @example
+     * ```typescript
+     * // After logging in
+     * await page.goto('https://example.com/login');
+     * await page.type('email input', 'user@example.com');
+     * await page.type('password input', 'password');
+     * await page.click('login button');
+     *
+     * // Save the session cookies
+     * await page.updateProfileCookies();
+     * ```
+     */
+    async updateProfileCookies() {
+        return await this.core.sendCommand('updateProfileCookies', {
+            context_id: this.contextId,
+        });
+    }
+    /**
+     * Parse profile data from command result
+     */
+    parseProfile(data) {
+        if (typeof data === 'string') {
+            data = JSON.parse(data);
+        }
+        if (!data || typeof data !== 'object') {
+            return {
+                profileId: '',
+                profileName: '',
+                createdAt: '',
+                modifiedAt: '',
+                version: 1,
+                cookies: [],
+                hasLlmConfig: false,
+                hasProxyConfig: false,
+                autoSaveCookies: true,
+                persistLocalStorage: true,
+            };
+        }
+        // Parse fingerprint
+        let fingerprint;
+        const fp = data.fingerprint;
+        if (fp) {
+            fingerprint = {
+                userAgent: fp.user_agent || '',
+                platform: fp.platform || 'Win32',
+                vendor: fp.vendor || 'Google Inc.',
+                languages: fp.languages || ['en-US', 'en'],
+                hardwareConcurrency: fp.hardware_concurrency || 8,
+                deviceMemory: fp.device_memory || 8,
+                maxTouchPoints: fp.max_touch_points || 0,
+                canvasNoiseSeed: fp.canvas_noise_seed || 0,
+                gpuProfileIndex: fp.gpu_profile_index || 0,
+                webglVendor: fp.webgl_vendor || '',
+                webglRenderer: fp.webgl_renderer || '',
+                screenWidth: fp.screen_width || 1920,
+                screenHeight: fp.screen_height || 1080,
+                colorDepth: fp.color_depth || 24,
+                pixelRatio: fp.pixel_ratio || 1,
+                timezone: fp.timezone || '',
+                locale: fp.locale || 'en-US',
+                audioNoiseSeed: fp.audio_noise_seed || 0,
+                installedFonts: fp.installed_fonts || [],
+                hasPdfPlugin: fp.has_pdf_plugin !== false,
+                hasChromePdf: fp.has_chrome_pdf !== false,
+            };
+        }
+        // Parse cookies
+        const cookies = (data.cookies || []).map((c) => ({
+            name: c.name || '',
+            value: c.value || '',
+            domain: c.domain || '',
+            path: c.path || '/',
+            secure: c.secure || false,
+            httpOnly: c.httpOnly || false,
+            sameSite: c.sameSite || 'lax',
+            expires: c.expires || -1,
+        }));
+        return {
+            profileId: data.profile_id || '',
+            profileName: data.profile_name || '',
+            createdAt: data.created_at || '',
+            modifiedAt: data.modified_at || '',
+            version: data.version || 1,
+            fingerprint,
+            cookies,
+            hasLlmConfig: data.has_llm_config || false,
+            llmConfig: data.llm_config ? {
+                enabled: data.llm_config.enabled ?? true,
+                useBuiltin: data.llm_config.use_builtin ?? true,
+                externalEndpoint: data.llm_config.external_endpoint,
+                externalModel: data.llm_config.external_model,
+            } : undefined,
+            hasProxyConfig: data.has_proxy_config || false,
+            proxyConfig: data.proxy_config ? {
+                type: data.proxy_config.type || 'http',
+                host: data.proxy_config.host || '',
+                port: data.proxy_config.port || 0,
+                username: data.proxy_config.username,
+                password: data.proxy_config.password,
+            } : undefined,
+            autoSaveCookies: data.auto_save_cookies !== false,
+            persistLocalStorage: data.persist_local_storage !== false,
+        };
+    }
+    // ==================== CLEANUP ====================
+    /**
+     * Close this context and release resources
+     */
+    async close() {
+        await this.core.releaseContext(this.contextId);
+    }
+}
+exports.BrowserContext = BrowserContext;
+//# sourceMappingURL=context.js.map