@mastra/browser-viewer 0.0.0

package/dist/index.cjs

@@ -0,0 +1,796 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BrowserViewer: () => BrowserViewer,
+  BrowserViewerThreadManager: () => BrowserViewerThreadManager
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/browser-viewer.ts
+var import_browser2 = require("@mastra/core/browser");
+
+// src/thread-manager.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_browser = require("@mastra/core/browser");
+var import_playwright_core = require("playwright-core");
+var BrowserViewerThreadManager = class extends import_browser.ThreadManager {
+  browserConfig;
+  onBrowserCreated;
+  onBrowserClosed;
+  /** Map of thread ID to session info (for 'thread' scope) */
+  threadSessions = /* @__PURE__ */ new Map();
+  /** Shared session info (for 'shared' scope) */
+  sharedSession = null;
+  /** Cached CDP sessions for input injection, keyed by threadId */
+  inputCdpSessions = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super(config);
+    this.browserConfig = config.browserConfig;
+    this.onBrowserCreated = config.onBrowserCreated;
+    this.onBrowserClosed = config.onBrowserClosed;
+  }
+  /**
+   * Check if a thread should use the shared session slot.
+   * In shared scope, all threads use the shared session.
+   * In thread scope, DEFAULT_THREAD_ID also uses the shared session.
+   */
+  usesSharedSlot(threadId) {
+    return this.scope === "shared" || threadId === import_browser.DEFAULT_THREAD_ID;
+  }
+  /**
+   * Get the viewer session for a thread, using consistent routing.
+   * Handles both shared and thread-scoped sessions.
+   */
+  getViewerSession(threadId) {
+    if (this.usesSharedSlot(threadId)) {
+      return this.sharedSession;
+    }
+    return this.threadSessions.get(threadId) ?? null;
+  }
+  // ---------------------------------------------------------------------------
+  // Session Storage & Cleanup Helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Store a session in the appropriate slot based on scope.
+   * Consolidates session storage logic used by createSession, createSharedSession,
+   * createSharedSessionFromCdp, and connectToExternalCdp.
+   */
+  storeSession(session, threadId) {
+    if (this.usesSharedSlot(threadId)) {
+      this.sharedSession = session;
+      this.sessions.set(import_browser.DEFAULT_THREAD_ID, session);
+      this.setSharedManager(session.browser);
+    } else {
+      this.threadSessions.set(threadId, session);
+      this.sessions.set(threadId, session);
+      this.threadManagers.set(threadId, session.browser);
+    }
+  }
+  /**
+   * Clear a session from the appropriate slot based on scope.
+   * Must be called BEFORE async cleanup operations to prevent double callbacks
+   * from disconnect handlers.
+   */
+  clearSessionState(threadId) {
+    if (this.usesSharedSlot(threadId)) {
+      this.sharedSession = null;
+      this.clearSharedManager();
+      this.sessions.delete(import_browser.DEFAULT_THREAD_ID);
+    } else {
+      this.threadSessions.delete(threadId);
+      this.threadManagers.delete(threadId);
+      this.sessions.delete(threadId);
+    }
+  }
+  /**
+   * Clean up a session's resources (CDP session, browser, server).
+   * Consolidates cleanup logic used by closeThreadBrowser, closeSharedBrowser,
+   * and doDestroySession.
+   *
+   * @param session - The session to clean up
+   * @param threadId - The thread ID (for onBrowserClosed callback)
+   */
+  async cleanupSession(session, threadId) {
+    this.clearSessionState(threadId);
+    this.inputCdpSessions.delete(threadId);
+    if (session.cdpSession) {
+      try {
+        await session.cdpSession.detach();
+      } catch {
+      }
+    }
+    try {
+      await session.browser.close();
+    } catch {
+    }
+    if (session.browserServer) {
+      try {
+        await session.browserServer.close();
+      } catch {
+      }
+    }
+    this.onBrowserClosed?.(threadId);
+  }
+  /**
+   * Launch a new browser instance and return the components.
+   * Consolidates the launch logic shared by createSession and createSharedSession.
+   *
+   * @param threadId - Thread ID for logging and disconnect handler
+   */
+  async launchBrowser(threadId) {
+    const cdpPort = this.browserConfig.cdpPort ?? 0;
+    this.logger?.debug?.(`Launching Chrome for thread ${threadId} with remote-debugging-port=${cdpPort}`);
+    const launchOptions = {
+      headless: this.browserConfig.headless ?? false,
+      args: [`--remote-debugging-port=${cdpPort}`, "--no-first-run", "--no-default-browser-check"]
+    };
+    if (this.browserConfig.executablePath) {
+      launchOptions.executablePath = this.browserConfig.executablePath;
+    }
+    let browserServer = null;
+    let browser = null;
+    try {
+      browserServer = await import_playwright_core.chromium.launchServer(launchOptions);
+      const cdpUrl = this.discoverCdpUrl(browserServer);
+      browser = await import_playwright_core.chromium.connect(browserServer.wsEndpoint());
+      const context = await browser.newContext({
+        viewport: this.browserConfig.viewport ?? { width: 1280, height: 720 }
+      });
+      await context.newPage();
+      const pages = context.pages();
+      const cdpSession = pages[0] ? await context.newCDPSession(pages[0]) : null;
+      let disconnectHandled = false;
+      const handleDisconnect = () => {
+        if (disconnectHandled) return;
+        disconnectHandled = true;
+        this.handleBrowserDisconnected(threadId);
+      };
+      browserServer.on("close", handleDisconnect);
+      browser.on("disconnected", handleDisconnect);
+      try {
+        const browserCdpSession = await browser.newBrowserCDPSession();
+        await browserCdpSession.send("Target.setDiscoverTargets", { discover: true });
+        browserCdpSession.on("Target.targetDestroyed", async () => {
+          try {
+            const { targetInfos } = await browserCdpSession.send("Target.getTargets");
+            const pageTargets = targetInfos.filter(
+              (t) => t.type === "page" && !t.url.startsWith("chrome://") && !t.url.startsWith("devtools://")
+            );
+            if (pageTargets.length === 0) {
+              handleDisconnect();
+            }
+          } catch {
+            handleDisconnect();
+          }
+        });
+        browserCdpSession.on("Inspector.detached", handleDisconnect);
+      } catch {
+        this.logger?.debug?.("Failed to set up browser-level CDP target watching");
+      }
+      return { browserServer, browser, context, cdpSession, cdpUrl };
+    } catch (error) {
+      this.logger?.warn?.(`Failed to launch browser for thread ${threadId}: ${error}`);
+      await browser?.close().catch(() => {
+      });
+      await browserServer?.close().catch(() => {
+      });
+      throw error;
+    }
+  }
+  /**
+   * Get CDP URL for a specific thread.
+   */
+  getCdpUrlForThread(threadId) {
+    const effectiveThreadId = threadId ?? import_browser.DEFAULT_THREAD_ID;
+    return this.getViewerSession(effectiveThreadId)?.cdpUrl ?? null;
+  }
+  /**
+   * Get the active page for a thread.
+   */
+  async getActivePageForThread(threadId) {
+    const effectiveThreadId = threadId ?? import_browser.DEFAULT_THREAD_ID;
+    const session = this.getViewerSession(effectiveThreadId);
+    if (!session?.context) {
+      return null;
+    }
+    return this.resolveActivePage(session.context);
+  }
+  /**
+   * Resolve the active page from a browser context.
+   * Uses last page (most recently opened) with fallback to first page.
+   */
+  resolveActivePage(context) {
+    const pages = context.pages();
+    return pages[pages.length - 1] ?? pages[0] ?? null;
+  }
+  /**
+   * Get or create a CDP session for the active page in a thread.
+   *
+   * CDP sessions are page-scoped, so we create a fresh one for the currently active page
+   * rather than caching one that may point to a closed or inactive page.
+   */
+  async getCdpSessionForThread(threadId) {
+    const effectiveThreadId = threadId ?? import_browser.DEFAULT_THREAD_ID;
+    const session = this.getViewerSession(effectiveThreadId);
+    if (!session?.context) {
+      return null;
+    }
+    if (session.browser && !session.browser.isConnected()) {
+      this.handleBrowserDisconnected(effectiveThreadId);
+      return null;
+    }
+    const activePage = this.resolveActivePage(session.context);
+    if (!activePage) {
+      return null;
+    }
+    const cached = this.inputCdpSessions.get(effectiveThreadId);
+    const currentUrl = activePage.url();
+    if (cached && cached.pageUrl === currentUrl) {
+      return cached.session;
+    }
+    try {
+      const cdpSession = await session.context.newCDPSession(activePage);
+      this.inputCdpSessions.set(effectiveThreadId, { session: cdpSession, pageUrl: currentUrl });
+      return cdpSession;
+    } catch {
+      this.inputCdpSessions.delete(effectiveThreadId);
+      this.handleBrowserDisconnected(effectiveThreadId);
+      return null;
+    }
+  }
+  /**
+   * Get the browser context for a thread.
+   */
+  getContextForThread(threadId) {
+    const effectiveThreadId = threadId ?? import_browser.DEFAULT_THREAD_ID;
+    return this.getViewerSession(effectiveThreadId)?.context ?? null;
+  }
+  /**
+   * Create a fresh CDP session for the active page (not cached).
+   * Used by screencast which needs fresh sessions on tab switches.
+   */
+  async createFreshCdpSession(threadId) {
+    const effectiveThreadId = threadId ?? import_browser.DEFAULT_THREAD_ID;
+    const session = this.getViewerSession(effectiveThreadId);
+    if (!session?.context) {
+      return null;
+    }
+    const activePage = this.resolveActivePage(session.context);
+    if (!activePage) {
+      return null;
+    }
+    try {
+      return await session.context.newCDPSession(activePage);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Create a new session for a thread.
+   */
+  async createSession(threadId) {
+    const savedState = this.getSavedBrowserState(threadId);
+    const { browserServer, browser, context, cdpSession, cdpUrl } = await this.launchBrowser(threadId);
+    const session = {
+      threadId,
+      createdAt: Date.now(),
+      browserState: savedState,
+      browserServer,
+      browser,
+      context,
+      cdpSession,
+      cdpUrl
+    };
+    this.storeSession(session, threadId);
+    this.logger?.debug?.(`Chrome launched for thread ${threadId}, CDP URL: ${cdpUrl}`);
+    this.onBrowserCreated?.(browser, threadId, cdpUrl);
+    return session;
+  }
+  /**
+   * Discover the actual CDP WebSocket URL from Chrome's DevToolsActivePort file.
+   *
+   * Playwright's BrowserServer exposes _userDataDirForTest which points to Chrome's
+   * user data directory. Chrome writes a DevToolsActivePort file there containing:
+   *   Line 1: The debugging port number
+   *   Line 2: The browser WebSocket path (e.g., /devtools/browser/<guid>)
+   *
+   * This gives us the real CDP URL that external tools like agent-browser can connect to.
+   * Returns null if discovery fails - callers should handle this case.
+   */
+  discoverCdpUrl(browserServer) {
+    const userDataDir = browserServer._userDataDirForTest;
+    if (!userDataDir) {
+      this.logger?.warn?.("Could not access browser user data directory");
+      return null;
+    }
+    const portFilePath = (0, import_node_path.join)(userDataDir, "DevToolsActivePort");
+    const deadline = Date.now() + 1500;
+    while (!(0, import_node_fs.existsSync)(portFilePath) && Date.now() < deadline) {
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50);
+    }
+    if (!(0, import_node_fs.existsSync)(portFilePath)) {
+      this.logger?.warn?.("DevToolsActivePort file not found");
+      return null;
+    }
+    try {
+      const content = (0, import_node_fs.readFileSync)(portFilePath, "utf-8").trim().split("\n");
+      const port = content[0];
+      const browserPath = content[1];
+      if (!port || !browserPath) {
+        this.logger?.warn?.("Invalid DevToolsActivePort content");
+        return null;
+      }
+      const cdpUrl = `ws://127.0.0.1:${port}${browserPath}`;
+      this.logger?.debug?.(`Discovered CDP URL from DevToolsActivePort: ${cdpUrl}`);
+      return cdpUrl;
+    } catch (error) {
+      this.logger?.warn?.("Failed to read DevToolsActivePort file:", error);
+      return null;
+    }
+  }
+  /**
+   * Create a shared session by connecting to an existing browser via CDP URL.
+   * Used when BrowserViewer is configured with a cdpUrl to connect to an external browser.
+   */
+  async createSharedSessionFromCdp(cdpUrl) {
+    if (this.sharedSession) {
+      return;
+    }
+    await this.connectToCdp(cdpUrl, import_browser.DEFAULT_THREAD_ID);
+  }
+  /**
+   * Create a shared session (for 'shared' scope).
+   */
+  async createSharedSession() {
+    if (this.sharedSession) {
+      return;
+    }
+    const { browserServer, browser, context, cdpSession, cdpUrl } = await this.launchBrowser(import_browser.DEFAULT_THREAD_ID);
+    const session = {
+      threadId: import_browser.DEFAULT_THREAD_ID,
+      createdAt: Date.now(),
+      browserServer,
+      browser,
+      context,
+      cdpSession,
+      cdpUrl
+    };
+    this.storeSession(session, import_browser.DEFAULT_THREAD_ID);
+    this.logger?.debug?.(`Shared Chrome launched, CDP URL: ${cdpUrl}`);
+    this.onBrowserCreated?.(browser, import_browser.DEFAULT_THREAD_ID, cdpUrl);
+    this.onSessionCreated?.(session);
+  }
+  /**
+   * Handle browser disconnection for a thread.
+   */
+  handleBrowserDisconnected(threadId) {
+    this.logger?.debug?.(`Browser disconnected for thread ${threadId}`);
+    if (!this.getViewerSession(threadId)) return;
+    this.clearSessionState(threadId);
+    this.onBrowserClosed?.(threadId);
+  }
+  /**
+   * Connect to an external browser via CDP URL for screencast.
+   *
+   * This is used when an agent is using their own external CDP (e.g., browser-use cloud).
+   * We connect Playwright to the external browser to enable screencast without launching
+   * our own browser.
+   *
+   * @param cdpUrl - The external CDP WebSocket URL (wss://... or ws://...)
+   * @param threadId - Thread ID to associate the session with
+   */
+  async connectToExternalCdp(cdpUrl, threadId) {
+    if (this.getViewerSession(threadId)) {
+      if (this.usesSharedSlot(threadId)) {
+        await this.closeSharedBrowser();
+      } else {
+        await this.closeThreadBrowser(threadId);
+      }
+    }
+    return this.connectToCdp(cdpUrl, threadId);
+  }
+  /**
+   * Connect to a browser via CDP URL and create a session.
+   * Shared implementation for createSharedSessionFromCdp and connectToExternalCdp.
+   */
+  async connectToCdp(cdpUrl, threadId) {
+    const effectiveThreadId = this.usesSharedSlot(threadId) ? import_browser.DEFAULT_THREAD_ID : threadId;
+    this.logger?.debug?.(`Connecting to CDP for thread ${effectiveThreadId}: ${cdpUrl}`);
+    let browser = null;
+    try {
+      browser = await import_playwright_core.chromium.connectOverCDP(cdpUrl);
+      const contexts = browser.contexts();
+      const context = contexts[0] ?? await browser.newContext();
+      let pages = context.pages();
+      if (pages.length === 0) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+        pages = context.pages();
+        if (pages.length === 0) {
+          await context.newPage();
+          pages = context.pages();
+        }
+      }
+      const cdpSession = pages[0] ? await context.newCDPSession(pages[0]) : null;
+      let disconnectHandled = false;
+      const handleDisconnect = () => {
+        if (disconnectHandled) return;
+        disconnectHandled = true;
+        this.handleBrowserDisconnected(effectiveThreadId);
+      };
+      context.on("close", handleDisconnect);
+      browser.on("disconnected", handleDisconnect);
+      const session = {
+        threadId: effectiveThreadId,
+        createdAt: Date.now(),
+        browserServer: null,
+        // We don't own the server for external CDP connections
+        browser,
+        context,
+        cdpSession,
+        cdpUrl
+      };
+      this.storeSession(session, threadId);
+      this.logger?.debug?.(`Connected to CDP for thread ${effectiveThreadId}`);
+      this.onBrowserCreated?.(browser, effectiveThreadId, cdpUrl);
+      this.onSessionCreated?.(session);
+      return session;
+    } catch (error) {
+      this.logger?.warn?.(`Failed to connect to CDP: ${error}`);
+      await browser?.close().catch(() => {
+      });
+      throw error;
+    }
+  }
+  /**
+   * Close a specific thread's browser.
+   */
+  async closeThreadBrowser(threadId) {
+    const session = this.threadSessions.get(threadId);
+    if (!session) {
+      return;
+    }
+    await this.cleanupSession(session, threadId);
+  }
+  /**
+   * Close the shared browser.
+   */
+  async closeSharedBrowser() {
+    if (!this.sharedSession) {
+      return;
+    }
+    await this.cleanupSession(this.sharedSession, import_browser.DEFAULT_THREAD_ID);
+  }
+  /**
+   * Close all browsers.
+   */
+  async closeAll() {
+    const threadIds = Array.from(this.threadSessions.keys());
+    await Promise.all(threadIds.map((id) => this.closeThreadBrowser(id)));
+    await this.closeSharedBrowser();
+  }
+  /**
+   * Get the manager for a session.
+   * Required by base class.
+   */
+  getManagerForSession(session) {
+    const viewerSession = session;
+    return viewerSession.browser;
+  }
+  /**
+   * Get the shared manager.
+   * Required by base class.
+   */
+  getSharedManager() {
+    if (!this.sharedSession) {
+      throw new Error("Shared browser not launched. Call createSharedSession() first.");
+    }
+    return this.sharedSession.browser;
+  }
+  /**
+   * Destroy a session and clean up resources.
+   * Required by base class.
+   */
+  async doDestroySession(session) {
+    const viewerSession = this.getViewerSession(session.threadId);
+    if (!viewerSession) {
+      return;
+    }
+    await this.cleanupSession(viewerSession, session.threadId);
+  }
+  /**
+   * Check if browser is running for a thread.
+   */
+  isBrowserRunning(threadId) {
+    const effectiveThreadId = threadId ?? import_browser.DEFAULT_THREAD_ID;
+    return this.getViewerSession(effectiveThreadId) !== null;
+  }
+};
+
+// src/browser-viewer.ts
+var BrowserViewer = class extends import_browser2.MastraBrowser {
+  id;
+  name = "BrowserViewer";
+  provider = "browser-viewer";
+  providerType = "cli";
+  /** Which CLI the agent uses */
+  cli;
+  /** Viewer-specific config (stored for reference) */
+  viewerConfig;
+  constructor(config) {
+    const effectiveScope = config.cdpUrl ? config.scope ?? "shared" : config.scope ?? "thread";
+    const { cli: _cli, cdpPort: _cdpPort, userDataDir: _userDataDir, ...baseConfig } = config;
+    super({
+      ...baseConfig,
+      scope: effectiveScope
+    });
+    this.id = `browser-viewer-${Date.now()}`;
+    this.cli = config.cli;
+    this.viewerConfig = config;
+    this.threadManager = new BrowserViewerThreadManager({
+      scope: effectiveScope,
+      browserConfig: config,
+      logger: this.logger,
+      onSessionCreated: (session) => {
+        this.notifyBrowserReady(session.threadId);
+      },
+      onBrowserCreated: (_browser, threadId, _cdpUrl) => {
+        this.logger?.debug?.(`Browser created for thread ${threadId}`);
+      },
+      onBrowserClosed: (threadId) => {
+        this.logger?.debug?.(`Browser closed for thread ${threadId}`);
+        this.notifyBrowserClosed(threadId);
+      }
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // CDP URL Access
+  // ---------------------------------------------------------------------------
+  /**
+   * Get the CDP WebSocket URL for CLI tools to connect.
+   * For thread scope, returns the CDP URL for the specified thread.
+   * For shared scope, returns the single shared CDP URL.
+   *
+   * @param threadId - Thread identifier (optional, uses current thread if not specified)
+   * @returns CDP URL or null if browser not running for that thread
+   */
+  getCdpUrl(threadId) {
+    return this.threadManager.getCdpUrlForThread(threadId ?? this.getCurrentThread());
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle (implements MastraBrowser abstract methods)
+  // ---------------------------------------------------------------------------
+  async doLaunch() {
+    const scope = this.threadManager.getScope();
+    const cdpUrl = this.config.cdpUrl;
+    if (cdpUrl) {
+      const url = typeof cdpUrl === "function" ? await cdpUrl() : cdpUrl;
+      await this.connectToExisting(url);
+    } else if (scope === "shared") {
+      await this.threadManager.createSharedSession();
+    }
+  }
+  async doClose() {
+    await this.threadManager.closeAll();
+  }
+  /**
+   * Connect to an existing browser via CDP URL.
+   */
+  async connectToExisting(cdpUrl) {
+    this.logger?.debug?.(`Connecting to existing browser at ${cdpUrl}`);
+    await this.threadManager.createSharedSessionFromCdp(cdpUrl);
+    this.logger?.debug?.("Connected to existing browser");
+  }
+  /**
+   * Ensure browser is ready for the current thread.
+   * For thread scope, creates a new browser if needed.
+   */
+  async ensureReady() {
+    const scope = this.threadManager.getScope();
+    const threadId = this.getCurrentThread();
+    if (scope === "thread" && !this.threadManager.isBrowserRunning(threadId)) {
+      await this.threadManager.getManagerForThread(threadId);
+    }
+    await super.ensureReady();
+  }
+  /**
+   * Check if browser is running (for current thread in thread scope).
+   */
+  isBrowserRunning(threadId) {
+    return this.threadManager.isBrowserRunning(threadId ?? this.getCurrentThread());
+  }
+  /**
+   * Launch browser, optionally for a specific thread.
+   * For thread scope, creates a browser for that thread.
+   * For shared scope, launches the single shared browser.
+   */
+  async launch(threadId) {
+    const scope = this.threadManager.getScope();
+    const effectiveThreadId = threadId ?? this.getCurrentThread();
+    if (scope === "shared") {
+      if (!this.threadManager.isBrowserRunning()) {
+        await super.launch();
+      }
+    } else {
+      if (!this.threadManager.isBrowserRunning(effectiveThreadId)) {
+        await this.threadManager.getManagerForThread(effectiveThreadId);
+        this.status = "ready";
+      }
+    }
+  }
+  /**
+   * Handle browser disconnection.
+   * Overrides base class method.
+   */
+  handleBrowserDisconnected() {
+    super.handleBrowserDisconnected();
+  }
+  /**
+   * Connect to an external browser via CDP URL for screencast.
+   *
+   * Use this when an agent is using their own external CDP (e.g., browser-use cloud).
+   * Connects Playwright to the external browser to enable screencast without launching
+   * our own browser.
+   *
+   * @param cdpUrl - The external CDP WebSocket URL (wss://... or ws://...)
+   * @param threadId - Thread ID to associate the session with
+   */
+  async connectToExternalCdp(cdpUrl, threadId) {
+    const effectiveThreadId = threadId ?? this.getCurrentThread();
+    await this.threadManager.connectToExternalCdp(cdpUrl, effectiveThreadId);
+    this.status = "ready";
+  }
+  // ---------------------------------------------------------------------------
+  // Browser State (implements MastraBrowser abstract methods)
+  // ---------------------------------------------------------------------------
+  async getActivePage(threadId) {
+    return this.threadManager.getActivePageForThread(threadId ?? this.getCurrentThread());
+  }
+  getBrowserStateForThread(threadId) {
+    const context = this.threadManager.getContextForThread(threadId ?? this.getCurrentThread());
+    if (!context) {
+      return null;
+    }
+    const pages = context.pages();
+    const activeIndex = pages.length > 0 ? pages.length - 1 : 0;
+    const tabs = pages.map((page, index) => ({
+      url: page.url(),
+      title: "",
+      // Would need async call to get title
+      isActive: index === activeIndex
+    }));
+    return {
+      tabs,
+      activeTabIndex: activeIndex
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Screencast Support
+  // ---------------------------------------------------------------------------
+  async startScreencast(options) {
+    const threadId = options?.threadId ?? this.getCurrentThread();
+    const provider = {
+      getCdpSession: async () => {
+        const cdpSession = await this.threadManager.createFreshCdpSession(threadId);
+        if (!cdpSession) {
+          throw new Error("No browser context available for screencast");
+        }
+        return {
+          send: async (method, params) => {
+            return cdpSession.send(method, params);
+          },
+          on: (event, handler) => {
+            cdpSession.on(event, handler);
+          },
+          off: (event, handler) => {
+            cdpSession.off(event, handler);
+          }
+        };
+      },
+      isBrowserRunning: () => this.isBrowserRunning(threadId)
+    };
+    const stream = new import_browser2.ScreencastStreamImpl(provider, {
+      format: options?.format ?? "jpeg",
+      quality: options?.quality ?? 80,
+      maxWidth: options?.maxWidth ?? 1280,
+      maxHeight: options?.maxHeight ?? 720,
+      everyNthFrame: options?.everyNthFrame ?? 1
+    });
+    const context = this.threadManager.getContextForThread(threadId);
+    if (context) {
+      const pageListeners = /* @__PURE__ */ new Map();
+      const onNewPage = () => {
+        setTimeout(() => {
+          if (stream.isActive()) {
+            stream.reconnect().catch(() => {
+            });
+          }
+        }, 100);
+      };
+      const onPageCreated = (page) => {
+        setupPageListeners(page);
+      };
+      const setupPageListeners = (page) => {
+        page.once("close", () => {
+          pageListeners.delete(page);
+          setTimeout(() => {
+            if (stream.isActive() && context.pages().length > 0) {
+              stream.reconnect().catch(() => {
+              });
+            }
+          }, 100);
+        });
+        const onFrameNavigated = (frame) => {
+          if (!frame.parentFrame()) {
+            stream.emitUrl(frame.url());
+          }
+        };
+        page.on("framenavigated", onFrameNavigated);
+        pageListeners.set(page, onFrameNavigated);
+      };
+      context.on("page", onNewPage);
+      context.on("page", onPageCreated);
+      for (const page of context.pages()) {
+        setupPageListeners(page);
+      }
+      stream.once("stop", () => {
+        context.off("page", onNewPage);
+        context.off("page", onPageCreated);
+        for (const [page, listener] of pageListeners) {
+          page.off("framenavigated", listener);
+        }
+        pageListeners.clear();
+      });
+    }
+    await stream.start();
+    return stream;
+  }
+  // ---------------------------------------------------------------------------
+  // Input Injection
+  // ---------------------------------------------------------------------------
+  async injectMouseEvent(params, threadId) {
+    const cdpSession = await this.threadManager.getCdpSessionForThread(threadId ?? this.getCurrentThread());
+    if (!cdpSession) {
+      throw new Error("CDP session not available for mouse injection");
+    }
+    await cdpSession.send("Input.dispatchMouseEvent", params);
+  }
+  async injectKeyboardEvent(params, threadId) {
+    const cdpSession = await this.threadManager.getCdpSessionForThread(threadId ?? this.getCurrentThread());
+    if (!cdpSession) {
+      throw new Error("CDP session not available for keyboard injection");
+    }
+    await cdpSession.send("Input.dispatchKeyEvent", params);
+  }
+  // ---------------------------------------------------------------------------
+  // Tools (CLI agents don't use SDK tools - they use workspace commands)
+  // ---------------------------------------------------------------------------
+  getTools() {
+    return {};
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserViewer,
+  BrowserViewerThreadManager
+});
+//# sourceMappingURL=index.cjs.map