address comments

Co-authored-by: ctate <chris@ctate.dev>

cli/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "agent-browser"
-version = "0.5.0"
+version = "0.4.4"
 dependencies = [
  "libc",
  "serde",

cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "agent-browser"
-version = "0.5.0"
+version = "0.4.4"
 edition = "2021"
 description = "Fast browser automation CLI for AI agents"
 license = "Apache-2.0"

cli/src/commands.rs

@@ -901,7 +901,6 @@ mod tests {
             debug: false,
             headers: None,
             executable_path: None,
-            extensions: Vec::new(),
             cdp: None,
         }
     }

cli/src/connection.rs

@@ -159,16 +159,9 @@ pub struct DaemonResult {
     pub already_running: bool,
 }
 
-pub fn ensure_daemon(
+pub fn ensure_daemon(session: &str, headed: bool, executable_path: Option<&str>) -> Result<DaemonResult, String> {
-    session: &str,
-    headed: bool,
-    executable_path: Option<&str>,
-    extensions: &[String],
-) -> Result<DaemonResult, String> {
     if is_daemon_running(session) && daemon_ready(session) {
-        return Ok(DaemonResult {
+        return Ok(DaemonResult { already_running: true });
-            already_running: true,
-        });
     }
 
     let exe_path = env::current_exe().map_err(|e| e.to_string())?;
@@ -203,10 +196,6 @@ pub fn ensure_daemon(
             cmd.env("AGENT_BROWSER_EXECUTABLE_PATH", path);
         }
 
-        if !extensions.is_empty() {
-            cmd.env("AGENT_BROWSER_EXTENSIONS", extensions.join(","));
-        }
-
         // Create new process group and session to fully detach
         unsafe {
             cmd.pre_exec(|| {
@@ -245,10 +234,6 @@ pub fn ensure_daemon(
             cmd.env("AGENT_BROWSER_EXECUTABLE_PATH", path);
         }
 
-        if !extensions.is_empty() {
-            cmd.env("AGENT_BROWSER_EXTENSIONS", extensions.join(","));
-        }
-
         // CREATE_NEW_PROCESS_GROUP | DETACHED_PROCESS
         const CREATE_NEW_PROCESS_GROUP: u32 = 0x00000200;
         const DETACHED_PROCESS: u32 = 0x00000008;

cli/src/flags.rs

@@ -9,15 +9,9 @@ pub struct Flags {
     pub headers: Option<String>,
     pub executable_path: Option<String>,
     pub cdp: Option<String>,
-    pub extensions: Vec<String>,
 }
 
 pub fn parse_flags(args: &[String]) -> Flags {
-    let extensions_env = env::var("AGENT_BROWSER_EXTENSIONS")
-        .ok()
-        .map(|s| s.split(',').map(|p| p.trim().to_string()).filter(|p| !p.is_empty()).collect::<Vec<_>>())
-        .unwrap_or_default();
-
     let mut flags = Flags {
         json: false,
         full: false,
@@ -27,7 +21,6 @@ pub fn parse_flags(args: &[String]) -> Flags {
         headers: None,
         executable_path: env::var("AGENT_BROWSER_EXECUTABLE_PATH").ok(),
         cdp: None,
-        extensions: extensions_env,
     };
 
     let mut i = 0;
@@ -54,13 +47,7 @@ pub fn parse_flags(args: &[String]) -> Flags {
                     flags.executable_path = Some(s.clone());
                     i += 1;
                 }
-            },
+            }
-            "--extension" => {
-                if let Some(s) = args.get(i + 1) {
-                    flags.extensions.push(s.clone());
-                    i += 1;
-                }
-            },
             "--cdp" => {
                 if let Some(s) = args.get(i + 1) {
                     flags.cdp = Some(s.clone());
@@ -81,7 +68,7 @@ pub fn clean_args(args: &[String]) -> Vec<String> {
     // Global flags that should be stripped from command args
     const GLOBAL_FLAGS: &[&str] = &["--json", "--full", "--headed", "--debug"];
     // Global flags that take a value (need to skip the next arg too)
-    const GLOBAL_FLAGS_WITH_VALUE: &[&str] = &["--session", "--headers", "--executable-path", "--cdp", "--extension"];
+    const GLOBAL_FLAGS_WITH_VALUE: &[&str] = &["--session", "--headers", "--executable-path", "--cdp"];
 
     for arg in args.iter() {
         if skip_next {

cli/src/main.rs

@@ -149,7 +149,7 @@ fn main() {
         }
     };
 
-    let daemon_result = match ensure_daemon(&flags.session, flags.headed, flags.executable_path.as_deref(), &flags.extensions) {
+    let daemon_result = match ensure_daemon(&flags.session, flags.headed, flags.executable_path.as_deref()) {
         Ok(result) => result,
         Err(e) => {
             if flags.json {
@@ -162,14 +162,9 @@ fn main() {
     };
 
     // Warn if executable_path was specified but daemon was already running
-    if daemon_result.already_running && (flags.executable_path.is_some() || !flags.extensions.is_empty()) {
+    if daemon_result.already_running && flags.executable_path.is_some() {
         if !flags.json {
-            if flags.executable_path.is_some() {
+            eprintln!("\x1b[33m⚠\x1b[0m --executable-path ignored: daemon already running. Use 'agent-browser close' first to restart with new path.");
-                eprintln!("\x1b[33m⚠\x1b[0m --executable-path ignored: daemon already running. Use 'agent-browser close' first to restart with new path.");
-            }
-            if !flags.extensions.is_empty() {
-                eprintln!("\x1b[33m⚠\x1b[0m --extension ignored: daemon already running. Use 'agent-browser close' first to restart with extensions.");
-            }
         }
     }
 

cli/src/output.rs

@@ -1191,7 +1191,6 @@ Options:
   --session <name>           Isolated session (or AGENT_BROWSER_SESSION env)
   --headers <json>           HTTP headers scoped to URL's origin (for auth)
   --executable-path <path>   Custom browser executable (or AGENT_BROWSER_EXECUTABLE_PATH)
-  --extension <path>         Load browser extensions (repeatable).
   --json                     JSON output
   --full, -f                 Full page screenshot
   --headed                   Show browser window (not headless)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-browser",
-  "version": "0.5.0",
+  "version": "0.4.4",
   "description": "Headless browser automation CLI for AI agents",
   "type": "module",
   "main": "dist/daemon.js",

src/actions.test.ts

@@ -1,39 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { toAIFriendlyError } from './actions.js';
-
-describe('toAIFriendlyError', () => {
-  describe('element blocked by overlay', () => {
-    it('should detect intercepts pointer events even when Timeout is in message', () => {
-      // This is the exact error from Playwright when a cookie banner blocks an element
-      // Bug: Previously this was incorrectly reported as "not found or not visible"
-      const error = new Error(
-        'TimeoutError: locator.click: Timeout 10000ms exceeded.\n' +
-          'Call log:\n' +
-          "  - waiting for getByRole('link', { name: 'Anmelden', exact: true }).first()\n" +
-          '    - locator resolved to <a href="https://example.com/login">Anmelden</a>\n' +
-          '  - attempting click action\n' +
-          '    2 x waiting for element to be visible, enabled and stable\n' +
-          '      - element is visible, enabled and stable\n' +
-          '      - scrolling into view if needed\n' +
-          '      - done scrolling\n' +
-          '      - <body class="font-sans antialiased">...</body> intercepts pointer events\n' +
-          '    - retrying click action'
-      );
-
-      const result = toAIFriendlyError(error, '@e4');
-
-      // Must NOT say "not found" - the element WAS found
-      expect(result.message).not.toContain('not found');
-      // Must indicate the element is blocked
-      expect(result.message).toContain('blocked by another element');
-      expect(result.message).toContain('modal or overlay');
-    });
-
-    it('should suggest dismissing cookie banners', () => {
-      const error = new Error('<div class="cookie-overlay"> intercepts pointer events');
-      const result = toAIFriendlyError(error, '@e1');
-
-      expect(result.message).toContain('cookie banners');
-    });
-  });
-});

src/actions.ts

@@ -134,9 +134,8 @@ interface SnapshotData {
 
 /**
  * Convert Playwright errors to AI-friendly messages
- * @internal Exported for testing
  */
-export function toAIFriendlyError(error: unknown, selector: string): Error {
+function toAIFriendlyError(error: unknown, selector: string): Error {
   const message = error instanceof Error ? error.message : String(error);
 
   // Handle strict mode violation (multiple elements match)
@@ -151,24 +150,7 @@ export function toAIFriendlyError(error: unknown, selector: string): Error {
     );
   }
 
-  // Handle element not interactable (must be checked BEFORE timeout case)
+  // Handle element not found
-  // This includes cases where an overlay/modal blocks the element
-  if (message.includes('intercepts pointer events')) {
-    return new Error(
-      `Element "${selector}" is blocked by another element (likely a modal or overlay). ` +
-        `Try dismissing any modals/cookie banners first.`
-    );
-  }
-
-  // Handle element not visible
-  if (message.includes('not visible') && !message.includes('Timeout')) {
-    return new Error(
-      `Element "${selector}" is not visible. ` +
-        `Try scrolling it into view or check if it's hidden.`
-    );
-  }
-
-  // Handle element not found (timeout waiting for element)
   if (
     message.includes('waiting for') &&
     (message.includes('to be visible') || message.includes('Timeout'))
@@ -179,6 +161,14 @@ export function toAIFriendlyError(error: unknown, selector: string): Error {
     );
   }
 
+  // Handle element not interactable
+  if (message.includes('intercepts pointer events') || message.includes('not visible')) {
+    return new Error(
+      `Element "${selector}" is not interactable (may be hidden or covered). ` +
+        `Try scrolling it into view or check if a modal/overlay is blocking it.`
+    );
+  }
+
   // Return original error for unknown cases
   return error instanceof Error ? error : new Error(message);
 }

src/browser.ts

@@ -13,8 +13,6 @@ import {
   type Locator,
   type CDPSession,
 } from 'playwright-core';
-import path from 'node:path';
-import os from 'node:os';
 import type { LaunchCommand } from './types.js';
 import { type RefMap, type EnhancedSnapshot, getEnhancedSnapshot, parseRef } from './snapshot.js';
 
@@ -67,7 +65,6 @@ interface PageError {
 export class BrowserManager {
   private browser: Browser | null = null;
   private cdpPort: number | null = null;
-  private isPersistentContext: boolean = false;
   private contexts: BrowserContext[] = [];
   private pages: Page[] = [];
   private activePageIndex: number = 0;
@@ -93,7 +90,7 @@ export class BrowserManager {
    * Check if browser is launched
    */
   isLaunched(): boolean {
-    return this.browser !== null || this.isPersistentContext;
+    return this.browser !== null;
   }
 
   /**
@@ -640,16 +637,12 @@ export class BrowserManager {
    */
   async launch(options: LaunchCommand): Promise<void> {
     const cdpPort = options.cdpPort;
-    const hasExtensions = !!options.extensions?.length;
 
-    if (hasExtensions && cdpPort) {
+    if (this.browser) {
-      throw new Error('Extensions cannot be used with CDP connection');
+      const switchingFromCdpToBrowser = !cdpPort && this.cdpPort !== null;
-    }
+      const needsCdpReconnect = !!cdpPort && this.needsCdpReconnect(cdpPort);
 
-    if (this.isLaunched()) {
+      if (switchingFromCdpToBrowser || needsCdpReconnect) {
-      const needsRelaunch =
-        (!cdpPort && this.cdpPort !== null) || (!!cdpPort && this.needsCdpReconnect(cdpPort));
-      if (needsRelaunch) {
         await this.close();
       } else {
         return;
@@ -661,45 +654,35 @@ export class BrowserManager {
       return;
     }
 
+    // Select browser type
     const browserType = options.browser ?? 'chromium';
-    if (hasExtensions && browserType !== 'chromium') {
-      throw new Error('Extensions are only supported in Chromium');
-    }
-
     const launcher =
       browserType === 'firefox' ? firefox : browserType === 'webkit' ? webkit : chromium;
-    const viewport = options.viewport ?? { width: 1280, height: 720 };
 
-    let context: BrowserContext;
+    // Launch browser
-    if (hasExtensions) {
+    this.browser = await launcher.launch({
-      const extPaths = options.extensions!.join(',');
+      headless: options.headless ?? true,
-      const session = process.env.AGENT_BROWSER_SESSION || 'default';
+      executablePath: options.executablePath,
-      context = await launcher.launchPersistentContext(
+    });
-        path.join(os.tmpdir(), `agent-browser-ext-${session}`),
+    this.cdpPort = null;
-        {
-          headless: false,
-          executablePath: options.executablePath,
-          args: [`--disable-extensions-except=${extPaths}`, `--load-extension=${extPaths}`],
-          viewport,
-          extraHTTPHeaders: options.headers,
-        }
-      );
-      this.isPersistentContext = true;
-    } else {
-      this.browser = await launcher.launch({
-        headless: options.headless ?? true,
-        executablePath: options.executablePath,
-      });
-      this.cdpPort = null;
-      context = await this.browser.newContext({ viewport, extraHTTPHeaders: options.headers });
-    }
 
+    // Create context with viewport and optional headers
+    const context = await this.browser.newContext({
+      viewport: options.viewport ?? { width: 1280, height: 720 },
+      extraHTTPHeaders: options.headers,
+    });
+
+    // Set default timeout to 10 seconds (Playwright default is 30s)
     context.setDefaultTimeout(10000);
+
     this.contexts.push(context);
 
-    const page = context.pages()[0] ?? (await context.newPage());
+    // Create initial page
+    const page = await context.newPage();
     this.pages.push(page);
     this.activePageIndex = 0;
+
+    // Automatically start console and error tracking
     this.setupPageTracking(page);
   }
 
@@ -1141,7 +1124,6 @@ export class BrowserManager {
     this.pages = [];
     this.contexts = [];
     this.cdpPort = null;
-    this.isPersistentContext = false;
     this.activePageIndex = 0;
     this.refMap = {};
     this.lastSnapshot = '';

src/daemon.ts

@@ -192,17 +192,11 @@ export async function startDaemon(options?: { streamPort?: number }): Promise<vo
             parseResult.command.action !== 'launch' &&
             parseResult.command.action !== 'close'
           ) {
-            const extensions = process.env.AGENT_BROWSER_EXTENSIONS
-              ? process.env.AGENT_BROWSER_EXTENSIONS.split(',')
-                  .map((p) => p.trim())
-                  .filter(Boolean)
-              : undefined;
             await browser.launch({
               id: 'auto',
               action: 'launch',
               headless: true,
               executablePath: process.env.AGENT_BROWSER_EXECUTABLE_PATH,
-              extensions: extensions,
             });
           }
 

src/types.ts

@@ -15,7 +15,6 @@ export interface LaunchCommand extends BaseCommand {
   headers?: Record<string, string>;
   executablePath?: string;
   cdpPort?: number;
-  extensions?: string[];
 }
 
 export interface NavigateCommand extends BaseCommand {