codebuff 1.0.234 → 1.0.235

package/dist/browser-runner.js

@@ -0,0 +1,680 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activeBrowserRunner = exports.handleBrowserInstruction = exports.BrowserRunner = void 0;
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+const promise_1 = require("./common/util/promise");
+const string_1 = require("./common/util/string");
+const browser_actions_1 = require("./common/browser-actions");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const project_files_1 = require("./project-files");
+const file_1 = require("./common/util/file");
+class BrowserRunner {
+    // Add getter methods for diagnostic loop
+    getLogs() {
+        return this.logs;
+    }
+    getNetworkEvents() {
+        return this.networkEvents;
+    }
+    browser = null;
+    page = null;
+    logs = [];
+    jsErrorCount = 0;
+    retryCount = 0;
+    startTime = 0;
+    // Error tracking
+    consecutiveErrors = 0;
+    totalErrors = 0;
+    constructor() { }
+    // Error tracking configuration
+    maxConsecutiveErrors = 3;
+    totalErrorThreshold = 10;
+    performanceMetrics = {};
+    networkEvents = [];
+    async executeWithRetry(action) {
+        const retryOptions = action.retryOptions ?? browser_actions_1.BROWSER_DEFAULTS.retryOptions;
+        let lastError = null;
+        for (let attempt = 0; attempt <= (retryOptions.maxRetries ?? 3); attempt++) {
+            try {
+                const result = await this.executeAction(action);
+                // Reset consecutive errors on success
+                this.consecutiveErrors = 0;
+                return result;
+            }
+            catch (error) {
+                // Track errors
+                this.consecutiveErrors++;
+                this.totalErrors++;
+                // Log error analysis
+                this.logErrorForAnalysis(error);
+                // Check error thresholds
+                if (this.consecutiveErrors >= this.maxConsecutiveErrors) {
+                    const msg = `Max consecutive errors reached (${this.maxConsecutiveErrors}).`;
+                    this.logs.push({
+                        type: 'error',
+                        message: msg,
+                        timestamp: Date.now(),
+                        source: 'tool',
+                    });
+                    await this.shutdown();
+                    return {
+                        success: false,
+                        error: msg,
+                        logs: this.logs,
+                    };
+                }
+                if (this.totalErrors >= this.totalErrorThreshold) {
+                    const msg = `Total error threshold reached (${this.totalErrorThreshold}).`;
+                    this.logs.push({
+                        type: 'error',
+                        message: msg,
+                        timestamp: Date.now(),
+                        source: 'tool',
+                    });
+                    await this.shutdown();
+                    return {
+                        success: false,
+                        error: msg,
+                        logs: this.logs,
+                    };
+                }
+                lastError = error;
+                const shouldRetry = retryOptions.retryOnErrors?.includes(error.name);
+                if (!shouldRetry || attempt === retryOptions.maxRetries) {
+                    throw error;
+                }
+                await new Promise((resolve) => setTimeout(resolve, retryOptions.retryDelay ?? 1000));
+                this.logs.push({
+                    type: 'info',
+                    message: `Retrying action (attempt ${attempt + 1}/${retryOptions.maxRetries})`,
+                    timestamp: Date.now(),
+                    category: 'retry',
+                    source: 'tool',
+                });
+            }
+        }
+        throw lastError;
+    }
+    async executeAction(action) {
+        try {
+            // Only take pre-action screenshot if browser is already running
+            let preActionResult = null;
+            if (this.browser && this.page) {
+                // preActionResult = await this.takeScreenshot(
+                //   {
+                //     type: 'screenshot',
+                //   },
+                //   this.page
+                // )
+            }
+            let response;
+            switch (action.type) {
+                case 'start':
+                    await this.getBrowser(action);
+                    if (!action.url) {
+                        break;
+                    }
+                case 'navigate':
+                    response = await this.navigate({ ...action, type: 'navigate' });
+                    break;
+                case 'click':
+                    console.log('Clicking has not been implemented yet');
+                    break;
+                case 'type':
+                    await this.typeText(action);
+                    break;
+                case 'scroll':
+                    await this.scroll(action);
+                    break;
+                case 'screenshot':
+                    break;
+                case 'stop':
+                    await this.shutdown();
+                    return {
+                        success: true,
+                        logs: this.logs,
+                        metrics: await this.collectMetrics(),
+                    };
+                default:
+                    throw new Error(`Unknown action type: ${action.type}`);
+            }
+            // Take post-action screenshot
+            let postActionResult = null;
+            if (this.page) {
+                // postActionResult = await this.takeScreenshot(
+                //   {
+                //     type: 'screenshot',
+                //   },
+                //   this.page
+                // )
+            }
+            const metrics = await this.collectMetrics();
+            response = {
+                success: true,
+                logs: this.logs,
+                metrics,
+                // ...(postActionResult && {
+                //   screenshots: {
+                //     ...(preActionResult && {
+                //       pre: {
+                //         type: 'image',
+                //         source: {
+                //           type: 'base64',
+                //           media_type: 'image/jpeg',
+                //           data: preActionResult.data,
+                //         },
+                //       },
+                //     }),
+                // post: {
+                //   type: 'image',
+                //   source: {
+                //     type: 'base64',
+                //     media_type: 'image/jpeg',
+                //     data: postActionResult.data,
+                //   },
+                // },
+                // },
+                // }),
+            };
+            return response;
+        }
+        catch (err) {
+            await this.shutdown();
+            return {
+                success: false,
+                error: err?.message ?? String(err),
+                logs: this.logs,
+            };
+        }
+    }
+    logErrorForAnalysis(error) {
+        // Add helpful hints based on error patterns
+        const errorPatterns = {
+            'not defined': 'Check for missing script dependencies or undefined variables',
+            'Failed to fetch': 'Verify endpoint URLs and network connectivity',
+            '404': 'Resource not found - verify URLs and paths',
+            SSL: 'SSL certificate error - check HTTPS configuration',
+            ERR_NAME_NOT_RESOLVED: 'DNS resolution failed - check domain name',
+            ERR_CONNECTION_TIMED_OUT: 'Connection timeout - check network or firewall',
+            ERR_NETWORK_CHANGED: 'Network changed during request - retry operation',
+            ERR_INTERNET_DISCONNECTED: 'No internet connection',
+            'Navigation timeout': 'Page took too long to load - check performance or timeouts',
+            WebSocket: 'WebSocket connection issue - check server status',
+            ERR_TUNNEL_CONNECTION_FAILED: 'Proxy or VPN connection issue',
+            ERR_CERT_: 'SSL/TLS certificate validation error',
+            ERR_BLOCKED_BY_CLIENT: 'Request blocked by browser extension or policy',
+            ERR_TOO_MANY_REDIRECTS: 'Redirect loop detected',
+            'Frame detached': 'Target frame or element no longer exists',
+            'Node is detached': 'Element was removed from DOM',
+            ERR_ABORTED: 'Request was aborted - possible navigation or reload',
+            ERR_CONTENT_LENGTH_MISMATCH: 'Incomplete response - check server stability',
+            ERR_RESPONSE_HEADERS_TRUNCATED: 'Response headers too large or malformed',
+        };
+        for (const [pattern, hint] of Object.entries(errorPatterns)) {
+            if (error.message.includes(pattern)) {
+                this.logs.push({
+                    type: 'info',
+                    message: `Hint: ${hint}`,
+                    timestamp: Date.now(),
+                    category: 'hint',
+                    source: 'tool',
+                });
+                break; // Stop after first matching pattern
+            }
+        }
+        this.logs.push({
+            type: 'error',
+            message: `Action error: ${error.message}`,
+            timestamp: Date.now(),
+            stack: error.stack,
+            source: 'tool',
+        });
+    }
+    async getBrowser(config) {
+        // Check if browser exists and is connected
+        if (!this.browser || !this.page) {
+            await this.startBrowser(config);
+        }
+        else {
+            try {
+                // Test if browser is still responsive
+                await this.page.evaluate(() => true);
+            }
+            catch (error) {
+                // Browser is dead or unresponsive, restart it
+                await this.shutdown();
+                await this.startBrowser(config);
+            }
+        }
+        if (!this.browser || !this.page) {
+            throw new Error('Failed to initialize browser');
+        }
+        return { browser: this.browser, page: this.page };
+    }
+    async startBrowser(config) {
+        if (this.browser) {
+            await this.shutdown();
+        }
+        // Set start time for session tracking
+        this.startTime = Date.now();
+        // Update session configuration
+        this.maxConsecutiveErrors =
+            config?.maxConsecutiveErrors ?? browser_actions_1.BROWSER_DEFAULTS.maxConsecutiveErrors;
+        this.totalErrorThreshold =
+            config?.totalErrorThreshold ?? browser_actions_1.BROWSER_DEFAULTS.totalErrorThreshold;
+        // Reset error counters
+        this.consecutiveErrors = 0;
+        this.totalErrors = 0;
+        // Set up user data directory for profile persistence, scoped to current project
+        let userDataDir = undefined;
+        try {
+            userDataDir = path.join((0, project_files_1.getProjectDataDir)(), browser_actions_1.BROWSER_DEFAULTS.userDataDir);
+            (0, file_1.ensureDirectoryExists)(userDataDir);
+        }
+        catch (error) { }
+        try {
+            // Define helper to find Chrome in standard locations
+            const findChrome = () => {
+                switch (process.platform) {
+                    case 'win32':
+                        return 'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe';
+                    case 'darwin':
+                        return '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+                    default:
+                        return '/usr/bin/google-chrome';
+                }
+            };
+            this.browser = await puppeteer_core_1.default.launch({
+                defaultViewport: {
+                    width: browser_actions_1.BROWSER_DEFAULTS.viewportWidth,
+                    height: browser_actions_1.BROWSER_DEFAULTS.viewportHeight,
+                },
+                headless: browser_actions_1.BROWSER_DEFAULTS.headless,
+                userDataDir,
+                waitForInitialPage: true,
+                args: [
+                    '--window-size=1200,800',
+                    '--disable-backgrounding-occluded-windows',
+                    '--disable-breakpad',
+                    '--disable-sync',
+                    '--no-sandbox',
+                    '--no-first-run',
+                    '--disable-session-crashed-bubble',
+                    '--disable-restore-session-state',
+                    '--hide-crash-restore-bubble',
+                    '--noerrdialogs',
+                    '--disable-infobars',
+                ],
+                executablePath: findChrome(),
+            });
+        }
+        catch (error) {
+            // If launch fails, guide the user to install Google Chrome
+            console.log("Couldn't launch Chrome browser. Please ensure Google Chrome is installed on your system.");
+            return {
+                success: false,
+                error: 'Chrome browser not found. Please install Google Chrome to use browser features.',
+                logs: this.logs,
+                networkEvents: this.networkEvents,
+            };
+        }
+        // this.logs.push({
+        //   type: 'info',
+        //   message: 'Browser started',
+        //   timestamp: Date.now(),
+        //   source: 'tool',
+        // })
+        // Pick the first existing page or create a new one
+        const pages = await this.browser.pages();
+        this.page = pages.length > 0 ? pages[0] : await this.browser.newPage();
+        this.attachPageListeners();
+        await (0, promise_1.sleep)(500);
+        return {
+            success: true,
+            logs: this.logs,
+            networkEvents: [],
+        };
+    }
+    async navigate(action) {
+        try {
+            const { page } = await this.getBrowser(action);
+            const url = (0, string_1.ensureUrlProtocol)(action.url);
+            await page.goto(url, {
+                waitUntil: action.waitUntil ?? browser_actions_1.BROWSER_DEFAULTS.waitUntil,
+                timeout: action.timeout ?? browser_actions_1.BROWSER_DEFAULTS.timeout,
+            });
+            this.logs.push({
+                type: 'info',
+                message: `Navigated to ${url}`,
+                timestamp: Date.now(),
+                source: 'tool',
+            });
+            return {
+                success: true,
+                logs: this.logs,
+                networkEvents: [],
+            };
+        }
+        catch (error) {
+            const errorMessage = error?.message || 'Unknown navigation error';
+            this.logs.push({
+                type: 'error',
+                message: `Navigation failed: ${errorMessage}`,
+                timestamp: Date.now(),
+                source: 'tool',
+            });
+            return {
+                success: false,
+                error: errorMessage,
+                logs: this.logs,
+                networkEvents: [],
+            };
+        }
+    }
+    async typeText(action) {
+        const { page } = await this.getBrowser();
+        await page.type(action.selector, action.text, {
+            delay: action.delay ?? browser_actions_1.BROWSER_DEFAULTS.delay,
+        });
+    }
+    async scroll(action) {
+        const { page } = await this.getBrowser();
+        // Get viewport height
+        const viewport = page.viewport();
+        if (!viewport)
+            throw new Error('No viewport found');
+        // Default to scrolling down if no direction specified
+        const direction = action.direction ?? 'down';
+        const scrollAmount = direction === 'up' ? -viewport.height : viewport.height;
+        await page.evaluate((amount) => {
+            window.scrollBy(0, amount);
+        }, scrollAmount);
+        this.logs.push({
+            type: 'info',
+            message: `Scrolled ${direction}`,
+            timestamp: Date.now(),
+            source: 'tool',
+        });
+        return {
+            success: true,
+            logs: this.logs,
+            networkEvents: [],
+        };
+    }
+    async takeScreenshot(action, page) {
+        // Take a screenshot with aggressive compression settings
+        const screenshot = await page.screenshot({
+            fullPage: browser_actions_1.BROWSER_DEFAULTS.fullPage,
+            type: 'jpeg',
+            quality: action.screenshotCompressionQuality ??
+                browser_actions_1.BROWSER_DEFAULTS.screenshotCompressionQuality,
+            encoding: 'base64',
+        });
+        // Log screenshot capture and size
+        const sizeInKB = Math.round((screenshot.length * 3) / 4 / 1024);
+        this.logs.push({
+            type: 'info',
+            message: `Captured screenshot (${sizeInKB}KB)`,
+            timestamp: Date.now(),
+            category: 'screenshot',
+            source: 'tool',
+        });
+        // If debug mode is enabled, save the screenshot
+        if (action.debug) {
+            console.debug({
+                message: 'Saving screenshot to disk...',
+                timestamp: Date.now(),
+                source: 'tool',
+            });
+            try {
+                const chatDir = (0, project_files_1.getCurrentChatDir)();
+                const screenshotsDir = path.join(chatDir, 'screenshots');
+                (0, file_1.ensureDirectoryExists)(screenshotsDir);
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const filename = `screenshot-${timestamp}.jpg`;
+                const filepath = path.join(screenshotsDir, filename);
+                fs.writeFileSync(filepath, Buffer.from(screenshot, 'base64'));
+                console.debug({
+                    type: 'debug',
+                    message: `Saved screenshot to ${filepath}`,
+                    timestamp: Date.now(),
+                    source: 'tool',
+                });
+                // Save metadata
+                const metadataPath = path.join(screenshotsDir, `${timestamp}-metadata.json`);
+                const metadata = {
+                    timestamp,
+                    format: 'jpeg',
+                    quality: 25,
+                    fullPage: action.fullPage ?? browser_actions_1.BROWSER_DEFAULTS.fullPage,
+                    metrics: await this.collectMetrics(),
+                };
+                fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+            }
+            catch (error) {
+                console.error({
+                    message: `Failed to save screenshot: ${error.message}`,
+                    timestamp: Date.now(),
+                    source: 'tool',
+                });
+            }
+        }
+        return {
+            data: screenshot,
+            logs: this.logs,
+        };
+    }
+    attachPageListeners() {
+        if (!this.page)
+            return;
+        // Console messages
+        this.page.on('console', (msg) => {
+            const type = msg.type() === 'error' ? 'error' : msg.type();
+            this.logs.push({
+                type,
+                message: msg.text(),
+                timestamp: Date.now(),
+                source: 'browser',
+            });
+        });
+        // Page errors
+        this.page.on('pageerror', (err) => {
+            this.logs.push({
+                type: 'error',
+                message: err.message,
+                timestamp: Date.now(),
+                stack: err.stack,
+                source: 'browser',
+            });
+            this.jsErrorCount++;
+        });
+        // Network requests
+        this.page.on('request', (request) => {
+            const method = request.method();
+            if (method) {
+                this.networkEvents.push({
+                    url: request.url(),
+                    method,
+                    timestamp: Date.now(),
+                });
+            }
+        });
+        // Network responses
+        this.page.on('response', async (response) => {
+            const req = response.request();
+            const index = this.networkEvents.findIndex((evt) => evt.url === req.url() && evt.method === req.method());
+            const status = response.status();
+            const errorText = status >= 400 ? await response.text().catch(() => '') : undefined;
+            if (index !== -1) {
+                this.networkEvents[index].status = status;
+                this.networkEvents[index].errorText = errorText;
+            }
+            else {
+                const method = req.method();
+                if (method) {
+                    this.networkEvents.push({
+                        url: req.url(),
+                        method,
+                        status,
+                        errorText,
+                        timestamp: Date.now(),
+                    });
+                }
+            }
+            // Log network errors
+            if (status >= 400) {
+                this.logs.push({
+                    type: 'error',
+                    message: `Network error ${status} for ${req.url()}`,
+                    timestamp: Date.now(),
+                    source: 'tool',
+                });
+            }
+        });
+    }
+    async collectPerformanceMetrics() {
+        if (!this.page)
+            return;
+        // Collect Web Vitals and other performance metrics
+        const metrics = await this.page.evaluate(() => {
+            const lcpEntry = performance.getEntriesByType('largest-contentful-paint')[0];
+            const navEntry = performance.getEntriesByType('navigation')[0];
+            const fcpEntry = performance
+                .getEntriesByType('paint')
+                .find((entry) => entry.name === 'first-contentful-paint');
+            return {
+                ttfb: navEntry?.responseStart - navEntry?.requestStart,
+                lcp: lcpEntry?.startTime,
+                fcp: fcpEntry?.startTime,
+                domContentLoaded: navEntry?.domContentLoadedEventEnd - navEntry?.startTime,
+            };
+        });
+        this.performanceMetrics = metrics;
+    }
+    async collectMetrics() {
+        if (!this.page)
+            return undefined;
+        const perfEntries = JSON.parse(await this.page.evaluate(() => JSON.stringify(performance.getEntriesByType('navigation'))));
+        let loadTime = 0;
+        if (perfEntries && perfEntries.length > 0) {
+            const navTiming = perfEntries[0];
+            loadTime = navTiming.loadEventEnd - navTiming.startTime;
+        }
+        const memoryUsed = await this.page
+            .metrics()
+            .then((m) => m.JSHeapUsedSize || 0);
+        await this.collectPerformanceMetrics();
+        return {
+            loadTime,
+            memoryUsage: memoryUsed,
+            jsErrors: this.jsErrorCount,
+            networkErrors: this.networkEvents.filter((e) => e.status && e.status >= 400).length,
+            ttfb: this.performanceMetrics.ttfb,
+            lcp: this.performanceMetrics.lcp,
+            fcp: this.performanceMetrics.fcp,
+            domContentLoaded: this.performanceMetrics.domContentLoaded,
+            sessionDuration: Date.now() - this.startTime,
+        };
+    }
+    filterLogs(logs, filter) {
+        // First deduplicate logs
+        const seen = new Set();
+        logs = logs.filter((log) => {
+            const key = `${log.type}|${log.message}|${log.timestamp}|${log.source}`;
+            if (seen.has(key)) {
+                return false;
+            }
+            seen.add(key);
+            return true;
+        });
+        // Then apply any filters
+        if (!filter)
+            return logs;
+        return logs.filter((log) => {
+            if (filter.types && !filter.types.includes(log.type))
+                return false;
+            if (filter.minLevel && log.level && log.level < filter.minLevel)
+                return false;
+            if (filter.categories &&
+                log.category &&
+                !filter.categories.includes(log.category))
+                return false;
+            return true;
+        });
+    }
+    async execute(action) {
+        try {
+            const response = await this.executeWithRetry(action);
+            // Filter and deduplicate logs
+            response.logs = this.filterLogs(response.logs, action.logFilter ?? undefined);
+            this.logs = []; // Clear logs after sending them in response
+            return response;
+        }
+        catch (error) {
+            if (error.name === 'TargetClosedError' ||
+                (error.message && error.message.includes('detached Frame'))) {
+                this.logs.push({
+                    type: 'error',
+                    message: 'Browser was closed or detached. Starting new session...',
+                    timestamp: Date.now(),
+                    category: 'browser',
+                    source: 'tool',
+                });
+                await this.shutdown();
+                if (action.type !== 'stop') {
+                    return this.executeWithRetry(action);
+                }
+            }
+            throw error;
+        }
+    }
+    async shutdown() {
+        const browser = this.browser;
+        if (browser) {
+            // Clear references first to prevent double shutdown
+            this.browser = null;
+            this.page = null;
+            try {
+                await browser.close();
+            }
+            catch (err) {
+                console.error('Error closing browser:', err);
+            }
+        }
+    }
+}
+exports.BrowserRunner = BrowserRunner;
+const handleBrowserInstruction = async (action) => {
+    const response = await exports.activeBrowserRunner.execute(action);
+    return response;
+};
+exports.handleBrowserInstruction = handleBrowserInstruction;
+exports.activeBrowserRunner = new BrowserRunner();
+//# sourceMappingURL=browser-runner.js.map