@dyyz1993/agent-browser 0.24.0 → 0.26.0

package/dist/browser/browser-manager.js

@@ -0,0 +1,1251 @@
+import { chromium, firefox, webkit, devices, } from 'playwright-core';
+import path from 'node:path';
+import os from 'node:os';
+import { getEnhancedSnapshot, generateStableSelectors, parseRef, } from '../snapshot.js';
+import { SnapshotStore } from '../snapshot-store.js';
+import { getEventCallbacks } from '../browser-events.js';
+import { NetworkTracker } from './network-tracker.js';
+import { ScreencastManager } from './screencast-manager.js';
+import { RecordingManager } from './recording-manager.js';
+import { RecorderManager } from './recorder-manager.js';
+import { connectToBrowserbase, connectToKernel, connectToBrowserUse, connectViaCDP, closeBrowserbaseSession, closeBrowserUseSession, closeKernelSession, } from './providers.js';
+export class BrowserManager {
+    browser = null;
+    cdpEndpoint = null;
+    isPersistentContext = false;
+    browserbaseSessionId = null;
+    browserbaseApiKey = null;
+    browserUseSessionId = null;
+    browserUseApiKey = null;
+    kernelSessionId = null;
+    kernelApiKey = null;
+    contexts = [];
+    pages = [];
+    activePageIndex = 0;
+    dialogHandler = null;
+    isRecordingHar = false;
+    refMap = {};
+    lastSnapshot = '';
+    snapshotStore = new SnapshotStore();
+    scopedHeaderRoutes = new Map();
+    commandHistory = [];
+    cdpSession = null;
+    routes = new Map();
+    network;
+    screencast;
+    recording;
+    recorder;
+    constructor() {
+        this.network = new NetworkTracker(() => this.getPage());
+        this.screencast = new ScreencastManager(() => this.getCDPSession());
+        this.recording = new RecordingManager({
+            getBrowser: () => this.browser,
+            getPage: () => this.getPage(),
+            getContexts: () => this.contexts,
+            getPages: () => this.pages,
+            getActivePageIndex: () => this.activePageIndex,
+            setActivePageIndex: (i) => {
+                this.activePageIndex = i;
+            },
+            addPage: (page) => {
+                if (!this.pages.includes(page))
+                    this.pages.push(page);
+            },
+            addContext: (context) => {
+                if (!this.contexts.includes(context))
+                    this.contexts.push(context);
+            },
+            removePage: (page) => {
+                const idx = this.pages.indexOf(page);
+                if (idx !== -1)
+                    this.pages.splice(idx, 1);
+            },
+            removeContext: (context) => {
+                const idx = this.contexts.indexOf(context);
+                if (idx !== -1)
+                    this.contexts.splice(idx, 1);
+            },
+            setupPageTracking: (page) => this.setupPageTracking(page),
+            invalidateCDPSession: () => this.invalidateCDPSession(),
+        });
+        this.recorder = new RecorderManager({
+            getPage: () => this.getPage(),
+            getPages: () => this.pages,
+            getActivePageIndex: () => this.activePageIndex,
+            setActivePageIndex: (i) => {
+                this.activePageIndex = i;
+            },
+            getCDPSession: () => this.getCDPSession(),
+            getCdpEndpoint: () => this.cdpEndpoint,
+        });
+    }
+    isLaunched() {
+        if (this.isPersistentContext)
+            return true;
+        if (!this.browser)
+            return false;
+        return this.browser.isConnected();
+    }
+    async getSnapshot(options) {
+        const frame = options?.framePath ? this.getFrame(options.framePath) : this.getFrame();
+        const snapshot = await getEnhancedSnapshot(frame, options);
+        this.refMap = snapshot.refs;
+        this.lastSnapshot = snapshot.tree;
+        const url = this.pages.length > 0 ? this.getPage().url() : '';
+        const elements = [];
+        let index = 1;
+        for (const [ref, data] of Object.entries(snapshot.refs)) {
+            elements.push({
+                ref,
+                index: index,
+                role: data.role,
+                name: data.name,
+                cssSelector: '',
+                xpath: '',
+            });
+            index++;
+        }
+        const snapshotId = this.snapshotStore.create(url, elements, options?.framePath);
+        const elementCount = elements.length;
+        const header = `Snapshot #${snapshotId} (${elementCount} interactive elements)\n---`;
+        const tips = `---\nTips:\n  Get selector:  snapshot --selector-for ${snapshotId}:@e1\n  Or by index:   snapshot --selector-for ${snapshotId}:1\n  List all:      snapshot --selectors-of ${snapshotId}\n  Validate:      snapshot --validate ${snapshotId}`;
+        snapshot.tree = `${header}\n${snapshot.tree}\n${tips}`;
+        this.lastSnapshot = snapshot.tree;
+        return { ...snapshot, snapshotId };
+    }
+    async ensureSelectorsGenerated(snapId) {
+        const store = this.snapshotStore;
+        if (store.isSelectorsGenerated(snapId))
+            return true;
+        const entry = store.get(snapId);
+        if (!entry)
+            return false;
+        const refs = {};
+        for (const [ref, el] of entry.elements) {
+            refs[ref] = {
+                selector: `getByRole('${el.role}'${el.name ? `, { name: "${el.name}", exact: true }` : ''})`,
+                role: el.role,
+                name: el.name,
+            };
+        }
+        const frame = entry.framePath ? this.getFrame(entry.framePath) : this.getFrame();
+        let stableSelectors = {};
+        try {
+            stableSelectors = await generateStableSelectors(frame, refs);
+        }
+        catch {
+            /* empty */
+        }
+        for (const [ref, sel] of Object.entries(stableSelectors)) {
+            const el = entry.elements.get(ref);
+            if (el) {
+                el.cssSelector = sel.cssSelector;
+                el.xpath = sel.xpath;
+            }
+        }
+        store.markSelectorsGenerated(snapId);
+        return true;
+    }
+    getRefMap() {
+        return this.refMap;
+    }
+    getSnapshotStore() {
+        return this.snapshotStore;
+    }
+    recordCommand(action, selector, value, success) {
+        this.commandHistory.push({ action, selector, value, success, timestamp: Date.now() });
+    }
+    getHistory(filter) {
+        let history = this.commandHistory;
+        if (filter) {
+            history = history.filter((h) => h.selector.includes(filter) || h.action.includes(filter));
+        }
+        return history;
+    }
+    clearHistory() {
+        this.commandHistory = [];
+    }
+    getLocatorFromRef(refArg, framePath) {
+        const ref = parseRef(refArg);
+        if (!ref)
+            return null;
+        const refData = this.refMap[ref];
+        if (!refData)
+            return null;
+        const frame = this.getFrame(framePath);
+        if (refData.role === 'clickable' || refData.role === 'focusable') {
+            return frame.locator(refData.selector);
+        }
+        let locator;
+        if (refData.name) {
+            locator = frame.getByRole(refData.role, {
+                name: refData.name,
+                exact: true,
+            });
+        }
+        else {
+            locator = frame.getByRole(refData.role);
+        }
+        if (refData.nth !== undefined) {
+            locator = locator.nth(refData.nth);
+        }
+        return locator;
+    }
+    isRef(selector) {
+        return parseRef(selector) !== null;
+    }
+    getLocator(selectorOrRef, framePath) {
+        const locator = this.getLocatorFromRef(selectorOrRef, framePath);
+        if (locator)
+            return locator;
+        const frame = framePath ? this.getFrame(framePath) : this.getFrame();
+        return frame.locator(selectorOrRef);
+    }
+    getPage() {
+        if (this.pages.length === 0) {
+            throw new Error('Browser not launched. Call launch first.');
+        }
+        return this.pages[this.activePageIndex];
+    }
+    getFrame(framePath) {
+        if (!framePath) {
+            return this.getPage().mainFrame();
+        }
+        return this.getFrameByPath(framePath);
+    }
+    getFrameByPath(framePath) {
+        const page = this.getPage();
+        const selectors = framePath
+            .split('/')
+            .map((s) => s.trim())
+            .filter(Boolean);
+        if (selectors.length === 0) {
+            return page.mainFrame();
+        }
+        let current = page.mainFrame();
+        for (let i = 0; i < selectors.length; i++) {
+            const selector = selectors[i];
+            const childFrames = current.childFrames();
+            if (childFrames.length === 0) {
+                throw new Error(`No child frames found for selector "${selector}" at path position ${i + 1}. ` +
+                    `Path: "${framePath}". ` +
+                    `Current frame has no child frames.`);
+            }
+            const matchedFrame = this.findMatchingFrame(childFrames, selector);
+            if (!matchedFrame) {
+                const availableInfo = childFrames.map((f, idx) => ({
+                    index: idx,
+                    name: f.name(),
+                    url: f.url(),
+                }));
+                const suggestion = childFrames.length > 0
+                    ? ` Use 'agent-browser frames' to list all iframes, or try: ${childFrames.map((f, idx) => `--in-frame "${idx}"`).join(', ')}`
+                    : '';
+                throw new Error(`Frame not found for selector "${selector}" at path position ${i + 1}. ` +
+                    `Path: "${framePath}". ` +
+                    `Available child frames: ${JSON.stringify(availableInfo, null, 2)}.${suggestion}`);
+            }
+            current = matchedFrame;
+        }
+        return current;
+    }
+    findMatchingFrame(frames, selector) {
+        const indexMatch = selector.match(/^(\d+)$/);
+        if (indexMatch) {
+            const index = parseInt(indexMatch[1], 10);
+            return frames[index];
+        }
+        const cleanSelector = selector.replace('#', '');
+        const nameMatch = frames.find((f) => f.name() === selector || f.name() === cleanSelector);
+        if (nameMatch)
+            return nameMatch;
+        const urlPathMatch = frames.find((f) => {
+            const url = f.url();
+            return url.includes(`/${cleanSelector}`) || url.endsWith(`/${cleanSelector}`);
+        });
+        if (urlPathMatch)
+            return urlPathMatch;
+        return undefined;
+    }
+    listFrames() {
+        const page = this.getPage();
+        const result = [];
+        const walk = (frame, pathSoFar) => {
+            const children = frame.childFrames();
+            for (let i = 0; i < children.length; i++) {
+                const child = children[i];
+                const name = child.name() || '';
+                const segment = name || String(i);
+                const childPath = pathSoFar ? `${pathSoFar}/${segment}` : segment;
+                result.push({ name, url: child.url(), path: childPath });
+                walk(child, childPath);
+            }
+        };
+        walk(page.mainFrame(), '');
+        return result;
+    }
+    setDialogHandler(response, promptText) {
+        const page = this.getPage();
+        if (this.dialogHandler) {
+            page.removeListener('dialog', this.dialogHandler);
+        }
+        this.dialogHandler = async (dialog) => {
+            if (response === 'accept') {
+                await dialog.accept(promptText);
+            }
+            else {
+                await dialog.dismiss();
+            }
+        };
+        page.on('dialog', this.dialogHandler);
+    }
+    clearDialogHandler() {
+        if (this.dialogHandler) {
+            const page = this.getPage();
+            page.removeListener('dialog', this.dialogHandler);
+            this.dialogHandler = null;
+        }
+    }
+    startRequestTracking(captureResponse = false) {
+        this.network.startRequestTracking(captureResponse);
+    }
+    get trackingEnabled() {
+        return this.network.trackingEnabled;
+    }
+    getRequests(filter, type) {
+        return this.network.getRequests(filter, type);
+    }
+    clearRequests() {
+        this.network.clearRequests();
+    }
+    startWebSocketTracking() {
+        this.network.startWebSocketTracking();
+    }
+    get wsTrackingEnabled() {
+        return this.network.wsTrackingEnabled;
+    }
+    getWebSockets(filter) {
+        return this.network.getWebSockets(filter);
+    }
+    clearWebSockets() {
+        this.network.clearWebSockets();
+    }
+    saveRequestsToDir(outputDir, filter, type) {
+        return this.network.saveRequestsToDir(outputDir, filter, type);
+    }
+    startConsoleTracking() {
+        this.network.startConsoleTracking();
+    }
+    getConsoleMessages() {
+        return this.network.getConsoleMessages();
+    }
+    clearConsoleMessages() {
+        this.network.clearConsoleMessages();
+    }
+    startErrorTracking() {
+        this.network.startErrorTracking();
+    }
+    getPageErrors() {
+        return this.network.getPageErrors();
+    }
+    clearPageErrors() {
+        this.network.clearPageErrors();
+    }
+    async addRoute(url, options) {
+        const page = this.getPage();
+        const handler = async (route) => {
+            if (options.abort) {
+                await route.abort();
+            }
+            else if (options.response) {
+                await route.fulfill({
+                    status: options.response.status ?? 200,
+                    body: options.response.body ?? '',
+                    contentType: options.response.contentType ?? 'text/plain',
+                    headers: options.response.headers,
+                });
+            }
+            else {
+                await route.continue();
+            }
+        };
+        this.routes.set(url, handler);
+        await page.route(url, handler);
+    }
+    async removeRoute(url) {
+        const page = this.getPage();
+        if (url) {
+            const handler = this.routes.get(url);
+            if (handler) {
+                await page.unroute(url, handler);
+                this.routes.delete(url);
+            }
+        }
+        else {
+            for (const [routeUrl, handler] of this.routes) {
+                await page.unroute(routeUrl, handler);
+            }
+            this.routes.clear();
+        }
+    }
+    async setGeolocation(latitude, longitude, accuracy) {
+        const context = this.contexts[0];
+        if (context) {
+            await context.setGeolocation({ latitude, longitude, accuracy });
+        }
+    }
+    async setPermissions(permissions, grant) {
+        const context = this.contexts[0];
+        if (context) {
+            if (grant) {
+                await context.grantPermissions(permissions);
+            }
+            else {
+                await context.clearPermissions();
+            }
+        }
+    }
+    async setViewport(width, height) {
+        const page = this.getPage();
+        await page.setViewportSize({ width, height });
+    }
+    async setDeviceScaleFactor(deviceScaleFactor, width, height, mobile = false) {
+        const cdp = await this.getCDPSession();
+        await cdp.send('Emulation.setDeviceMetricsOverride', {
+            width,
+            height,
+            deviceScaleFactor,
+            mobile,
+        });
+    }
+    async clearDeviceMetricsOverride() {
+        const cdp = await this.getCDPSession();
+        await cdp.send('Emulation.clearDeviceMetricsOverride');
+    }
+    getDevice(deviceName) {
+        return devices[deviceName];
+    }
+    listDevices() {
+        return Object.keys(devices);
+    }
+    async startHarRecording() {
+        this.isRecordingHar = true;
+    }
+    isHarRecording() {
+        return this.isRecordingHar;
+    }
+    async setOffline(offline) {
+        const context = this.contexts[0];
+        if (context) {
+            await context.setOffline(offline);
+        }
+    }
+    async setExtraHeaders(headers) {
+        const context = this.contexts[0];
+        if (context) {
+            await context.setExtraHTTPHeaders(headers);
+        }
+    }
+    async setScopedHeaders(origin, headers) {
+        const page = this.getPage();
+        let urlPattern;
+        try {
+            const url = new URL(origin.startsWith('http') ? origin : `https://${origin}`);
+            urlPattern = `**://${url.host}/**`;
+        }
+        catch {
+            urlPattern = `**://${origin}/**`;
+        }
+        const existingHandler = this.scopedHeaderRoutes.get(urlPattern);
+        if (existingHandler) {
+            await page.unroute(urlPattern, existingHandler);
+        }
+        const handler = async (route) => {
+            const requestHeaders = route.request().headers();
+            await route.continue({
+                headers: {
+                    ...requestHeaders,
+                    ...headers,
+                },
+            });
+        };
+        this.scopedHeaderRoutes.set(urlPattern, handler);
+        await page.route(urlPattern, handler);
+    }
+    async clearScopedHeaders(origin) {
+        const page = this.getPage();
+        if (origin) {
+            let urlPattern;
+            try {
+                const url = new URL(origin.startsWith('http') ? origin : `https://${origin}`);
+                urlPattern = `**://${url.host}/**`;
+            }
+            catch {
+                urlPattern = `**://${origin}/**`;
+            }
+            const handler = this.scopedHeaderRoutes.get(urlPattern);
+            if (handler) {
+                await page.unroute(urlPattern, handler);
+                this.scopedHeaderRoutes.delete(urlPattern);
+            }
+        }
+        else {
+            for (const [pattern, handler] of this.scopedHeaderRoutes) {
+                await page.unroute(pattern, handler);
+            }
+            this.scopedHeaderRoutes.clear();
+        }
+    }
+    async startTracing(options) {
+        const context = this.contexts[0];
+        if (context) {
+            await context.tracing.start({
+                screenshots: options.screenshots ?? true,
+                snapshots: options.snapshots ?? true,
+            });
+        }
+    }
+    async stopTracing(path) {
+        const context = this.contexts[0];
+        if (context) {
+            await context.tracing.stop({ path });
+        }
+    }
+    async saveStorageState(path) {
+        const context = this.contexts[0];
+        if (context) {
+            await context.storageState({ path });
+        }
+    }
+    getPages() {
+        return this.pages;
+    }
+    getActiveIndex() {
+        return this.activePageIndex;
+    }
+    getBrowser() {
+        return this.browser;
+    }
+    isCdpConnectionAlive() {
+        if (!this.browser)
+            return false;
+        try {
+            const contexts = this.browser.contexts();
+            if (contexts.length === 0) {
+                return false;
+            }
+            return contexts.some((context) => context.pages().length > 0);
+        }
+        catch {
+            return false;
+        }
+    }
+    needsCdpReconnect(cdpEndpoint) {
+        if (!this.browser?.isConnected()) {
+            return true;
+        }
+        if (this.cdpEndpoint !== cdpEndpoint) {
+            return true;
+        }
+        if (!this.isCdpConnectionAlive()) {
+            return true;
+        }
+        return false;
+    }
+    async launch(options) {
+        const cdpEndpoint = options.cdpUrl ?? (options.cdpPort ? String(options.cdpPort) : undefined);
+        const hasExtensions = !!options.extensions?.length;
+        const hasProfile = !!options.profile;
+        const hasStorageState = !!options.storageState;
+        if (hasExtensions && cdpEndpoint) {
+            throw new Error('Extensions cannot be used with CDP connection');
+        }
+        if (hasProfile && cdpEndpoint) {
+            throw new Error('Profile cannot be used with CDP connection');
+        }
+        if (hasStorageState && hasProfile) {
+            throw new Error('Storage state cannot be used with profile (profile is already persistent storage)');
+        }
+        if (hasStorageState && hasExtensions) {
+            throw new Error('Storage state cannot be used with extensions (extensions require persistent context)');
+        }
+        if (this.browser && !this.browser.isConnected()) {
+            await this.close();
+        }
+        if (this.isLaunched()) {
+            const needsRelaunch = (!cdpEndpoint && this.cdpEndpoint !== null) ||
+                (!!cdpEndpoint && this.needsCdpReconnect(cdpEndpoint));
+            if (needsRelaunch) {
+                await this.close();
+            }
+            else {
+                return;
+            }
+        }
+        if (cdpEndpoint) {
+            const result = await connectViaCDP(cdpEndpoint, {
+                addContext: (ctx) => this.contexts.push(ctx),
+                addPage: (p) => this.pages.push(p),
+                setupContextTracking: (ctx) => this.setupContextTracking(ctx),
+                setupPageTracking: (p) => this.setupPageTracking(p),
+            });
+            this.browser = result.browser;
+            this.cdpEndpoint = result.cdpEndpoint;
+            this.activePageIndex = 0;
+            return;
+        }
+        const provider = options.provider ?? process.env.AGENT_BROWSER_PROVIDER;
+        if (provider === 'browserbase') {
+            const session = await connectToBrowserbase();
+            this.browser = session.browser;
+            this.browserbaseSessionId = session.sessionId;
+            this.browserbaseApiKey = session.apiKey;
+            session.context.setDefaultTimeout(10000);
+            this.contexts.push(session.context);
+            this.setupContextTracking(session.context);
+            this.pages.push(session.page);
+            this.activePageIndex = 0;
+            this.setupPageTracking(session.page);
+            return;
+        }
+        if (provider === 'browseruse') {
+            const session = await connectToBrowserUse();
+            this.browser = session.browser;
+            this.browserUseSessionId = session.sessionId;
+            this.browserUseApiKey = session.apiKey;
+            session.context.setDefaultTimeout(60000);
+            this.contexts.push(session.context);
+            this.pages.push(session.page);
+            this.activePageIndex = 0;
+            this.setupPageTracking(session.page);
+            this.setupContextTracking(session.context);
+            return;
+        }
+        if (provider === 'kernel') {
+            const session = await connectToKernel();
+            this.browser = session.browser;
+            this.kernelSessionId = session.sessionId;
+            this.kernelApiKey = session.apiKey;
+            session.context.setDefaultTimeout(60000);
+            this.contexts.push(session.context);
+            this.pages.push(session.page);
+            this.activePageIndex = 0;
+            this.setupPageTracking(session.page);
+            this.setupContextTracking(session.context);
+            return;
+        }
+        const browserType = options.browser ?? 'chromium';
+        if (hasExtensions && browserType !== 'chromium') {
+            throw new Error('Extensions are only supported in Chromium');
+        }
+        if (options.allowFileAccess && browserType !== 'chromium') {
+            throw new Error('allowFileAccess is only supported in Chromium');
+        }
+        const launcher = browserType === 'firefox' ? firefox : browserType === 'webkit' ? webkit : chromium;
+        const viewport = options.viewport ?? { width: 1280, height: 720 };
+        const fileAccessArgs = options.allowFileAccess
+            ? ['--allow-file-access-from-files', '--allow-file-access']
+            : [];
+        const isHeaded = hasExtensions || options.headless === false;
+        const antiDetectionArgs = [
+            '--disable-blink-features=AutomationControlled',
+            '--disable-dev-shm-usage',
+            '--no-sandbox',
+            ...(isHeaded ? [] : ['--disable-gpu']),
+            '--enable-features=WebGL',
+            '--ignore-gpu-blacklist',
+            ...(isHeaded ? ['--use-gl=desktop', '--enable-gpu-compositing'] : []),
+        ];
+        const baseArgs = options.args
+            ? [...fileAccessArgs, ...antiDetectionArgs, ...options.args]
+            : [...fileAccessArgs, ...antiDetectionArgs];
+        let context;
+        if (hasExtensions) {
+            const extPaths = (options.extensions ?? []).join(',');
+            const session = process.env.AGENT_BROWSER_SESSION || 'default';
+            const extArgs = [`--disable-extensions-except=${extPaths}`, `--load-extension=${extPaths}`];
+            const allArgs = baseArgs ? [...extArgs, ...baseArgs] : extArgs;
+            context = await launcher.launchPersistentContext(path.join(os.tmpdir(), `agent-browser-ext-${session}`), {
+                headless: false,
+                executablePath: options.executablePath,
+                args: allArgs,
+                viewport,
+                extraHTTPHeaders: options.headers,
+                userAgent: options.userAgent,
+                ...(options.proxy && { proxy: options.proxy }),
+                ignoreHTTPSErrors: options.ignoreHTTPSErrors ?? false,
+            });
+            this.isPersistentContext = true;
+        }
+        else if (hasProfile) {
+            const profilePath = (options.profile ?? '').replace(/^~\//, os.homedir() + '/');
+            context = await launcher.launchPersistentContext(profilePath, {
+                headless: options.headless ?? true,
+                executablePath: options.executablePath,
+                args: baseArgs,
+                viewport,
+                extraHTTPHeaders: options.headers,
+                userAgent: options.userAgent,
+                ...(options.proxy && { proxy: options.proxy }),
+                ignoreHTTPSErrors: options.ignoreHTTPSErrors ?? false,
+            });
+            this.isPersistentContext = true;
+        }
+        else {
+            this.browser = await launcher.launch({
+                headless: options.headless ?? true,
+                executablePath: options.executablePath,
+                args: baseArgs,
+            });
+            this.cdpEndpoint = null;
+            context = await this.browser.newContext({
+                viewport,
+                extraHTTPHeaders: options.headers,
+                userAgent: options.userAgent,
+                ...(options.proxy && { proxy: options.proxy }),
+                ignoreHTTPSErrors: options.ignoreHTTPSErrors ?? false,
+                ...(options.storageState && { storageState: options.storageState }),
+            });
+        }
+        await context.addInitScript(() => {
+            if (!window.chrome) {
+                window.chrome = {
+                    runtime: {},
+                    loadTimes: function () { },
+                    csi: function () { },
+                    app: {},
+                };
+            }
+            Object.defineProperty(navigator, 'plugins', {
+                get: () => [
+                    {
+                        name: 'Chrome PDF Plugin',
+                        filename: 'internal-pdf-viewer',
+                        description: 'Portable Document Format',
+                    },
+                    {
+                        name: 'Chrome PDF Viewer',
+                        filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai',
+                        description: '',
+                    },
+                    {
+                        name: 'Native Client',
+                        filename: 'internal-nacl-plugin',
+                        description: '',
+                    },
+                ],
+            });
+            Object.defineProperty(navigator, 'mimeTypes', {
+                get: () => [
+                    {
+                        type: 'application/pdf',
+                        suffixes: 'pdf',
+                        description: 'Portable Document Format',
+                    },
+                    {
+                        type: 'application/x-google-chrome-pdf',
+                        suffixes: 'pdf',
+                        description: 'Portable Document Format',
+                    },
+                ],
+            });
+        });
+        context.setDefaultTimeout(60000);
+        this.contexts.push(context);
+        this.setupContextTracking(context);
+        const page = context.pages()[0] ?? (await context.newPage());
+        if (!this.pages.includes(page)) {
+            this.pages.push(page);
+            this.setupPageTracking(page);
+        }
+        this.activePageIndex = this.pages.length > 0 ? this.pages.length - 1 : 0;
+    }
+    setupPageTracking(page) {
+        this.network.setupPageTracking(page);
+        page.on('load', async () => {
+            const callbacks = getEventCallbacks();
+            callbacks.onNavigation?.({
+                url: page.url(),
+                title: await page.title().catch(() => ''),
+            });
+        });
+        page.on('close', () => {
+            const index = this.pages.indexOf(page);
+            if (index !== -1) {
+                this.pages.splice(index, 1);
+                if (this.activePageIndex >= this.pages.length) {
+                    this.activePageIndex = Math.max(0, this.pages.length - 1);
+                }
+                const callbacks = getEventCallbacks();
+                callbacks.onTabClosed?.({
+                    index,
+                    remainingTabs: this.pages.length,
+                });
+            }
+        });
+    }
+    async setupContextTracking(context) {
+        context.on('page', async (page) => {
+            if (!this.pages.includes(page)) {
+                this.pages.push(page);
+                this.setupPageTracking(page);
+            }
+            const callbacks = getEventCallbacks();
+            if (callbacks.onTabCreated) {
+                const index = this.pages.length - 1;
+                callbacks.onTabCreated({
+                    index,
+                    url: page.url(),
+                    title: await page.title().catch(() => ''),
+                });
+            }
+            const newIndex = this.pages.indexOf(page);
+            if (newIndex !== -1 && newIndex !== this.activePageIndex) {
+                this.activePageIndex = newIndex;
+                this.invalidateCDPSession().catch(() => { });
+            }
+        });
+    }
+    async newTab() {
+        if (!this.browser || this.contexts.length === 0) {
+            throw new Error('Browser not launched');
+        }
+        await this.invalidateCDPSession();
+        const context = this.contexts[0];
+        const page = await context.newPage();
+        if (!this.pages.includes(page)) {
+            this.pages.push(page);
+            this.setupPageTracking(page);
+        }
+        this.activePageIndex = this.pages.length - 1;
+        const callbacks = getEventCallbacks();
+        if (callbacks.onTabCreated) {
+            const index = this.pages.length - 1;
+            callbacks.onTabCreated({
+                index,
+                url: page.url(),
+                title: await page.title().catch(() => ''),
+            });
+        }
+        return { index: this.activePageIndex, total: this.pages.length };
+    }
+    async newWindow(viewport) {
+        if (!this.browser) {
+            throw new Error('Browser not launched');
+        }
+        const context = await this.browser.newContext({
+            viewport: viewport ?? { width: 1280, height: 720 },
+        });
+        context.setDefaultTimeout(60000);
+        this.contexts.push(context);
+        this.setupContextTracking(context);
+        const page = await context.newPage();
+        if (!this.pages.includes(page)) {
+            this.pages.push(page);
+            this.setupPageTracking(page);
+        }
+        this.activePageIndex = this.pages.length - 1;
+        const callbacks = getEventCallbacks();
+        if (callbacks.onTabCreated) {
+            const index = this.pages.length - 1;
+            callbacks.onTabCreated({
+                index,
+                url: page.url(),
+                title: await page.title().catch(() => ''),
+            });
+        }
+        return { index: this.activePageIndex, total: this.pages.length };
+    }
+    async invalidateCDPSession() {
+        const shouldRestart = this.screencast.shouldBeActive;
+        const savedCallback = this.screencast.savedCallback;
+        const savedOptions = this.screencast.savedOptions;
+        if (this.screencast.active) {
+            await this.screencast.stopScreencastInternal();
+        }
+        if (this.cdpSession) {
+            await this.cdpSession.detach().catch(() => { });
+            this.cdpSession = null;
+        }
+        if (shouldRestart && savedCallback) {
+            try {
+                await this.screencast.startScreencast(savedCallback, savedOptions ?? undefined);
+            }
+            catch {
+                // Ignore errors when restarting screencast on new page
+            }
+        }
+    }
+    async switchTo(index) {
+        if (index < 0 || index >= this.pages.length) {
+            throw new Error(`Invalid tab index: ${index}. Available: 0-${this.pages.length - 1}`);
+        }
+        if (index !== this.activePageIndex) {
+            await this.invalidateCDPSession();
+        }
+        const previousIndex = this.activePageIndex;
+        this.activePageIndex = index;
+        const page = this.pages[index];
+        if (this.recorder.getSessionId() && previousIndex !== index) {
+            this.recorder.addStep({
+                id: `step-${Date.now()}`,
+                timestamp: Date.now(),
+                action: 'tab_switch',
+                index: index,
+            });
+        }
+        const callbacks = getEventCallbacks();
+        callbacks.onTabSwitched?.({
+            fromIndex: previousIndex,
+            toIndex: index,
+        });
+        return {
+            index: this.activePageIndex,
+            url: page.url(),
+            title: '',
+        };
+    }
+    async closeTab(index) {
+        const targetIndex = index ?? this.activePageIndex;
+        if (targetIndex < 0 || targetIndex >= this.pages.length) {
+            throw new Error(`Invalid tab index: ${targetIndex}`);
+        }
+        if (this.pages.length === 1) {
+            throw new Error('Cannot close the last tab. Use "close" to close the browser.');
+        }
+        if (this.recorder.getSessionId()) {
+            this.recorder.addStep({
+                id: `step-${Date.now()}`,
+                timestamp: Date.now(),
+                action: 'tab_close',
+                index: targetIndex,
+            });
+        }
+        if (targetIndex === this.activePageIndex) {
+            await this.invalidateCDPSession();
+        }
+        const page = this.pages[targetIndex];
+        await page.close();
+        this.pages.splice(targetIndex, 1);
+        if (this.activePageIndex >= this.pages.length) {
+            this.activePageIndex = this.pages.length - 1;
+        }
+        else if (this.activePageIndex > targetIndex) {
+            this.activePageIndex--;
+        }
+        return { closed: targetIndex, remaining: this.pages.length };
+    }
+    async listTabs() {
+        const tabs = await Promise.all(this.pages.map(async (page, index) => ({
+            index,
+            url: page.url(),
+            title: await page.title().catch(() => ''),
+            active: index === this.activePageIndex,
+        })));
+        return tabs;
+    }
+    async getCDPSession() {
+        if (this.cdpSession) {
+            return this.cdpSession;
+        }
+        const page = this.getPage();
+        const context = page.context();
+        this.cdpSession = await context.newCDPSession(page);
+        return this.cdpSession;
+    }
+    isScreencasting() {
+        return this.screencast.isScreencasting();
+    }
+    async startScreencast(callback, options) {
+        return this.screencast.startScreencast(callback, options);
+    }
+    async stopScreencast() {
+        return this.screencast.stopScreencast();
+    }
+    async injectMouseEvent(params) {
+        return this.screencast.injectMouseEvent(params);
+    }
+    async injectKeyboardEvent(params) {
+        return this.screencast.injectKeyboardEvent(params);
+    }
+    async injectTouchEvent(params) {
+        return this.screencast.injectTouchEvent(params);
+    }
+    async insertText(text) {
+        return this.screencast.insertText(text);
+    }
+    _lastFillSelector = '';
+    _lastFillValue = '';
+    _fillFocusedSelector = '';
+    async fillValue(selector, value) {
+        const page = this.getPage();
+        if (!page)
+            return;
+        if (!selector || value === undefined)
+            return;
+        if (value === this._lastFillValue && selector === this._lastFillSelector)
+            return;
+        this._lastFillSelector = selector;
+        this._lastFillValue = value;
+        const needsFocus = !this._fillFocusedSelector || this._fillFocusedSelector !== selector;
+        await page.evaluate(({ selector, value, needsFocus }) => {
+            const el = document.querySelector(selector);
+            if (!el)
+                return { ok: false, reason: 'not_found' };
+            const isContentEditable = el instanceof HTMLElement &&
+                (el.isContentEditable || el.getAttribute('contenteditable') === 'true');
+            if (needsFocus && !isContentEditable) {
+                el.focus();
+            }
+            if (isContentEditable) {
+                if (needsFocus)
+                    el.focus();
+                document.execCommand('selectAll', false, undefined);
+                document.execCommand('insertText', false, value);
+                return { ok: true, method: 'contenteditable' };
+            }
+            const tag = el.tagName.toLowerCase();
+            const isInput = tag === 'input';
+            const isTextarea = tag === 'textarea';
+            if (!isInput && !isTextarea) {
+                return { ok: false, reason: 'not_input' };
+            }
+            const proto = isInput
+                ? window.HTMLInputElement.prototype
+                : window.HTMLTextAreaElement.prototype;
+            const nativeInputValueSetter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
+            if (nativeInputValueSetter) {
+                nativeInputValueSetter.call(el, value);
+            }
+            else {
+                el.value = value;
+            }
+            el.dispatchEvent(new InputEvent('input', {
+                bubbles: true,
+                cancelable: true,
+                inputType: 'insertReplacementText',
+                data: value,
+            }));
+            return { ok: true, method: 'native_setter' };
+        }, { selector, value, needsFocus });
+        if (needsFocus) {
+            this._fillFocusedSelector = selector;
+        }
+    }
+    clearFillState(selector) {
+        if (selector && this._fillFocusedSelector === selector) {
+            this._fillFocusedSelector = '';
+        }
+        if (!selector) {
+            this._fillFocusedSelector = '';
+            this._lastFillSelector = '';
+            this._lastFillValue = '';
+        }
+    }
+    async blurElement(selector) {
+        const page = this.getPage();
+        if (!page)
+            return;
+        await page.evaluate((sel) => {
+            const el = document.querySelector(sel);
+            if (el)
+                el.blur();
+        }, selector);
+    }
+    async pressKey(key) {
+        const page = this.getPage();
+        if (!page)
+            return;
+        await page.keyboard.press(key);
+    }
+    async injectFocusListener(onEvent) {
+        const page = this.getPage();
+        if (!page)
+            return;
+        try {
+            await page.exposeFunction('__agentBrowserInputEvent', (data) => {
+                onEvent(data);
+            });
+        }
+        catch {
+            // Already registered from previous injection - safe to continue
+        }
+        const injectScript = `
+      (function() {
+        if (window.__agentBrowserListenerInjected) return;
+        window.__agentBrowserListenerInjected = true;
+
+        document.addEventListener('focus', function(e) {
+          var el = e.target;
+          if (!el) return;
+          var tag = el.tagName;
+          if (tag !== 'INPUT' && tag !== 'TEXTAREA' && !el.isContentEditable) return;
+          try {
+            window.__agentBrowserInputEvent({
+              type: 'input_focused',
+              tag: tag,
+              inputType: el.type || '',
+              value: typeof el.value === 'string' ? el.value : '',
+              placeholder: el.placeholder || '',
+              id: el.id || '',
+              selector: (function() {
+                if (el.id) return '#' + el.id;
+                if (el.name && el.name) return '[name="' + el.name + '"]';
+                return el.tagName.toLowerCase();
+              })()
+            });
+          } catch(ex) {}
+        }, true);
+
+        document.addEventListener('input', function(e) {
+          var el = e.target;
+          if (!el) return;
+          var tag = el.tagName;
+          if (tag !== 'INPUT' && tag !== 'TEXTAREA' && !el.isContentEditable) return;
+          try {
+            window.__agentBrowserInputEvent({
+              type: 'input_value',
+              text: typeof el.value === 'string' ? el.value : ''
+            });
+          } catch(ex) {}
+        }, true);
+
+        document.addEventListener('blur', function() {
+          try {
+            window.__agentBrowserInputEvent({ type: 'input_blur' });
+          } catch(ex) {}
+        }, true);
+      })();
+    `;
+        await page.addInitScript(injectScript);
+        await page.evaluate(injectScript);
+    }
+    isRecording() {
+        return this.recording.isRecording();
+    }
+    isRecordingSession() {
+        return this.recorder.isRecordingSession();
+    }
+    async injectRecorderIfNeeded() {
+        return this.recorder.injectRecorderIfNeeded();
+    }
+    get recorderPaused() {
+        return this.recorder.recorderPaused;
+    }
+    set recorderPaused(val) {
+        this.recorder.recorderPaused = val;
+    }
+    pauseRecording() {
+        this.recorder.pauseRecording();
+    }
+    resumeRecording() {
+        this.recorder.resumeRecording();
+    }
+    recordStep(step) {
+        this.recorder.recordStep(step);
+    }
+    async startRecording(outputPath, url) {
+        return this.recording.startRecording(outputPath, url);
+    }
+    async stopRecording() {
+        return this.recording.stopRecording();
+    }
+    async restartRecording(outputPath, url) {
+        return this.recording.restartRecording(outputPath, url);
+    }
+    async startRecorder(url, hide = false) {
+        return this.recorder.startRecorder(url, hide);
+    }
+    async stopRecorder() {
+        return this.recorder.stopRecorder();
+    }
+    getRecorderStatus() {
+        return this.recorder.getRecorderStatus();
+    }
+    async close() {
+        if (this.recording.isRecording()) {
+            await this.recording.stopRecording();
+        }
+        if (this.screencast.active) {
+            await this.screencast.stopScreencast();
+        }
+        const page = this.pages.length > 0 ? this.getPage() : null;
+        this.recorder.cleanup(page);
+        this.network.cleanup(page);
+        this.routes.clear();
+        if (this.cdpSession) {
+            await this.cdpSession.detach().catch(() => { });
+            this.cdpSession = null;
+        }
+        const closePages = async () => {
+            for (const page of this.pages) {
+                await page.close().catch(() => { });
+            }
+        };
+        const closeBrowser = async () => {
+            if (this.browser) {
+                await this.browser.close().catch(() => { });
+                this.browser = null;
+            }
+        };
+        if (this.browserbaseSessionId && this.browserbaseApiKey) {
+            await closeBrowserbaseSession(this.browserbaseSessionId, this.browserbaseApiKey).catch((error) => {
+                console.error('Failed to close Browserbase session:', error);
+            });
+            this.browser = null;
+        }
+        else if (this.browserUseSessionId && this.browserUseApiKey) {
+            await closeBrowserUseSession(this.browserUseSessionId, this.browserUseApiKey).catch((error) => {
+                console.error('Failed to close Browser Use session:', error);
+            });
+            this.browser = null;
+        }
+        else if (this.kernelSessionId && this.kernelApiKey) {
+            await closeKernelSession(this.kernelSessionId, this.kernelApiKey).catch((error) => {
+                console.error('Failed to close Kernel session:', error);
+            });
+            this.browser = null;
+        }
+        else if (this.cdpEndpoint !== null) {
+            console.log('[DEBUG close] CDP endpoint detected:', this.cdpEndpoint);
+            console.log('[DEBUG close] browser exists:', !!this.browser);
+            if (this.browser) {
+                try {
+                    console.log('[DEBUG close] CDP connection - closing pages and disconnecting');
+                    await closePages();
+                    await this.browser.close();
+                    console.log('[DEBUG close] CDP connection closed');
+                }
+                catch (e) {
+                    console.log('[DEBUG close] CDP disconnect failed:', e);
+                }
+                finally {
+                    this.browser = null;
+                }
+            }
+        }
+        else {
+            await closePages();
+            for (const context of this.contexts) {
+                await context.close().catch(() => { });
+            }
+            await closeBrowser();
+        }
+        this.pages = [];
+        this.contexts = [];
+        this.cdpEndpoint = null;
+        this.browserbaseSessionId = null;
+        this.browserbaseApiKey = null;
+        this.browserUseSessionId = null;
+        this.browserUseApiKey = null;
+        this.kernelSessionId = null;
+        this.kernelApiKey = null;
+        this.isPersistentContext = false;
+        this.activePageIndex = 0;
+        this.refMap = {};
+        this.lastSnapshot = '';
+        this.screencast.cleanup();
+        this.recording.cleanup();
+    }
+}
+//# sourceMappingURL=browser-manager.js.map