codebuff 1.0.150 → 1.0.152

package/dist/__tests__/browser-runner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/browser-runner.test.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const browser_runner_1 = require("../browser-runner");
+// Add your tests here
+describe('BrowserRunner', () => {
+    let runner;
+    beforeEach(() => {
+        runner = new browser_runner_1.BrowserRunner();
+    });
+    afterEach(async () => {
+        await runner.shutdown();
+    });
+    // Add test cases...
+});
+//# sourceMappingURL=browser-runner.test.js.map

package/dist/__tests__/browser-runner.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-runner.test.js","sourceRoot":"","sources":["../../src/__tests__/browser-runner.test.ts"],"names":[],"mappings":";;AAAA,sDAAiD;AAGjD,sBAAsB;AACtB,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;IAC7B,IAAI,MAAqB,CAAA;IAEzB,UAAU,CAAC,GAAG,EAAE;QACd,MAAM,GAAG,IAAI,8BAAa,EAAE,CAAA;IAC9B,CAAC,CAAC,CAAA;IAEF,SAAS,CAAC,KAAK,IAAI,EAAE;QACnB,MAAM,MAAM,CAAC,QAAQ,EAAE,CAAA;IACzB,CAAC,CAAC,CAAA;IAEF,oBAAoB;AACtB,CAAC,CAAC,CAAA"}

package/dist/browser-runner.d.ts

@@ -0,0 +1,34 @@
+import { BrowserAction, BrowserResponse } from './common/browser-actions';
+export declare class BrowserRunner {
+    getLogs(): BrowserResponse['logs'];
+    getNetworkEvents(): BrowserResponse['networkEvents'];
+    private browser;
+    private page;
+    private logs;
+    private jsErrorCount;
+    private retryCount;
+    private startTime;
+    private consecutiveErrors;
+    private totalErrors;
+    constructor();
+    private maxConsecutiveErrors;
+    private totalErrorThreshold;
+    private performanceMetrics;
+    private networkEvents;
+    private executeWithRetry;
+    private executeAction;
+    private logErrorForAnalysis;
+    private startBrowser;
+    private navigate;
+    private typeText;
+    private scroll;
+    private takeScreenshot;
+    private attachPageListeners;
+    private collectPerformanceMetrics;
+    private collectMetrics;
+    private filterLogs;
+    execute(action: BrowserAction): Promise<BrowserResponse>;
+    shutdown(): Promise<void>;
+}
+export declare const handleBrowserInstruction: (action: BrowserAction) => Promise<BrowserResponse>;
+export declare const activeBrowserRunner: BrowserRunner;

package/dist/browser-runner.js

@@ -0,0 +1,632 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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_1 = __importDefault(require("puppeteer"));
+const child_process_1 = require("child_process");
+const promise_1 = require("./common/util/promise");
+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 {
+            switch (action.type) {
+                case 'start':
+                    await this.startBrowser(action);
+                    break;
+                case 'navigate':
+                    await this.navigate(action);
+                    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':
+                    return await this.takeScreenshot(action);
+                case 'stop':
+                    await this.shutdown();
+                    return {
+                        success: true,
+                        logs: this.logs,
+                        metrics: await this.collectMetrics(),
+                    };
+                default:
+                    throw new Error(`Unknown action type: ${action.type}`);
+            }
+            const metrics = await this.collectMetrics();
+            const response = {
+                success: true,
+                logs: this.logs,
+                metrics,
+            };
+            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 startBrowser(action) {
+        if (this.browser) {
+            await this.shutdown();
+        }
+        // Set start time for session tracking
+        this.startTime = Date.now();
+        // Update session configuration
+        this.maxConsecutiveErrors =
+            action.maxConsecutiveErrors ?? browser_actions_1.BROWSER_DEFAULTS.maxConsecutiveErrors;
+        this.totalErrorThreshold =
+            action.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 {
+            this.browser = await puppeteer_1.default.launch({
+                defaultViewport: { width: 1280, height: 720 },
+                headless: browser_actions_1.BROWSER_DEFAULTS.headless,
+                userDataDir,
+                args: ['--no-sandbox', '--restore-last-session=false'],
+            });
+        }
+        catch (error) {
+            // If launch fails, try installing/updating Chrome and retry
+            console.log('Browser launch failed, attempting to install/update Chrome...');
+            (0, child_process_1.execSync)('npx puppeteer browsers install chrome', { stdio: 'inherit' });
+            this.browser = await puppeteer_1.default.launch({
+                defaultViewport: { width: 1280, height: 720 },
+                headless: browser_actions_1.BROWSER_DEFAULTS.headless,
+                userDataDir,
+                args: ['--no-sandbox', '--restore-last-session=false'],
+            });
+        }
+        this.logs.push({
+            type: 'info',
+            message: 'Browser started',
+            timestamp: Date.now(),
+            source: 'tool',
+        });
+        const pages = await this.browser.pages();
+        this.page = pages.length > 0 ? pages[0] : await this.browser.newPage();
+        this.attachPageListeners();
+        return {
+            success: true,
+            logs: [
+                {
+                    type: 'info',
+                    message: `Opened ${action.url} in browser`,
+                    timestamp: Date.now(),
+                    source: 'tool',
+                },
+            ],
+            networkEvents: [],
+        };
+    }
+    async navigate(action) {
+        // If headless state needs to change, restart browser
+        if (!this.browser) {
+            await this.startBrowser({
+                ...action,
+                type: 'start',
+            });
+        }
+        if (!this.page)
+            throw new Error('No browser page found; call start first.');
+        try {
+            await this.page.goto(action.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 ${action.url}`,
+                timestamp: Date.now(),
+                source: 'tool',
+            });
+            // Add a small delay after navigation to ensure page is stable
+            await (0, promise_1.sleep)(1000);
+            return {
+                success: true,
+                logs: this.logs,
+                networkEvents: [],
+            };
+        }
+        catch (error) {
+            // Explicitly type as any since we know we want to access .message
+            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) {
+        if (!this.page)
+            throw new Error('No browser page found; call start first.');
+        await this.page.type(action.selector, action.text, {
+            delay: action.delay ?? browser_actions_1.BROWSER_DEFAULTS.delay,
+        });
+    }
+    async scroll(action) {
+        if (!this.page)
+            throw new Error('No browser page found; call start first.');
+        // Get viewport height
+        const viewport = this.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 this.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: [],
+            networkEvents: [],
+        };
+    }
+    async takeScreenshot(action) {
+        if (!this.page)
+            throw new Error('No browser page found; call start first.');
+        // Take a screenshot with aggressive compression settings
+        const screenshot = await this.page.screenshot({
+            fullPage: browser_actions_1.BROWSER_DEFAULTS.fullPage, // action.fullPage ?? 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',
+        });
+        // Format screenshot in Anthropic's image content format
+        const imageContent = {
+            type: 'image',
+            source: {
+                type: 'base64',
+                media_type: 'image/jpeg',
+                data: screenshot,
+            },
+        };
+        // 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',
+                });
+            }
+        }
+        const metrics = await this.collectMetrics();
+        return {
+            success: true,
+            logs: this.logs,
+            screenshot: imageContent,
+            metrics,
+        };
+    }
+    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') {
+                this.logs.push({
+                    type: 'error',
+                    message: 'Browser crashed or was closed unexpectedly. Attempting recovery...',
+                    timestamp: Date.now(),
+                    category: 'browser',
+                    source: 'tool',
+                });
+                // Try to recover by restarting browser
+                await this.shutdown();
+                if (action.type !== 'stop') {
+                    await this.startBrowser({
+                        type: 'start',
+                        url: 'about:blank',
+                        timeout: 15000,
+                    });
+                }
+            }
+            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