@jackwener/opencli 1.6.0 → 1.6.2

package/dist/browser/base-page.d.ts

@@ -11,6 +11,8 @@
 import type { BrowserCookie, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
 export declare abstract class BasePage implements IPage {
     protected _lastUrl: string | null;
+    /** Cached previous snapshot hashes for incremental diff marking */
+    private _prevSnapshotHashes;
     abstract goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
@@ -22,10 +24,10 @@ export declare abstract class BasePage implements IPage {
     }): Promise<BrowserCookie[]>;
     abstract screenshot(options?: ScreenshotOptions): Promise<string>;
     abstract tabs(): Promise<unknown[]>;
-    abstract closeTab(index?: number): Promise<void>;
-    abstract newTab(): Promise<void>;
     abstract selectTab(index: number): Promise<void>;
     click(ref: string): Promise<void>;
+    /** Override in subclasses with CDP native click support */
+    protected tryNativeClick(_x: number, _y: number): Promise<boolean>;
     typeText(ref: string, text: string): Promise<void>;
     pressKey(key: string): Promise<void>;
     scrollTo(ref: string): Promise<unknown>;

package/dist/browser/base-page.js

@@ -13,9 +13,28 @@ import { clickJs, typeTextJs, pressKeyJs, waitForTextJs, waitForCaptureJs, waitF
 import { formatSnapshot } from '../snapshotFormatter.js';
 export class BasePage {
     _lastUrl = null;
+    /** Cached previous snapshot hashes for incremental diff marking */
+    _prevSnapshotHashes = null;
     // ── Shared DOM helper implementations ──
     async click(ref) {
-        await this.evaluate(clickJs(ref));
+        const result = await this.evaluate(clickJs(ref));
+        // Backwards compat: old format returned 'clicked' string
+        if (typeof result === 'string' || result == null)
+            return;
+        // JS click succeeded
+        if (result.status === 'clicked')
+            return;
+        // JS click failed — try CDP native click if coordinates available
+        if (result.x != null && result.y != null) {
+            const success = await this.tryNativeClick(result.x, result.y);
+            if (success)
+                return;
+        }
+        throw new Error(`Click failed: ${result.error ?? 'JS click and CDP fallback both failed'}`);
+    }
+    /** Override in subclasses with CDP native click support */
+    async tryNativeClick(_x, _y) {
+        return false;
     }
     async typeText(ref, text) {
         await this.evaluate(typeTextJs(ref, text));
@@ -75,17 +94,31 @@ export class BasePage {
     }
     async snapshot(opts = {}) {
         const snapshotJs = generateSnapshotJs({
-            viewportExpand: opts.viewportExpand ?? 800,
+            viewportExpand: opts.viewportExpand ?? 2000,
             maxDepth: Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200)),
             interactiveOnly: opts.interactive ?? false,
             maxTextLength: opts.maxTextLength ?? 120,
             includeScrollInfo: true,
             bboxDedup: true,
+            previousHashes: this._prevSnapshotHashes,
         });
         try {
-            return await this.evaluate(snapshotJs);
+            const result = await this.evaluate(snapshotJs);
+            // Read back the hashes stored by the snapshot for next diff
+            try {
+                const hashes = await this.evaluate('window.__opencli_prev_hashes');
+                this._prevSnapshotHashes = typeof hashes === 'string' ? hashes : null;
+            }
+            catch {
+                // Non-fatal: diff is best-effort
+            }
+            return result;
         }
-        catch {
+        catch (err) {
+            // Log snapshot failure for debugging, then fallback to basic accessibility tree
+            if (process.env.DEBUG_SNAPSHOT) {
+                console.error('[snapshot] DOM snapshot failed, falling back to accessibility tree:', err?.message?.slice(0, 200));
+            }
             return this._basicSnapshot(opts);
         }
     }

package/dist/browser/bridge.js

@@ -6,7 +6,7 @@ import { fileURLToPath } from 'node:url';
 import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { Page } from './page.js';
-import { isDaemonRunning, isExtensionConnected } from './daemon-client.js';
+import { fetchDaemonStatus, isExtensionConnected } from './daemon-client.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 const DAEMON_SPAWN_TIMEOUT = 10000; // 10s to wait for daemon + extension
 /**
@@ -52,14 +52,16 @@ export class BrowserBridge {
     async _ensureDaemon(timeoutSeconds) {
         const effectiveSeconds = (timeoutSeconds && timeoutSeconds > 0) ? timeoutSeconds : Math.ceil(DAEMON_SPAWN_TIMEOUT / 1000);
         const timeoutMs = effectiveSeconds * 1000;
+        // Single status check instead of two separate fetchDaemonStatus() calls
+        const status = await fetchDaemonStatus();
         // Fast path: extension already connected
-        if (await isExtensionConnected())
+        if (status?.extensionConnected)
             return;
         // Daemon running but no extension — wait for extension with progress
-        if (await isDaemonRunning()) {
+        if (status !== null) {
             if (process.env.OPENCLI_VERBOSE || process.stderr.isTTY) {
-                process.stderr.write('⏳ Waiting for Chrome extension to connect...\n');
-                process.stderr.write('   Make sure Chrome is open and the OpenCLI extension is enabled.\n');
+                process.stderr.write('⏳ Waiting for Chrome/Chromium extension to connect...\n');
+                process.stderr.write('   Make sure Chrome or Chromium is open and the OpenCLI extension is enabled.\n');
             }
             const deadline = Date.now() + timeoutMs;
             while (Date.now() < deadline) {
@@ -68,7 +70,7 @@ export class BrowserBridge {
                     return;
             }
             throw new Error('Daemon is running but the Browser Extension is not connected.\n' +
-                'Please install and enable the opencli Browser Bridge extension in Chrome.');
+                'Please install and enable the opencli Browser Bridge extension in Chrome or Chromium.');
         }
         // No daemon — spawn one
         const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -96,9 +98,9 @@ export class BrowserBridge {
             if (await isExtensionConnected())
                 return;
         }
-        if (await isDaemonRunning()) {
+        if ((await fetchDaemonStatus()) !== null) {
             throw new Error('Daemon is running but the Browser Extension is not connected.\n' +
-                'Please install and enable the opencli Browser Bridge extension in Chrome.');
+                'Please install and enable the opencli Browser Bridge extension in Chrome or Chromium.');
         }
         throw new Error('Failed to start opencli daemon. Try running manually:\n' +
             `  node ${daemonPath}\n` +

package/dist/browser/cdp.js

@@ -189,12 +189,6 @@ class CDPPage extends BasePage {
     async tabs() {
         return [];
     }
-    async closeTab(_index) {
-        // Not supported in direct CDP mode
-    }
-    async newTab() {
-        await this.bridge.send('Target.createTarget', { url: 'about:blank' });
-    }
     async selectTab(_index) {
         // Not supported in direct CDP mode
     }
@@ -234,6 +228,8 @@ function scoreCDPTarget(target, preferredPattern) {
         return Number.NEGATIVE_INFINITY;
     if (haystack.includes('devtools'))
         return Number.NEGATIVE_INFINITY;
+    if (type === 'background_page' || type === 'service_worker')
+        return Number.NEGATIVE_INFINITY;
     let score = 0;
     if (preferredPattern && preferredPattern.test(haystack))
         score += 1000;

package/dist/browser/daemon-client.d.ts

@@ -6,7 +6,7 @@
 import type { BrowserSessionInfo } from '../types.js';
 export interface DaemonCommand {
     id: string;
-    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'cdp';
+    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'insert-text' | 'bind-current' | 'network-capture-start' | 'network-capture-read' | 'cdp';
     tabId?: number;
     code?: string;
     workspace?: string;
@@ -14,6 +14,8 @@ export interface DaemonCommand {
     op?: string;
     index?: number;
     domain?: string;
+    matchDomain?: string;
+    matchPathPrefix?: string;
     format?: 'png' | 'jpeg';
     quality?: number;
     fullPage?: boolean;
@@ -21,6 +23,10 @@ export interface DaemonCommand {
     files?: string[];
     /** CSS selector for file input element (set-file-input action) */
     selector?: string;
+    /** Raw text payload for insert-text action */
+    text?: string;
+    /** URL substring filter pattern for network capture */
+    pattern?: string;
     cdpMethod?: string;
     cdpParams?: Record<string, unknown>;
 }
@@ -62,3 +68,7 @@ export declare function isExtensionConnected(): Promise<boolean>;
  */
 export declare function sendCommand(action: DaemonCommand['action'], params?: Omit<DaemonCommand, 'id' | 'action'>): Promise<unknown>;
 export declare function listSessions(): Promise<BrowserSessionInfo[]>;
+export declare function bindCurrentTab(workspace: string, opts?: {
+    matchDomain?: string;
+    matchPathPrefix?: string;
+}): Promise<unknown>;

package/dist/browser/daemon-client.js

@@ -108,3 +108,6 @@ export async function listSessions() {
     const result = await sendCommand('sessions');
     return Array.isArray(result) ? result : [];
 }
+export async function bindCurrentTab(workspace, opts = {}) {
+    return sendCommand('bind-current', { workspace, ...opts });
+}

package/dist/browser/dom-helpers.d.ts

@@ -4,9 +4,11 @@
  * Used by both Page (daemon mode) and CDPPage (direct CDP mode)
  * to eliminate code duplication for click, type, press, wait, scroll, etc.
  */
-/** Generate JS to click an element by ref */
+/** Generate JS to click an element by ref.
+ *  Returns { status, x, y, w, h } for CDP fallback when JS click fails. */
 export declare function clickJs(ref: string): string;
-/** Generate JS to type text into an element by ref */
+/** Generate JS to type text into an element by ref.
+ *  Uses native setter for React compat + execCommand for contenteditable. */
 export declare function typeTextJs(ref: string, text: string): string;
 /** Generate JS to press a keyboard key */
 export declare function pressKeyJs(key: string): string;

package/dist/browser/dom-helpers.js

@@ -4,63 +4,74 @@
  * Used by both Page (daemon mode) and CDPPage (direct CDP mode)
  * to eliminate code duplication for click, type, press, wait, scroll, etc.
  */
-/** Generate JS to click an element by ref */
-export function clickJs(ref) {
-    const safeRef = JSON.stringify(ref);
+/** Shared element lookup JS fragment (4-strategy resolution) */
+function resolveElementJs(safeRef, selectorSet) {
     return `
-    (() => {
       const ref = ${safeRef};
-      // 1. data-opencli-ref (set by snapshot engine)
       let el = document.querySelector('[data-opencli-ref="' + ref + '"]');
-      // 2. data-ref (legacy)
       if (!el) el = document.querySelector('[data-ref="' + ref + '"]');
-      // 3. CSS selector
       if (!el && ref.match(/^[a-zA-Z#.\\[]/)) {
         try { el = document.querySelector(ref); } catch {}
       }
-      // 4. Numeric index into interactive elements
       if (!el) {
         const idx = parseInt(ref, 10);
         if (!isNaN(idx)) {
-          el = document.querySelectorAll('a, button, input, select, textarea, [role="button"], [tabindex]:not([tabindex="-1"])')[idx];
+          el = document.querySelectorAll('${selectorSet}')[idx];
         }
-      }
+      }`;
+}
+/** Generate JS to click an element by ref.
+ *  Returns { status, x, y, w, h } for CDP fallback when JS click fails. */
+export function clickJs(ref) {
+    const safeRef = JSON.stringify(ref);
+    return `
+    (() => {
+      ${resolveElementJs(safeRef, 'a, button, input, select, textarea, [role="button"], [tabindex]:not([tabindex="-1"])')}
       if (!el) throw new Error('Element not found: ' + ref);
       el.scrollIntoView({ behavior: 'instant', block: 'center' });
-      el.click();
-      return 'clicked';
+      const rect = el.getBoundingClientRect();
+      const x = Math.round(rect.left + rect.width / 2);
+      const y = Math.round(rect.top + rect.height / 2);
+      try {
+        el.click();
+        return { status: 'clicked', x, y, w: Math.round(rect.width), h: Math.round(rect.height) };
+      } catch (e) {
+        return { status: 'js_failed', x, y, w: Math.round(rect.width), h: Math.round(rect.height), error: e.message };
+      }
     })()
   `;
 }
-/** Generate JS to type text into an element by ref */
+/** Generate JS to type text into an element by ref.
+ *  Uses native setter for React compat + execCommand for contenteditable. */
 export function typeTextJs(ref, text) {
     const safeRef = JSON.stringify(ref);
     const safeText = JSON.stringify(text);
     return `
     (() => {
-      const ref = ${safeRef};
-      // 1. data-opencli-ref (set by snapshot engine)
-      let el = document.querySelector('[data-opencli-ref="' + ref + '"]');
-      // 2. data-ref (legacy)
-      if (!el) el = document.querySelector('[data-ref="' + ref + '"]');
-      // 3. CSS selector
-      if (!el && ref.match(/^[a-zA-Z#.\\[]/)) {
-        try { el = document.querySelector(ref); } catch {}
-      }
-      // 4. Numeric index into typeable elements
-      if (!el) {
-        const idx = parseInt(ref, 10);
-        if (!isNaN(idx)) {
-          el = document.querySelectorAll('input, textarea, [contenteditable="true"]')[idx];
-        }
-      }
+      ${resolveElementJs(safeRef, 'input, textarea, [contenteditable="true"]')}
       if (!el) throw new Error('Element not found: ' + ref);
       el.focus();
       if (el.isContentEditable) {
-        el.textContent = ${safeText};
+        // Select all content + delete, then insert (supports undo, works with rich text editors)
+        const sel = window.getSelection();
+        const range = document.createRange();
+        range.selectNodeContents(el);
+        sel.removeAllRanges();
+        sel.addRange(range);
+        document.execCommand('delete', false);
+        document.execCommand('insertText', false, ${safeText});
         el.dispatchEvent(new Event('input', { bubbles: true }));
       } else {
-        el.value = ${safeText};
+        // Use native setter for React/framework compatibility (match element type)
+        const proto = el instanceof HTMLTextAreaElement
+          ? HTMLTextAreaElement.prototype
+          : HTMLInputElement.prototype;
+        const nativeSetter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
+        if (nativeSetter) {
+          nativeSetter.call(el, ${safeText});
+        } else {
+          el.value = ${safeText};
+        }
         el.dispatchEvent(new Event('input', { bubbles: true }));
         el.dispatchEvent(new Event('change', { bubbles: true }));
       }

package/dist/browser/dom-snapshot.js

@@ -336,6 +336,8 @@ export function generateSnapshotJs(opts = {}) {
     if (role && INTERACTIVE_ROLES.has(role)) return true;
     if (el.hasAttribute('onclick') || el.hasAttribute('onmousedown') || el.hasAttribute('ontouchstart')) return true;
     if (el.hasAttribute('tabindex') && el.getAttribute('tabindex') !== '-1') return true;
+    // Framework event listener detection (React/Vue/Angular onClick)
+    if (hasFrameworkListener(el)) return true;
     try { if (window.getComputedStyle(el).cursor === 'pointer') return true; } catch {}
     if (el.isContentEditable && el.getAttribute('contenteditable') !== 'false') return true;
     // Search element heuristic detection
@@ -343,9 +345,29 @@ export function generateSnapshotJs(opts = {}) {
     return false;
   }
 
+  function hasFrameworkListener(el) {
+    try {
+      // React: __reactProps$xxx / __reactEvents$xxx with onClick/onMouseDown
+      for (const key of Object.keys(el)) {
+        if (key.startsWith('__reactProps$') || key.startsWith('__reactEvents$')) {
+          const props = el[key];
+          if (props && (props.onClick || props.onMouseDown || props.onPointerDown)) return true;
+        }
+      }
+      // Vue 3: _vei (Vue Event Invoker) with onClick
+      if (el._vei && (el._vei.onClick || el._vei.click || el._vei.onMousedown)) return true;
+      // Vue 2: __vue__ instance with $listeners
+      if (el.__vue__?.$listeners?.click) return true;
+      // Angular: ng-reflect-click binding
+      if (el.hasAttribute('ng-reflect-click')) return true;
+    } catch { /* ignore errors from cross-origin or frozen objects */ }
+    return false;
+  }
+
   function isSearchElement(el) {
     // Check class names for search indicators
-    const className = el.className?.toLowerCase() || '';
+    // Note: SVG elements have className as SVGAnimatedString (not a string), use baseVal
+    const className = (typeof el.className === 'string' ? el.className : el.className?.baseVal || '').toLowerCase();
     const classes = className.split(/\\s+/).filter(Boolean);
     for (const cls of classes) {
       const cleaned = cls.replace(/[^a-z0-9-]/g, '');

package/dist/browser/page.d.ts

@@ -37,20 +37,25 @@ export declare class Page extends BasePage {
     /** Close the automation window in the extension */
     closeWindow(): Promise<void>;
     tabs(): Promise<unknown[]>;
-    closeTab(index?: number): Promise<void>;
-    newTab(): Promise<void>;
     selectTab(index: number): Promise<void>;
     /**
      * Capture a screenshot via CDP Page.captureScreenshot.
      */
     screenshot(options?: ScreenshotOptions): Promise<string>;
+    startNetworkCapture(pattern?: string): Promise<void>;
+    readNetworkCapture(): Promise<unknown[]>;
     /**
      * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
      * Chrome reads the files directly from the local filesystem, avoiding the
      * payload size limits of base64-in-evaluate.
      */
     setFileInput(files: string[], selector?: string): Promise<void>;
+    insertText(text: string): Promise<void>;
     cdp(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    /** CDP native click fallback — called when JS el.click() fails */
+    protected tryNativeClick(x: number, y: number): Promise<boolean>;
+    /** Precise click using DOM.getContentQuads/getBoxModel for inline elements */
+    clickWithQuads(ref: string): Promise<void>;
     nativeClick(x: number, y: number): Promise<void>;
     nativeType(text: string): Promise<void>;
     nativeKeyPress(key: string, modifiers?: string[]): Promise<void>;

package/dist/browser/page.js

@@ -52,26 +52,17 @@ export class Page extends BasePage {
             this._tabId = result.tabId;
         }
         this._lastUrl = url;
-        // Inject stealth anti-detection patches (guard flag prevents double-injection).
-        try {
-            await sendCommand('exec', {
-                code: generateStealthJs(),
-                ...this._cmdOpts(),
-            });
-        }
-        catch {
-            // Non-fatal: stealth is best-effort
-        }
-        // Smart settle: use DOM stability detection instead of fixed sleep.
-        // settleMs is now a timeout cap (default 1000ms), not a fixed wait.
+        // Inject stealth + settle in a single round-trip instead of two sequential exec calls.
+        // The stealth guard flag prevents double-injection; settle uses DOM stability detection.
         if (options?.waitUntil !== 'none') {
             const maxMs = options?.settleMs ?? 1000;
-            const settleOpts = {
-                code: waitForDomStableJs(maxMs, Math.min(500, maxMs)),
+            const combinedCode = `${generateStealthJs()};\n${waitForDomStableJs(maxMs, Math.min(500, maxMs))}`;
+            const combinedOpts = {
+                code: combinedCode,
                 ...this._cmdOpts(),
             };
             try {
-                await sendCommand('exec', settleOpts);
+                await sendCommand('exec', combinedOpts);
             }
             catch (err) {
                 if (!isRetryableSettleError(err))
@@ -81,17 +72,26 @@ export class Page extends BasePage {
                 // to load, then retry the settle probe once.
                 try {
                     await new Promise((r) => setTimeout(r, 200));
-                    await sendCommand('exec', settleOpts);
+                    await sendCommand('exec', combinedOpts);
                 }
                 catch (retryErr) {
                     if (!isRetryableSettleError(retryErr))
                         throw retryErr;
-                    // Retry also failed — give up silently. Settle is best-effort
-                    // after successful navigation; the next real command will surface
-                    // any persistent target error immediately.
                 }
             }
         }
+        else {
+            // Even with waitUntil='none', still inject stealth (best-effort)
+            try {
+                await sendCommand('exec', {
+                    code: generateStealthJs(),
+                    ...this._cmdOpts(),
+                });
+            }
+            catch {
+                // Non-fatal: stealth is best-effort
+            }
+        }
     }
     getActiveTabId() {
         return this._tabId;
@@ -120,22 +120,15 @@ export class Page extends BasePage {
         catch {
             // Window may already be closed or daemon may be down
         }
+        finally {
+            this._tabId = undefined;
+            this._lastUrl = null;
+        }
     }
     async tabs() {
         const result = await sendCommand('tabs', { op: 'list', ...this._wsOpt() });
         return Array.isArray(result) ? result : [];
     }
-    async closeTab(index) {
-        await sendCommand('tabs', { op: 'close', ...this._wsOpt(), ...(index !== undefined ? { index } : {}) });
-        // Invalidate cached tabId — the closed tab might have been our active one.
-        // We can't know for sure (close-by-index doesn't return tabId), so reset.
-        this._tabId = undefined;
-    }
-    async newTab() {
-        const result = await sendCommand('tabs', { op: 'new', ...this._wsOpt() });
-        if (result?.tabId)
-            this._tabId = result.tabId;
-    }
     async selectTab(index) {
         const result = await sendCommand('tabs', { op: 'select', index, ...this._wsOpt() });
         if (result?.selected)
@@ -156,6 +149,18 @@ export class Page extends BasePage {
         }
         return base64;
     }
+    async startNetworkCapture(pattern = '') {
+        await sendCommand('network-capture-start', {
+            pattern,
+            ...this._cmdOpts(),
+        });
+    }
+    async readNetworkCapture() {
+        const result = await sendCommand('network-capture-read', {
+            ...this._cmdOpts(),
+        });
+        return Array.isArray(result) ? result : [];
+    }
     /**
      * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
      * Chrome reads the files directly from the local filesystem, avoiding the
@@ -171,6 +176,15 @@ export class Page extends BasePage {
             throw new Error('setFileInput returned no count — command may not be supported by the extension');
         }
     }
+    async insertText(text) {
+        const result = await sendCommand('insert-text', {
+            text,
+            ...this._cmdOpts(),
+        });
+        if (!result?.inserted) {
+            throw new Error('insertText returned no inserted flag — command may not be supported by the extension');
+        }
+    }
     async cdp(method, params = {}) {
         return sendCommand('cdp', {
             cdpMethod: method,
@@ -178,6 +192,74 @@ export class Page extends BasePage {
             ...this._cmdOpts(),
         });
     }
+    /** CDP native click fallback — called when JS el.click() fails */
+    async tryNativeClick(x, y) {
+        try {
+            await this.nativeClick(x, y);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Precise click using DOM.getContentQuads/getBoxModel for inline elements */
+    async clickWithQuads(ref) {
+        const safeRef = JSON.stringify(ref);
+        const cssSelector = `[data-opencli-ref="${ref.replace(/"/g, '\\"')}"]`;
+        // Scroll element into view first
+        await this.evaluate(`
+      (() => {
+        const el = document.querySelector('[data-opencli-ref="' + ${safeRef} + '"]');
+        if (el) el.scrollIntoView({ behavior: 'instant', block: 'center' });
+        return !!el;
+      })()
+    `);
+        try {
+            // Find DOM node via CDP
+            const doc = await this.cdp('DOM.getDocument', {});
+            const result = await this.cdp('DOM.querySelectorAll', {
+                nodeId: doc.root.nodeId,
+                selector: cssSelector,
+            });
+            if (!result.nodeIds?.length)
+                throw new Error('DOM node not found');
+            const nodeId = result.nodeIds[0];
+            // Try getContentQuads first (precise for inline elements)
+            try {
+                const quads = await this.cdp('DOM.getContentQuads', { nodeId });
+                if (quads.quads?.length) {
+                    const q = quads.quads[0];
+                    const cx = (q[0] + q[2] + q[4] + q[6]) / 4;
+                    const cy = (q[1] + q[3] + q[5] + q[7]) / 4;
+                    await this.nativeClick(Math.round(cx), Math.round(cy));
+                    return;
+                }
+            }
+            catch { /* fallthrough */ }
+            // Try getBoxModel
+            try {
+                const box = await this.cdp('DOM.getBoxModel', { nodeId });
+                if (box.model?.content) {
+                    const c = box.model.content;
+                    const cx = (c[0] + c[2] + c[4] + c[6]) / 4;
+                    const cy = (c[1] + c[3] + c[5] + c[7]) / 4;
+                    await this.nativeClick(Math.round(cx), Math.round(cy));
+                    return;
+                }
+            }
+            catch { /* fallthrough */ }
+        }
+        catch { /* fallthrough */ }
+        // Final fallback: regular click
+        await this.evaluate(`
+      (() => {
+        const el = document.querySelector('[data-opencli-ref="' + ${safeRef} + '"]');
+        if (!el) throw new Error('Element not found: ' + ${safeRef});
+        el.click();
+        return 'clicked';
+      })()
+    `);
+    }
     async nativeClick(x, y) {
         await this.cdp('Input.dispatchMouseEvent', {
             type: 'mousePressed',

package/dist/browser.test.js

@@ -106,7 +106,7 @@ describe('BrowserBridge state', () => {
     });
     it('fails fast when daemon is running but extension is disconnected', async () => {
         vi.spyOn(daemonClient, 'isExtensionConnected').mockResolvedValue(false);
-        vi.spyOn(daemonClient, 'isDaemonRunning').mockResolvedValue(true);
+        vi.spyOn(daemonClient, 'fetchDaemonStatus').mockResolvedValue({ extensionConnected: false });
         const bridge = new BrowserBridge();
         await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Extension is not connected');
     });

package/dist/build-manifest.d.ts

@@ -21,6 +21,7 @@ export interface ManifestEntry {
         type?: string;
         default?: unknown;
         required?: boolean;
+        valueRequired?: boolean;
         positional?: boolean;
         help?: string;
         choices?: string[];

package/dist/build-manifest.js

@@ -26,6 +26,7 @@ function toManifestArgs(args) {
         type: arg.type ?? 'str',
         default: arg.default,
         required: !!arg.required,
+        valueRequired: !!arg.valueRequired || undefined,
         positional: arg.positional || undefined,
         help: arg.help ?? '',
         choices: arg.choices,