@jackwener/opencli 1.5.6 → 1.5.7

package/extension/src/background.test.ts

@@ -35,8 +35,12 @@ function createChromeMock() {
     { id: 3, windowId: 1, url: 'chrome://extensions', title: 'chrome', active: false, status: 'complete' },
   ];
 
-  const query = vi.fn(async (queryInfo: { windowId?: number } = {}) => {
-    return tabs.filter((tab) => queryInfo.windowId === undefined || tab.windowId === queryInfo.windowId);
+  const query = vi.fn(async (queryInfo: { windowId?: number; active?: boolean } = {}) => {
+    return tabs.filter((tab) => {
+      if (queryInfo.windowId !== undefined && tab.windowId !== queryInfo.windowId) return false;
+      if (queryInfo.active !== undefined && !!tab.active !== queryInfo.active) return false;
+      return true;
+    });
   });
   const create = vi.fn(async ({ windowId, url, active }: { windowId?: number; url?: string; active?: boolean }) => {
     const tab: MockTab = {
@@ -84,6 +88,8 @@ function createChromeMock() {
     runtime: {
       onInstalled: { addListener: vi.fn() } as Listener<() => void>,
       onStartup: { addListener: vi.fn() } as Listener<() => void>,
+      onMessage: { addListener: vi.fn() } as Listener<(msg: unknown, sender: unknown, sendResponse: (value: unknown) => void) => void>,
+      getManifest: vi.fn(() => ({ version: 'test-version' })),
     },
     cookies: {
       getAll: vi.fn(async () => []),
@@ -193,4 +199,198 @@ describe('background tab isolation', () => {
       expect.objectContaining({ workspace: 'site:zhihu', windowId: 2 }),
     ]));
   });
+
+  it('rebinds site:notebooklm to the active notebook tab instead of a home tab', async () => {
+    const { chrome, tabs } = createChromeMock();
+    tabs[0].url = 'https://notebooklm.google.com/';
+    tabs[0].title = 'NotebookLM Home';
+    tabs[1].url = 'https://notebooklm.google.com/notebook/nb-live';
+    tabs[1].title = 'Live Notebook';
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    mod.__test__.setAutomationWindowId('site:notebooklm', 1);
+
+    const tabId = await mod.__test__.resolveTabId(undefined, 'site:notebooklm');
+
+    expect(tabId).toBe(2);
+    expect(mod.__test__.getSession('site:notebooklm')).toEqual(expect.objectContaining({
+      windowId: 2,
+      preferredTabId: 2,
+      owned: false,
+    }));
+  });
+
+  it('prefers a notebook tab over an active home tab for site:notebooklm', async () => {
+    const { chrome, tabs } = createChromeMock();
+    tabs[0].url = 'https://notebooklm.google.com/';
+    tabs[0].title = 'NotebookLM Home';
+    tabs[0].active = true;
+    tabs[1].url = 'https://notebooklm.google.com/notebook/nb-passive';
+    tabs[1].title = 'Notebook';
+    tabs[1].active = false;
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    mod.__test__.setAutomationWindowId('site:notebooklm', 1);
+
+    const tabId = await mod.__test__.resolveTabId(undefined, 'site:notebooklm');
+
+    expect(tabId).toBe(2);
+    expect(mod.__test__.getSession('site:notebooklm')).toEqual(expect.objectContaining({
+      windowId: 2,
+      preferredTabId: 2,
+      owned: false,
+    }));
+  });
+
+  it('detaches an adopted workspace session on idle instead of closing the user window', async () => {
+    const { chrome } = createChromeMock();
+    vi.stubGlobal('chrome', chrome);
+    vi.useFakeTimers();
+
+    const mod = await import('./background');
+    mod.__test__.setSession('site:notebooklm', {
+      windowId: 2,
+      preferredTabId: 2,
+      owned: false,
+    });
+
+    mod.__test__.resetWindowIdleTimer('site:notebooklm');
+    await vi.advanceTimersByTimeAsync(30001);
+
+    expect(chrome.windows.remove).not.toHaveBeenCalled();
+    expect(mod.__test__.getSession('site:notebooklm')).toBeNull();
+  });
+
+  it('binds the active NotebookLM tab into the workspace explicitly', async () => {
+    const { chrome, tabs } = createChromeMock();
+    tabs[1].url = 'https://notebooklm.google.com/notebook/nb-active';
+    tabs[1].title = 'Bound Notebook';
+    tabs[1].active = true;
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    const result = await mod.__test__.handleBindCurrent(
+      {
+        id: 'bind-current',
+        action: 'bind-current',
+        workspace: 'site:notebooklm',
+        matchDomain: 'notebooklm.google.com',
+        matchPathPrefix: '/notebook/',
+      },
+      'site:notebooklm',
+    );
+
+    expect(result).toEqual({
+      id: 'bind-current',
+      ok: true,
+      data: expect.objectContaining({
+        tabId: 2,
+        windowId: 2,
+        url: 'https://notebooklm.google.com/notebook/nb-active',
+        title: 'Bound Notebook',
+        workspace: 'site:notebooklm',
+      }),
+    });
+    expect(mod.__test__.getSession('site:notebooklm')).toEqual(expect.objectContaining({
+      windowId: 2,
+      preferredTabId: 2,
+      owned: false,
+    }));
+  });
+
+  it('bind-current falls back to another matching notebook tab in the current window', async () => {
+    const { chrome, tabs } = createChromeMock();
+    tabs[0].windowId = 2;
+    tabs[0].url = 'https://notebooklm.google.com/';
+    tabs[0].title = 'NotebookLM Home';
+    tabs[0].active = true;
+    tabs[1].url = 'https://notebooklm.google.com/notebook/nb-passive';
+    tabs[1].title = 'Passive Notebook';
+    tabs[1].active = false;
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    const result = await mod.__test__.handleBindCurrent(
+      {
+        id: 'bind-fallback',
+        action: 'bind-current',
+        workspace: 'site:notebooklm',
+        matchDomain: 'notebooklm.google.com',
+        matchPathPrefix: '/notebook/',
+      },
+      'site:notebooklm',
+    );
+
+    expect(result).toEqual({
+      id: 'bind-fallback',
+      ok: true,
+      data: expect.objectContaining({
+        tabId: 2,
+        windowId: 2,
+        url: 'https://notebooklm.google.com/notebook/nb-passive',
+        title: 'Passive Notebook',
+      }),
+    });
+  });
+
+  it('bind-current falls back to a matching notebook tab in another window of the same profile', async () => {
+    const { chrome, tabs } = createChromeMock();
+    tabs[0].windowId = 3;
+    tabs[0].url = 'https://notebooklm.google.com/';
+    tabs[0].title = 'NotebookLM Home';
+    tabs[0].active = true;
+    tabs[1].windowId = 2;
+    tabs[1].url = 'https://notebooklm.google.com/notebook/nb-other-window';
+    tabs[1].title = 'Notebook In Other Window';
+    tabs[1].active = false;
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    const result = await mod.__test__.handleBindCurrent(
+      {
+        id: 'bind-cross-window',
+        action: 'bind-current',
+        workspace: 'site:notebooklm',
+        matchDomain: 'notebooklm.google.com',
+        matchPathPrefix: '/notebook/',
+      },
+      'site:notebooklm',
+    );
+
+    expect(result).toEqual({
+      id: 'bind-cross-window',
+      ok: true,
+      data: expect.objectContaining({
+        tabId: 2,
+        windowId: 2,
+        url: 'https://notebooklm.google.com/notebook/nb-other-window',
+        title: 'Notebook In Other Window',
+      }),
+    });
+  });
+
+  it('rejects bind-current when the active tab is not NotebookLM', async () => {
+    const { chrome } = createChromeMock();
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    const result = await mod.__test__.handleBindCurrent(
+      {
+        id: 'bind-miss',
+        action: 'bind-current',
+        workspace: 'site:notebooklm',
+        matchDomain: 'notebooklm.google.com',
+        matchPathPrefix: '/notebook/',
+      },
+      'site:notebooklm',
+    );
+
+    expect(result).toEqual({
+      id: 'bind-miss',
+      ok: false,
+      error: 'No visible tab matching notebooklm.google.com /notebook/',
+    });
+  });
 });

package/extension/src/background.ts

@@ -117,6 +117,8 @@ type AutomationSession = {
   windowId: number;
   idleTimer: ReturnType<typeof setTimeout> | null;
   idleDeadlineAt: number;
+  owned: boolean;
+  preferredTabId: number | null;
 };
 
 const automationSessions = new Map<string, AutomationSession>();
@@ -134,6 +136,11 @@ function resetWindowIdleTimer(workspace: string): void {
   session.idleTimer = setTimeout(async () => {
     const current = automationSessions.get(workspace);
     if (!current) return;
+    if (!current.owned) {
+      console.log(`[opencli] Borrowed workspace ${workspace} detached from window ${current.windowId} (idle timeout)`);
+      automationSessions.delete(workspace);
+      return;
+    }
     try {
       await chrome.windows.remove(current.windowId);
       console.log(`[opencli] Automation window ${current.windowId} (${workspace}) closed (idle timeout)`);
@@ -173,6 +180,8 @@ async function getAutomationWindow(workspace: string): Promise<number> {
     windowId: win.id!,
     idleTimer: null,
     idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
+    owned: true,
+    preferredTabId: null,
   };
   automationSessions.set(workspace, session);
   console.log(`[opencli] Created automation window ${session.windowId} (${workspace})`);
@@ -254,6 +263,8 @@ async function handleCommand(cmd: Command): Promise<Result> {
         return await handleSessions(cmd);
       case 'set-file-input':
         return await handleSetFileInput(cmd, workspace);
+      case 'bind-current':
+        return await handleBindCurrent(cmd, workspace);
       default:
         return { id: cmd.id, ok: false, error: `Unknown action: ${cmd.action}` };
     }
@@ -301,6 +312,89 @@ function isTargetUrl(currentUrl: string | undefined, targetUrl: string): boolean
   return normalizeUrlForComparison(currentUrl) === normalizeUrlForComparison(targetUrl);
 }
 
+function matchesDomain(url: string | undefined, domain: string): boolean {
+  if (!url) return false;
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname === domain || parsed.hostname.endsWith(`.${domain}`);
+  } catch {
+    return false;
+  }
+}
+
+function matchesBindCriteria(tab: chrome.tabs.Tab, cmd: Command): boolean {
+  if (!tab.id || !isDebuggableUrl(tab.url)) return false;
+  if (cmd.matchDomain && !matchesDomain(tab.url, cmd.matchDomain)) return false;
+  if (cmd.matchPathPrefix) {
+    try {
+      const parsed = new URL(tab.url!);
+      if (!parsed.pathname.startsWith(cmd.matchPathPrefix)) return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+
+function isNotebooklmWorkspace(workspace: string): boolean {
+  return workspace === 'site:notebooklm';
+}
+
+function classifyNotebooklmUrl(url?: string): 'notebook' | 'home' | 'other' {
+  if (!url) return 'other';
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname !== 'notebooklm.google.com') return 'other';
+    return parsed.pathname.startsWith('/notebook/') ? 'notebook' : 'home';
+  } catch {
+    return 'other';
+  }
+}
+
+function scoreWorkspaceTab(workspace: string, tab: chrome.tabs.Tab): number {
+  if (!tab.id || !isDebuggableUrl(tab.url)) return -1;
+  if (isNotebooklmWorkspace(workspace)) {
+    const kind = classifyNotebooklmUrl(tab.url);
+    if (kind === 'other') return -1;
+    if (kind === 'notebook') return tab.active ? 400 : 300;
+    return tab.active ? 200 : 100;
+  }
+  return -1;
+}
+
+function setWorkspaceSession(workspace: string, session: Omit<AutomationSession, 'idleTimer' | 'idleDeadlineAt'>): void {
+  const existing = automationSessions.get(workspace);
+  if (existing?.idleTimer) clearTimeout(existing.idleTimer);
+  automationSessions.set(workspace, {
+    ...session,
+    idleTimer: null,
+    idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
+  });
+}
+
+async function maybeBindWorkspaceToExistingTab(workspace: string): Promise<number | null> {
+  if (!isNotebooklmWorkspace(workspace)) return null;
+  const tabs = await chrome.tabs.query({});
+  let bestTab: chrome.tabs.Tab | null = null;
+  let bestScore = -1;
+  for (const tab of tabs) {
+    const score = scoreWorkspaceTab(workspace, tab);
+    if (score > bestScore) {
+      bestScore = score;
+      bestTab = tab;
+    }
+  }
+  if (!bestTab?.id || bestScore < 0) return null;
+  setWorkspaceSession(workspace, {
+    windowId: bestTab.windowId,
+    owned: false,
+    preferredTabId: bestTab.id,
+  });
+  console.log(`[opencli] Workspace ${workspace} bound to existing tab ${bestTab.id} in window ${bestTab.windowId}`);
+  resetWindowIdleTimer(workspace);
+  return bestTab.id;
+}
+
 /**
  * Resolve target tab in the automation window.
  * If explicit tabId is given, use that directly.
@@ -314,9 +408,12 @@ async function resolveTabId(tabId: number | undefined, workspace: string): Promi
     try {
       const tab = await chrome.tabs.get(tabId);
       const session = automationSessions.get(workspace);
-      if (isDebuggableUrl(tab.url) && session && tab.windowId === session.windowId) return tabId;
-      if (session && tab.windowId !== session.windowId) {
-        console.warn(`[opencli] Tab ${tabId} belongs to window ${tab.windowId}, not automation window ${session.windowId}, re-resolving`);
+      const matchesSession = session
+        ? (session.preferredTabId !== null ? session.preferredTabId === tabId : tab.windowId === session.windowId)
+        : false;
+      if (isDebuggableUrl(tab.url) && matchesSession) return tabId;
+      if (session && !matchesSession) {
+        console.warn(`[opencli] Tab ${tabId} is not bound to workspace ${workspace}, re-resolving`);
       } else if (!isDebuggableUrl(tab.url)) {
         // Tab exists but URL is not debuggable — fall through to auto-resolve
         console.warn(`[opencli] Tab ${tabId} URL is not debuggable (${tab.url}), re-resolving`);
@@ -327,6 +424,19 @@ async function resolveTabId(tabId: number | undefined, workspace: string): Promi
     }
   }
 
+  const adoptedTabId = await maybeBindWorkspaceToExistingTab(workspace);
+  if (adoptedTabId !== null) return adoptedTabId;
+
+  const existingSession = automationSessions.get(workspace);
+  if (existingSession?.preferredTabId !== null) {
+    try {
+      const preferredTab = await chrome.tabs.get(existingSession.preferredTabId);
+      if (isDebuggableUrl(preferredTab.url)) return preferredTab.id!;
+    } catch {
+      automationSessions.delete(workspace);
+    }
+  }
+
   // Get (or create) the automation window
   const windowId = await getAutomationWindow(workspace);
 
@@ -359,6 +469,14 @@ async function resolveTabId(tabId: number | undefined, workspace: string): Promi
 async function listAutomationTabs(workspace: string): Promise<chrome.tabs.Tab[]> {
   const session = automationSessions.get(workspace);
   if (!session) return [];
+  if (session.preferredTabId !== null) {
+    try {
+      return [await chrome.tabs.get(session.preferredTabId)];
+    } catch {
+      automationSessions.delete(workspace);
+      return [];
+    }
+  }
   try {
     return await chrome.tabs.query({ windowId: session.windowId });
   } catch {
@@ -570,10 +688,12 @@ async function handleScreenshot(cmd: Command, workspace: string): Promise<Result
 async function handleCloseWindow(cmd: Command, workspace: string): Promise<Result> {
   const session = automationSessions.get(workspace);
   if (session) {
-    try {
-      await chrome.windows.remove(session.windowId);
-    } catch {
-      // Window may already be closed
+    if (session.owned) {
+      try {
+        await chrome.windows.remove(session.windowId);
+      } catch {
+        // Window may already be closed
+      }
     }
     if (session.idleTimer) clearTimeout(session.idleTimer);
     automationSessions.delete(workspace);
@@ -605,11 +725,52 @@ async function handleSessions(cmd: Command): Promise<Result> {
   return { id: cmd.id, ok: true, data };
 }
 
+async function handleBindCurrent(cmd: Command, workspace: string): Promise<Result> {
+  const activeTabs = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
+  const fallbackTabs = await chrome.tabs.query({ lastFocusedWindow: true });
+  const allTabs = await chrome.tabs.query({});
+  const boundTab = activeTabs.find((tab) => matchesBindCriteria(tab, cmd))
+    ?? fallbackTabs.find((tab) => matchesBindCriteria(tab, cmd))
+    ?? allTabs.find((tab) => matchesBindCriteria(tab, cmd));
+  if (!boundTab?.id) {
+    return {
+      id: cmd.id,
+      ok: false,
+      error: cmd.matchDomain || cmd.matchPathPrefix
+        ? `No visible tab matching ${cmd.matchDomain ?? 'domain'}${cmd.matchPathPrefix ? ` ${cmd.matchPathPrefix}` : ''}`
+        : 'No active debuggable tab found',
+    };
+  }
+
+  setWorkspaceSession(workspace, {
+    windowId: boundTab.windowId,
+    owned: false,
+    preferredTabId: boundTab.id,
+  });
+  resetWindowIdleTimer(workspace);
+  console.log(`[opencli] Workspace ${workspace} explicitly bound to tab ${boundTab.id} (${boundTab.url})`);
+  return {
+    id: cmd.id,
+    ok: true,
+    data: {
+      tabId: boundTab.id,
+      windowId: boundTab.windowId,
+      url: boundTab.url,
+      title: boundTab.title,
+      workspace,
+    },
+  };
+}
+
 export const __test__ = {
   handleNavigate,
   isTargetUrl,
   handleTabs,
   handleSessions,
+  handleBindCurrent,
+  resolveTabId,
+  resetWindowIdleTimer,
+  getSession: (workspace: string = 'default') => automationSessions.get(workspace) ?? null,
   getAutomationWindowId: (workspace: string = 'default') => automationSessions.get(workspace)?.windowId ?? null,
   setAutomationWindowId: (workspace: string, windowId: number | null) => {
     if (windowId === null) {
@@ -618,10 +779,13 @@ export const __test__ = {
       automationSessions.delete(workspace);
       return;
     }
-    automationSessions.set(workspace, {
+    setWorkspaceSession(workspace, {
       windowId,
-      idleTimer: null,
-      idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
+      owned: true,
+      preferredTabId: null,
     });
   },
+  setSession: (workspace: string, session: { windowId: number; owned: boolean; preferredTabId: number | null }) => {
+    setWorkspaceSession(workspace, session);
+  },
 };

package/extension/src/cdp.ts

@@ -71,6 +71,18 @@ async function ensureAttached(tabId: number): Promise<void> {
   } catch {
     // Some pages may not need explicit enable
   }
+
+  // Disable breakpoints so that `debugger;` statements in page code don't
+  // pause execution.  Anti-bot scripts use `debugger;` traps to detect CDP —
+  // they measure the time gap caused by the pause. Deactivating breakpoints
+  // makes the engine skip `debugger;` entirely, neutralising the timing
+  // side-channel without patching page JS.
+  try {
+    await chrome.debugger.sendCommand({ tabId }, 'Debugger.enable');
+    await chrome.debugger.sendCommand({ tabId }, 'Debugger.setBreakpointsActive', { active: false });
+  } catch {
+    // Non-fatal: best-effort hardening
+  }
 }
 
 export async function evaluate(tabId: number, expression: string): Promise<unknown> {

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.7",
   "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);