@jackwener/opencli 1.5.8 → 1.6.0

package/dist/browser/page.js

@@ -9,13 +9,12 @@
  * where resolveTabId() in the extension picks a chrome:// or
  * chrome-extension:// tab that can't be debugged.
  */
-import { formatSnapshot } from '../snapshotFormatter.js';
 import { sendCommand } from './daemon-client.js';
 import { wrapForEval } from './utils.js';
 import { saveBase64ToFile } from '../utils.js';
-import { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 import { generateStealthJs } from './stealth.js';
-import { clickJs, typeTextJs, pressKeyJs, waitForTextJs, waitForCaptureJs, waitForSelectorJs, scrollJs, autoScrollJs, networkRequestsJs, waitForDomStableJs, } from './dom-helpers.js';
+import { waitForDomStableJs } from './dom-helpers.js';
+import { BasePage } from './base-page.js';
 export function isRetryableSettleError(err) {
     const message = err instanceof Error ? err.message : String(err);
     return message.includes('Inspected target navigated or closed')
@@ -24,15 +23,14 @@ export function isRetryableSettleError(err) {
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
  */
-export class Page {
+export class Page extends BasePage {
     workspace;
     constructor(workspace = 'default') {
+        super();
         this.workspace = workspace;
     }
     /** Active tab ID, set after navigate and used in all subsequent commands */
     _tabId;
-    /** Last navigated URL, tracked in-memory to avoid extra round-trips */
-    _lastUrl = null;
     /** Helper: spread workspace into command params */
     _wsOpt() {
         return { workspace: this.workspace };
@@ -95,29 +93,8 @@ export class Page {
             }
         }
     }
-    async getCurrentUrl() {
-        if (this._lastUrl)
-            return this._lastUrl;
-        try {
-            const current = await this.evaluate('window.location.href');
-            if (typeof current === 'string' && current) {
-                this._lastUrl = current;
-                return current;
-            }
-        }
-        catch {
-            // Best-effort: some commands may run before a debuggable tab is ready.
-        }
-        return null;
-    }
-    /** Close the automation window in the extension */
-    async closeWindow() {
-        try {
-            await sendCommand('close-window', { ...this._wsOpt() });
-        }
-        catch {
-            // Window may already be closed or daemon may be down
-        }
+    getActiveTabId() {
+        return this._tabId;
     }
     async evaluate(js) {
         const code = wrapForEval(js);
@@ -135,120 +112,13 @@ export class Page {
         const result = await sendCommand('cookies', { ...this._wsOpt(), ...opts });
         return Array.isArray(result) ? result : [];
     }
-    async snapshot(opts = {}) {
-        // Primary: use the advanced DOM snapshot engine with multi-layer pruning
-        const snapshotJs = generateSnapshotJs({
-            viewportExpand: opts.viewportExpand ?? 800,
-            maxDepth: Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200)),
-            interactiveOnly: opts.interactive ?? false,
-            maxTextLength: opts.maxTextLength ?? 120,
-            includeScrollInfo: true,
-            bboxDedup: true,
-        });
+    /** Close the automation window in the extension */
+    async closeWindow() {
         try {
-            const result = await sendCommand('exec', { code: snapshotJs, ...this._cmdOpts() });
-            // The advanced engine already produces a clean, pruned, LLM-friendly output.
-            // Do NOT pass through formatSnapshot — its format is incompatible.
-            return result;
+            await sendCommand('close-window', { ...this._wsOpt() });
         }
         catch {
-            // Fallback: basic DOM snapshot (original implementation)
-            return this._basicSnapshot(opts);
-        }
-    }
-    /** Fallback basic snapshot — original buildTree approach */
-    async _basicSnapshot(opts = {}) {
-        const maxDepth = Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200));
-        const code = `
-      (async () => {
-        function buildTree(node, depth) {
-          if (depth > ${maxDepth}) return '';
-          const role = node.getAttribute?.('role') || node.tagName?.toLowerCase() || 'generic';
-          const name = node.getAttribute?.('aria-label') || node.getAttribute?.('alt') || node.textContent?.trim().slice(0, 80) || '';
-          const isInteractive = ['a', 'button', 'input', 'select', 'textarea'].includes(node.tagName?.toLowerCase()) || node.getAttribute?.('tabindex') != null;
-
-          ${opts.interactive ? 'if (!isInteractive && !node.children?.length) return "";' : ''}
-
-          let indent = '  '.repeat(depth);
-          let line = indent + role;
-          if (name) line += ' "' + name.replace(/"/g, '\\\\\\"') + '"';
-          if (node.tagName?.toLowerCase() === 'a' && node.href) line += ' [' + node.href + ']';
-          if (node.tagName?.toLowerCase() === 'input') line += ' [' + (node.type || 'text') + ']';
-
-          let result = line + '\\n';
-          if (node.children) {
-            for (const child of node.children) {
-              result += buildTree(child, depth + 1);
-            }
-          }
-          return result;
-        }
-        return buildTree(document.body, 0);
-      })()
-    `;
-        const raw = await sendCommand('exec', { code, ...this._cmdOpts() });
-        if (opts.raw)
-            return raw;
-        if (typeof raw === 'string')
-            return formatSnapshot(raw, opts);
-        return raw;
-    }
-    async click(ref) {
-        const code = clickJs(ref);
-        await sendCommand('exec', { code, ...this._cmdOpts() });
-    }
-    async typeText(ref, text) {
-        const code = typeTextJs(ref, text);
-        await sendCommand('exec', { code, ...this._cmdOpts() });
-    }
-    async pressKey(key) {
-        const code = pressKeyJs(key);
-        await sendCommand('exec', { code, ...this._cmdOpts() });
-    }
-    async scrollTo(ref) {
-        const code = scrollToRefJs(ref);
-        return sendCommand('exec', { code, ...this._cmdOpts() });
-    }
-    async getFormState() {
-        const code = getFormStateJs();
-        return (await sendCommand('exec', { code, ...this._cmdOpts() }));
-    }
-    async wait(options) {
-        if (typeof options === 'number') {
-            if (options >= 1) {
-                // For waits >= 1s, use DOM-stable check: return early when the page
-                // stops mutating, with the original wait time as the hard cap.
-                // This turns e.g. `page.wait(5)` from a fixed 5s sleep into
-                // "wait until DOM is stable, max 5s" — often completing in <1s.
-                try {
-                    const maxMs = options * 1000;
-                    await sendCommand('exec', {
-                        code: waitForDomStableJs(maxMs, Math.min(500, maxMs)),
-                        ...this._cmdOpts(),
-                    });
-                    return;
-                }
-                catch {
-                    // Fallback: fixed sleep (e.g. if page has no DOM yet)
-                }
-            }
-            await new Promise(resolve => setTimeout(resolve, options * 1000));
-            return;
-        }
-        if (typeof options.time === 'number') {
-            await new Promise(resolve => setTimeout(resolve, options.time * 1000));
-            return;
-        }
-        if (options.selector) {
-            const timeout = (options.timeout ?? 10) * 1000;
-            const code = waitForSelectorJs(options.selector, timeout);
-            await sendCommand('exec', { code, ...this._cmdOpts() });
-            return;
-        }
-        if (options.text) {
-            const timeout = (options.timeout ?? 30) * 1000;
-            const code = waitForTextJs(options.text, timeout);
-            await sendCommand('exec', { code, ...this._cmdOpts() });
+            // Window may already be closed or daemon may be down
         }
     }
     async tabs() {
@@ -271,25 +141,8 @@ export class Page {
         if (result?.selected)
             this._tabId = result.selected;
     }
-    async networkRequests(includeStatic = false) {
-        const code = networkRequestsJs(includeStatic);
-        const result = await sendCommand('exec', { code, ...this._cmdOpts() });
-        return Array.isArray(result) ? result : [];
-    }
-    /**
-     * Console messages are not available in lightweight daemon mode.
-     * Would require CDP Runtime.consoleAPICalled event listener.
-     * @returns Always returns empty array.
-     */
-    async consoleMessages(_level = 'info') {
-        return [];
-    }
     /**
      * Capture a screenshot via CDP Page.captureScreenshot.
-     * @param options.format - 'png' (default) or 'jpeg'
-     * @param options.quality - JPEG quality 0-100
-     * @param options.fullPage - capture full scrollable page
-     * @param options.path - save to file path (returns base64 if omitted)
      */
     async screenshot(options = {}) {
         const base64 = await sendCommand('screenshot', {
@@ -303,31 +156,6 @@ export class Page {
         }
         return base64;
     }
-    async scroll(direction = 'down', amount = 500) {
-        const code = scrollJs(direction, amount);
-        await sendCommand('exec', { code, ...this._cmdOpts() });
-    }
-    async autoScroll(options = {}) {
-        const times = options.times ?? 3;
-        const delayMs = options.delayMs ?? 2000;
-        const code = autoScrollJs(times, delayMs);
-        await sendCommand('exec', { code, ...this._cmdOpts() });
-    }
-    async installInterceptor(pattern) {
-        const { generateInterceptorJs } = await import('../interceptor.js');
-        // Must use evaluate() so wrapForEval() converts the arrow function into an IIFE;
-        // sendCommand('exec') sends the code as-is, and CDP never executes a bare arrow.
-        await this.evaluate(generateInterceptorJs(JSON.stringify(pattern), {
-            arrayName: '__opencli_xhr',
-            patchGuard: '__opencli_interceptor_patched',
-        }));
-    }
-    async getInterceptedRequests() {
-        const { generateReadInterceptedJs } = await import('../interceptor.js');
-        // Same as installInterceptor: must go through evaluate() for IIFE wrapping
-        const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
-        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
@@ -343,12 +171,52 @@ export class Page {
             throw new Error('setFileInput returned no count — command may not be supported by the extension');
         }
     }
-    async waitForCapture(timeout = 10) {
-        const maxMs = timeout * 1000;
-        await sendCommand('exec', {
-            code: waitForCaptureJs(maxMs),
+    async cdp(method, params = {}) {
+        return sendCommand('cdp', {
+            cdpMethod: method,
+            cdpParams: params,
             ...this._cmdOpts(),
         });
     }
+    async nativeClick(x, y) {
+        await this.cdp('Input.dispatchMouseEvent', {
+            type: 'mousePressed',
+            x, y,
+            button: 'left',
+            clickCount: 1,
+        });
+        await this.cdp('Input.dispatchMouseEvent', {
+            type: 'mouseReleased',
+            x, y,
+            button: 'left',
+            clickCount: 1,
+        });
+    }
+    async nativeType(text) {
+        // Use Input.insertText for reliable Unicode/CJK text insertion
+        await this.cdp('Input.insertText', { text });
+    }
+    async nativeKeyPress(key, modifiers = []) {
+        let modifierFlags = 0;
+        for (const mod of modifiers) {
+            if (mod === 'Alt')
+                modifierFlags |= 1;
+            if (mod === 'Ctrl')
+                modifierFlags |= 2;
+            if (mod === 'Meta')
+                modifierFlags |= 4;
+            if (mod === 'Shift')
+                modifierFlags |= 8;
+        }
+        await this.cdp('Input.dispatchKeyEvent', {
+            type: 'keyDown',
+            key,
+            modifiers: modifierFlags,
+        });
+        await this.cdp('Input.dispatchKeyEvent', {
+            type: 'keyUp',
+            key,
+            modifiers: modifierFlags,
+        });
+    }
 }
-// (End of file)

package/dist/browser/tabs.js

@@ -19,12 +19,12 @@ export function extractTabEntries(raw) {
             .map(line => line.trim())
             .filter(Boolean)
             .map(line => {
-            // Match actual Playwright MCP format: "- 0: (current) [title](url)"  or  "- 1: [title](url)"
-            const mcpMatch = line.match(/^-\s+(\d+):\s*(.*)$/);
-            if (mcpMatch) {
+            // Match tab list format: "- 0: (current) [title](url)"  or  "- 1: [title](url)"
+            const tabMatch = line.match(/^-\s+(\d+):\s*(.*)$/);
+            if (tabMatch) {
                 return {
-                    index: parseInt(mcpMatch[1], 10),
-                    identity: mcpMatch[2].trim() || `tab-${mcpMatch[1]}`,
+                    index: parseInt(tabMatch[1], 10),
+                    identity: tabMatch[2].trim() || `tab-${tabMatch[1]}`,
                 };
             }
             // Legacy format: "Tab 0 ..."

package/dist/browser.test.js

@@ -84,31 +84,31 @@ describe('browser helpers', () => {
 });
 describe('BrowserBridge state', () => {
     it('transitions to closed after close()', async () => {
-        const mcp = new BrowserBridge();
-        expect(mcp.state).toBe('idle');
-        await mcp.close();
-        expect(mcp.state).toBe('closed');
+        const bridge = new BrowserBridge();
+        expect(bridge.state).toBe('idle');
+        await bridge.close();
+        expect(bridge.state).toBe('closed');
     });
     it('rejects connect() after the session has been closed', async () => {
-        const mcp = new BrowserBridge();
-        await mcp.close();
-        await expect(mcp.connect()).rejects.toThrow('Session is closed');
+        const bridge = new BrowserBridge();
+        await bridge.close();
+        await expect(bridge.connect()).rejects.toThrow('Session is closed');
     });
     it('rejects connect() while already connecting', async () => {
-        const mcp = new BrowserBridge();
-        mcp._state = 'connecting';
-        await expect(mcp.connect()).rejects.toThrow('Already connecting');
+        const bridge = new BrowserBridge();
+        bridge._state = 'connecting';
+        await expect(bridge.connect()).rejects.toThrow('Already connecting');
     });
     it('rejects connect() while closing', async () => {
-        const mcp = new BrowserBridge();
-        mcp._state = 'closing';
-        await expect(mcp.connect()).rejects.toThrow('Session is closing');
+        const bridge = new BrowserBridge();
+        bridge._state = 'closing';
+        await expect(bridge.connect()).rejects.toThrow('Session is closing');
     });
     it('fails fast when daemon is running but extension is disconnected', async () => {
         vi.spyOn(daemonClient, 'isExtensionConnected').mockResolvedValue(false);
         vi.spyOn(daemonClient, 'isDaemonRunning').mockResolvedValue(true);
-        const mcp = new BrowserBridge();
-        await expect(mcp.connect({ timeout: 0.1 })).rejects.toThrow('Browser Extension is not connected');
+        const bridge = new BrowserBridge();
+        await expect(bridge.connect({ timeout: 0.1 })).rejects.toThrow('Browser Extension is not connected');
     });
 });
 describe('stealth anti-detection', () => {