@jackwener/opencli 1.5.6 → 1.5.8

package/extension/src/protocol.ts

@@ -5,7 +5,7 @@
  * Everything else is just JS code sent via 'exec'.
  */
 
-export type Action = 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input';
+export type Action = 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'bind-current';
 
 export interface Command {
   /** Unique request ID */
@@ -26,6 +26,10 @@ export interface Command {
   index?: number;
   /** Cookie domain filter */
   domain?: string;
+  /** Optional hostname/domain to require for current-tab binding */
+  matchDomain?: string;
+  /** Optional pathname prefix to require for current-tab binding */
+  matchPathPrefix?: string;
   /** Screenshot format: png (default) or jpeg */
   format?: 'png' | 'jpeg';
   /** JPEG quality (0-100), only for jpeg format */
@@ -58,7 +62,5 @@ export const DAEMON_PING_URL = `http://${DAEMON_HOST}:${DAEMON_PORT}/ping`;
 
 /** Base reconnect delay for extension WebSocket (ms) */
 export const WS_RECONNECT_BASE_DELAY = 2000;
-/** Max reconnect delay (ms) */
-export const WS_RECONNECT_MAX_DELAY = 60000;
-/** Idle timeout before daemon auto-exits (ms) */
-export const DAEMON_IDLE_TIMEOUT = 5 * 60 * 1000;
+/** Max reconnect delay (ms) — kept short since daemon is long-lived */
+export const WS_RECONNECT_MAX_DELAY = 5000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.5.6",
+  "version": "1.5.8",
   "publishConfig": {
     "access": "public"
   },

package/src/browser/cdp.ts

@@ -29,6 +29,7 @@ import {
   waitForSelectorJs,
 } from './dom-helpers.js';
 import { isRecord, saveBase64ToFile } from '../utils.js';
+import { getAllElectronApps } from '../electron-apps.js';
 
 export interface CDPTarget {
   type?: string;
@@ -56,11 +57,11 @@ export class CDPBridge implements IBrowserFactory {
   private _pending = new Map<number, { resolve: (val: unknown) => void; reject: (err: Error) => void; timer: ReturnType<typeof setTimeout> }>();
   private _eventListeners = new Map<string, Set<(params: unknown) => void>>();
 
-  async connect(opts?: { timeout?: number; workspace?: string }): Promise<IPage> {
+  async connect(opts?: { timeout?: number; workspace?: string; cdpEndpoint?: string }): Promise<IPage> {
     if (this._ws) throw new Error('CDPBridge is already connected. Call close() before reconnecting.');
 
-    const endpoint = process.env.OPENCLI_CDP_ENDPOINT;
-    if (!endpoint) throw new Error('OPENCLI_CDP_ENDPOINT is not set');
+    const endpoint = opts?.cdpEndpoint ?? process.env.OPENCLI_CDP_ENDPOINT;
+    if (!endpoint) throw new Error('CDP endpoint not provided (pass cdpEndpoint or set OPENCLI_CDP_ENDPOINT)');
 
     let wsUrl = endpoint;
     if (endpoint.startsWith('http')) {
@@ -326,7 +327,17 @@ class CDPPage implements IPage {
   }
 
   async getCurrentUrl(): Promise<string | null> {
-    return this._lastUrl;
+    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: direct CDP sessions may not have a ready page yet.
+    }
+    return null;
   }
 
   async installInterceptor(pattern: string): Promise<void> {
@@ -404,19 +415,15 @@ function scoreCDPTarget(target: CDPTarget, preferredPattern?: RegExp): number {
   if (url === '' || url === 'about:blank') score -= 40;
 
   if (title && title !== 'devtools') score += 25;
-  if (title.includes('antigravity')) score += 120;
-  if (title.includes('codex')) score += 120;
-  if (title.includes('cursor')) score += 120;
-  if (title.includes('chatwise')) score += 120;
-  if (title.includes('notion')) score += 120;
-  if (title.includes('discord')) score += 120;
-
-  if (url.includes('antigravity')) score += 100;
-  if (url.includes('codex')) score += 100;
-  if (url.includes('cursor')) score += 100;
-  if (url.includes('chatwise')) score += 100;
-  if (url.includes('notion')) score += 100;
-  if (url.includes('discord')) score += 100;
+
+  // Boost score for known Electron app names from the registry (builtin + user-defined)
+  const appNames = Object.values(getAllElectronApps()).map(a => (a.displayName ?? a.processName).toLowerCase());
+  for (const name of appNames) {
+    if (title.includes(name)) { score += 120; break; }
+  }
+  for (const name of appNames) {
+    if (url.includes(name)) { score += 100; break; }
+  }
 
   return score;
 }

package/src/browser/daemon-client.ts

@@ -19,7 +19,7 @@ function generateId(): string {
 
 export interface DaemonCommand {
   id: string;
-  action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input';
+  action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'bind-current';
   tabId?: number;
   code?: string;
   workspace?: string;
@@ -27,6 +27,8 @@ export interface DaemonCommand {
   op?: string;
   index?: number;
   domain?: string;
+  matchDomain?: string;
+  matchPathPrefix?: string;
   format?: 'png' | 'jpeg';
   quality?: number;
   fullPage?: boolean;
@@ -145,3 +147,7 @@ export async function listSessions(): Promise<BrowserSessionInfo[]> {
   return Array.isArray(result) ? result : [];
 }
 
+export async function bindCurrentTab(workspace: string, opts: { matchDomain?: string; matchPathPrefix?: string } = {}): Promise<unknown> {
+  return sendCommand('bind-current', { workspace, ...opts });
+}
+

package/src/browser/dom-helpers.test.ts

@@ -1,5 +1,19 @@
 import { describe, it, expect } from 'vitest';
-import { waitForCaptureJs, waitForSelectorJs } from './dom-helpers.js';
+import { autoScrollJs, waitForCaptureJs, waitForSelectorJs } from './dom-helpers.js';
+
+describe('autoScrollJs', () => {
+  it('returns early without error when document.body is null', async () => {
+    const g = globalThis as any;
+    const origDoc = g.document;
+    g.document = { body: null, documentElement: {} };
+    g.window = g;
+    const code = autoScrollJs(3, 500);
+    // Should resolve without throwing
+    await expect(eval(code)).resolves.not.toThrow();
+    g.document = origDoc;
+    delete g.window;
+  });
+});
 
 describe('waitForCaptureJs', () => {
   it('returns a non-empty string', () => {

package/src/browser/dom-helpers.ts

@@ -109,6 +109,7 @@ export function scrollJs(direction: string, amount: number): string {
 export function autoScrollJs(times: number, delayMs: number): string {
   return `
     (async () => {
+      if (!document.body) return;
       for (let i = 0; i < ${times}; i++) {
         const lastHeight = document.body.scrollHeight;
         window.scrollTo(0, lastHeight);

package/src/browser/mcp.ts

@@ -57,21 +57,30 @@ export class BrowserBridge implements IBrowserFactory {
   }
 
   private async _ensureDaemon(timeoutSeconds?: number): Promise<void> {
-    // Use default if not provided, zero, or negative
     const effectiveSeconds = (timeoutSeconds && timeoutSeconds > 0) ? timeoutSeconds : Math.ceil(DAEMON_SPAWN_TIMEOUT / 1000);
     const timeoutMs = effectiveSeconds * 1000;
 
+    // Fast path: extension already connected
     if (await isExtensionConnected()) return;
+
+    // Daemon running but no extension — wait for extension with progress
     if (await isDaemonRunning()) {
+      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');
+      }
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        await new Promise(resolve => setTimeout(resolve, 200));
+        if (await isExtensionConnected()) 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.',
       );
     }
 
-    // Find daemon relative to this file — works for both:
-    //   npx tsx src/main.ts  → src/browser/mcp.ts  → src/daemon.ts
-    //   node dist/main.js    → dist/browser/mcp.js → dist/daemon.js
+    // No daemon — spawn one
     const __dirname = path.dirname(fileURLToPath(import.meta.url));
     const parentDir = path.resolve(__dirname, '..');
     const daemonTs = path.join(parentDir, 'daemon.ts');
@@ -79,12 +88,10 @@ export class BrowserBridge implements IBrowserFactory {
     const isTs = fs.existsSync(daemonTs);
     const daemonPath = isTs ? daemonTs : daemonJs;
 
-    if (process.env.OPENCLI_VERBOSE) {
-      console.error(`[opencli] Starting daemon (${isTs ? 'ts' : 'js'})...`);
+    if (process.env.OPENCLI_VERBOSE || process.stderr.isTTY) {
+      process.stderr.write('⏳ Starting daemon...\n');
     }
 
-    // For compiled .js, use the current node binary directly (fast).
-    // For .ts dev mode, node can't run .ts files — use tsx via --import.
     const spawnArgs = isTs
       ? [process.execPath, '--import', 'tsx/esm', daemonPath]
       : [process.execPath, daemonPath];
@@ -96,15 +103,13 @@ export class BrowserBridge implements IBrowserFactory {
     });
     this._daemonProc.unref();
 
-    // Wait for daemon to be ready AND extension to connect (exponential backoff)
-    const backoffs = [50, 100, 200, 400, 800, 1500, 3000];
+    // Wait for daemon + extension with faster polling
     const deadline = Date.now() + timeoutMs;
-    for (let i = 0; Date.now() < deadline; i++) {
-      await new Promise(resolve => setTimeout(resolve, backoffs[Math.min(i, backoffs.length - 1)]));
+    while (Date.now() < deadline) {
+      await new Promise(resolve => setTimeout(resolve, 200));
       if (await isExtensionConnected()) return;
     }
 
-    // Daemon might be up but extension not connected — give a useful error
     if (await isDaemonRunning()) {
       throw new Error(
         'Daemon is running but the Browser Extension is not connected.\n' +

package/src/browser/page.test.ts

@@ -0,0 +1,58 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const { sendCommandMock } = vi.hoisted(() => ({
+  sendCommandMock: vi.fn(),
+}));
+
+vi.mock('./daemon-client.js', () => ({
+  sendCommand: sendCommandMock,
+}));
+
+import { Page } from './page.js';
+
+describe('Page.getCurrentUrl', () => {
+  beforeEach(() => {
+    sendCommandMock.mockReset();
+  });
+
+  it('reads the real browser URL when no local navigation cache exists', async () => {
+    sendCommandMock.mockResolvedValueOnce('https://notebooklm.google.com/notebook/nb-live');
+
+    const page = new Page('site:notebooklm');
+    const url = await page.getCurrentUrl();
+
+    expect(url).toBe('https://notebooklm.google.com/notebook/nb-live');
+    expect(sendCommandMock).toHaveBeenCalledTimes(1);
+    expect(sendCommandMock).toHaveBeenCalledWith('exec', expect.objectContaining({
+      workspace: 'site:notebooklm',
+    }));
+  });
+
+  it('caches the discovered browser URL for later reads', async () => {
+    sendCommandMock.mockResolvedValueOnce('https://notebooklm.google.com/notebook/nb-live');
+
+    const page = new Page('site:notebooklm');
+    expect(await page.getCurrentUrl()).toBe('https://notebooklm.google.com/notebook/nb-live');
+    expect(await page.getCurrentUrl()).toBe('https://notebooklm.google.com/notebook/nb-live');
+
+    expect(sendCommandMock).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('Page.evaluate', () => {
+  beforeEach(() => {
+    sendCommandMock.mockReset();
+  });
+
+  it('retries once when the inspected target navigated during exec', async () => {
+    sendCommandMock
+      .mockRejectedValueOnce(new Error('{"code":-32000,"message":"Inspected target navigated or closed"}'))
+      .mockResolvedValueOnce(42);
+
+    const page = new Page('site:notebooklm');
+    const value = await page.evaluate('21 + 21');
+
+    expect(value).toBe(42);
+    expect(sendCommandMock).toHaveBeenCalledTimes(2);
+  });
+});

package/src/browser/page.ts

@@ -108,7 +108,17 @@ export class Page implements IPage {
   }
 
   async getCurrentUrl(): Promise<string | null> {
-    return this._lastUrl;
+    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 */
@@ -122,7 +132,13 @@ export class Page implements IPage {
 
   async evaluate(js: string): Promise<unknown> {
     const code = wrapForEval(js);
-    return sendCommand('exec', { code, ...this._cmdOpts() });
+    try {
+      return await sendCommand('exec', { code, ...this._cmdOpts() });
+    } catch (err) {
+      if (!isRetryableSettleError(err)) throw err;
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      return sendCommand('exec', { code, ...this._cmdOpts() });
+    }
   }
 
   async getCookies(opts: { domain?: string; url?: string } = {}): Promise<BrowserCookie[]> {

package/src/browser/stealth.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect } from 'vitest';
+import { generateStealthJs } from './stealth.js';
+
+/**
+ * Tests for the stealth anti-detection module.
+ *
+ * We test the generated JS string for expected content and structure.
+ * Evaluating in Node is fragile because stealth patches target browser
+ * globals (navigator, Performance, HTMLIFrameElement) that don't exist
+ * or behave differently in Node. Instead we verify the code string
+ * contains the right patches and is syntactically valid.
+ */
+
+describe('generateStealthJs', () => {
+  it('returns a non-empty string', () => {
+    const code = generateStealthJs();
+    expect(typeof code).toBe('string');
+    expect(code.length).toBeGreaterThan(0);
+  });
+
+  it('is a valid self-contained IIFE', () => {
+    const code = generateStealthJs();
+    // Should start/end as an IIFE
+    expect(code.trim()).toMatch(/^\(\(\) => \{/);
+    expect(code.trim()).toMatch(/\}\)\(\)$/);
+  });
+
+  it('patches navigator.webdriver', () => {
+    const code = generateStealthJs();
+    expect(code).toContain("navigator, 'webdriver'");
+    expect(code).toContain('() => false');
+  });
+
+  it('stubs window.chrome', () => {
+    const code = generateStealthJs();
+    expect(code).toContain('window.chrome');
+    expect(code).toContain('runtime');
+    expect(code).toContain('loadTimes');
+    expect(code).toContain('csi');
+  });
+
+  it('fakes navigator.plugins if empty', () => {
+    const code = generateStealthJs();
+    expect(code).toContain('navigator.plugins');
+    expect(code).toContain('PDF Viewer');
+    expect(code).toContain('Chrome PDF Viewer');
+  });
+
+  it('ensures navigator.languages is non-empty', () => {
+    const code = generateStealthJs();
+    expect(code).toContain('navigator.languages');
+    expect(code).toContain("'en-US'");
+  });
+
+  it('normalizes Permissions.query for notifications', () => {
+    const code = generateStealthJs();
+    expect(code).toContain('Permissions');
+    expect(code).toContain('notifications');
+  });
+
+  it('cleans automation artifacts', () => {
+    const code = generateStealthJs();
+    expect(code).toContain('__playwright');
+    expect(code).toContain('__puppeteer');
+    expect(code).toContain("'cdc_'");
+    expect(code).toContain("'__cdc_'");
+  });
+
+  it('filters CDP patterns from Error.stack', () => {
+    const code = generateStealthJs();
+    expect(code).toContain('puppeteer_evaluation_script');
+    expect(code).toContain("'pptr:'");
+    expect(code).toContain("'debugger://'");
+  });
+
+  it('neutralizes debugger statement traps', () => {
+    const code = generateStealthJs();
+    // Should patch Function constructor with new.target / Reflect.construct
+    expect(code).toContain('_OrigFunction');
+    expect(code).toContain('_PatchedFunction');
+    expect(code).toContain('new.target');
+    expect(code).toContain('Reflect.construct');
+    // Should patch eval
+    expect(code).toContain('_origEval');
+    expect(code).toContain('_patchedEval');
+    // Regex to strip debugger (lookbehind for statement boundaries)
+    expect(code).toContain('_debuggerRe');
+  });
+
+  it('uses shared toString disguise via WeakMap', () => {
+    const code = generateStealthJs();
+    // Shared infrastructure at the top of the IIFE
+    expect(code).toContain('_origToString');
+    expect(code).toContain('WeakMap');
+    expect(code).toContain('_disguised');
+    expect(code).toContain('_disguise');
+    // Should NOT have per-instance toString overrides on Function/eval
+    // (they go through _disguise instead)
+  });
+
+  it('defends console method fingerprinting', () => {
+    const code = generateStealthJs();
+    expect(code).toContain('_consoleMethods');
+    expect(code).toContain("'log'");
+    expect(code).toContain("'warn'");
+    expect(code).toContain("'error'");
+    expect(code).toContain('[native code]');
+    // Uses saved _origToString reference
+    expect(code).toContain('_origToString.call');
+  });
+
+  it('defends window dimension detection', () => {
+    const code = generateStealthJs();
+    expect(code).toContain('outerWidth');
+    expect(code).toContain('outerHeight');
+    expect(code).toContain('innerWidth');
+    expect(code).toContain('innerHeight');
+  });
+
+  it('filters Performance API entries', () => {
+    const code = generateStealthJs();
+    expect(code).toContain('getEntries');
+    expect(code).toContain('getEntriesByType');
+    expect(code).toContain('getEntriesByName');
+    expect(code).toContain('_suspiciousPatterns');
+  });
+
+  it('cleans document $cdc_ properties', () => {
+    const code = generateStealthJs();
+    expect(code).toContain("'$cdc_'");
+    expect(code).toContain("'$chrome_'");
+  });
+
+  it('patches iframe contentWindow.chrome consistency', () => {
+    const code = generateStealthJs();
+    expect(code).toContain('contentWindow');
+    expect(code).toContain('HTMLIFrameElement');
+  });
+
+  it('uses non-enumerable guard flag on EventTarget.prototype', () => {
+    const code = generateStealthJs();
+    expect(code).toContain('EventTarget.prototype');
+    expect(code).toContain("'__lsn'");
+    expect(code).toContain('enumerable: false');
+  });
+
+  it('generates syntactically valid JavaScript', () => {
+    const code = generateStealthJs();
+    // new Function() parses the code without executing it in a real
+    // browser context, catching syntax errors from template literal issues.
+    expect(() => new Function(code)).not.toThrow();
+  });
+});