@jackwener/opencli 1.5.6 → 1.5.8

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,20 @@ 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 && existingSession.preferredTabId !== null) {
+    try {
+      const preferredTabId = existingSession.preferredTabId;
+      const preferredTab = await chrome.tabs.get(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 +470,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 +689,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 +726,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 +780,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.test.ts

@@ -0,0 +1,75 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+function createChromeMock() {
+  const tabs = {
+    get: vi.fn(async (_tabId: number) => ({
+      id: 1,
+      windowId: 1,
+      url: 'https://x.com/home',
+    })),
+    onRemoved: { addListener: vi.fn() },
+    onUpdated: { addListener: vi.fn() },
+  };
+
+  const debuggerApi = {
+    attach: vi.fn(async () => {}),
+    detach: vi.fn(async () => {}),
+    sendCommand: vi.fn(async (_target: unknown, method: string) => {
+      if (method === 'Runtime.evaluate') return { result: { value: 'ok' } };
+      return {};
+    }),
+    onDetach: { addListener: vi.fn() },
+  };
+
+  const scripting = {
+    executeScript: vi.fn(async () => [{ result: { removed: 1 } }]),
+  };
+
+  return {
+    chrome: {
+      tabs,
+      debugger: debuggerApi,
+      scripting,
+      runtime: { id: 'opencli-test' },
+    },
+    debuggerApi,
+    scripting,
+  };
+}
+
+describe('cdp attach recovery', () => {
+  beforeEach(() => {
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('does not mutate the DOM before a successful attach', async () => {
+    const { chrome, debuggerApi, scripting } = createChromeMock();
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./cdp');
+    const result = await mod.evaluate(1, '1');
+
+    expect(result).toBe('ok');
+    expect(debuggerApi.attach).toHaveBeenCalledTimes(1);
+    expect(scripting.executeScript).not.toHaveBeenCalled();
+  });
+
+  it('retries after cleanup when attach fails with a foreign extension error', async () => {
+    const { chrome, debuggerApi, scripting } = createChromeMock();
+    debuggerApi.attach
+      .mockRejectedValueOnce(new Error('Cannot access a chrome-extension:// URL of different extension'))
+      .mockResolvedValueOnce(undefined);
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./cdp');
+    const result = await mod.evaluate(1, '1');
+
+    expect(result).toBe('ok');
+    expect(scripting.executeScript).toHaveBeenCalledTimes(1);
+    expect(debuggerApi.attach).toHaveBeenCalledTimes(2);
+  });
+});

package/extension/src/cdp.ts

@@ -10,6 +10,8 @@ const attached = new Set<number>();
 
 /** Internal blank page used when no user URL is provided. */
 const BLANK_PAGE = 'data:text/html,<html></html>';
+const FOREIGN_EXTENSION_URL_PREFIX = 'chrome-extension://';
+const ATTACH_RECOVERY_DELAY_MS = 120;
 
 /** Check if a URL can be attached via CDP — only allow http(s) and our internal blank page. */
 function isDebuggableUrl(url?: string): boolean {
@@ -17,6 +19,67 @@ function isDebuggableUrl(url?: string): boolean {
   return url.startsWith('http://') || url.startsWith('https://') || url === BLANK_PAGE;
 }
 
+type CleanupResult = { removed: number };
+
+async function removeForeignExtensionEmbeds(tabId: number): Promise<CleanupResult> {
+  const tab = await chrome.tabs.get(tabId);
+  if (!tab.url || (!tab.url.startsWith('http://') && !tab.url.startsWith('https://'))) {
+    return { removed: 0 };
+  }
+  if (!chrome.scripting?.executeScript) return { removed: 0 };
+
+  try {
+    const [result] = await chrome.scripting.executeScript({
+      target: { tabId },
+      args: [`${FOREIGN_EXTENSION_URL_PREFIX}${chrome.runtime.id}/`],
+      func: (ownExtensionPrefix: string) => {
+        const extensionPrefix = 'chrome-extension://';
+        const selectors = ['iframe', 'frame', 'embed', 'object'];
+        const visitedRoots = new Set<Document | ShadowRoot>();
+        const roots: Array<Document | ShadowRoot> = [document];
+        let removed = 0;
+
+        while (roots.length > 0) {
+          const root = roots.pop();
+          if (!root || visitedRoots.has(root)) continue;
+          visitedRoots.add(root);
+
+          for (const selector of selectors) {
+            const nodes = root.querySelectorAll(selector);
+            for (const node of nodes) {
+              const src = node.getAttribute('src') || node.getAttribute('data') || '';
+              if (!src.startsWith(extensionPrefix) || src.startsWith(ownExtensionPrefix)) continue;
+              node.remove();
+              removed++;
+            }
+          }
+
+          const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+          let current = walker.nextNode();
+          while (current) {
+            const element = current as Element & { shadowRoot?: ShadowRoot | null };
+            if (element.shadowRoot) roots.push(element.shadowRoot);
+            current = walker.nextNode();
+          }
+        }
+
+        return { removed };
+      },
+    });
+    return result?.result ?? { removed: 0 };
+  } catch {
+    return { removed: 0 };
+  }
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function tryAttach(tabId: number): Promise<void> {
+  await chrome.debugger.attach({ tabId }, '1.3');
+}
+
 async function ensureAttached(tabId: number): Promise<void> {
   // Verify the tab URL is debuggable before attempting attach
   try {
@@ -47,16 +110,27 @@ async function ensureAttached(tabId: number): Promise<void> {
   }
 
   try {
-    await chrome.debugger.attach({ tabId }, '1.3');
+    await tryAttach(tabId);
   } catch (e: unknown) {
     const msg = e instanceof Error ? e.message : String(e);
     const hint = msg.includes('chrome-extension://')
       ? '. Tip: another Chrome extension may be interfering — try disabling other extensions'
       : '';
-    if (msg.includes('Another debugger is already attached')) {
+    if (msg.includes('chrome-extension://')) {
+      const recoveryCleanup = await removeForeignExtensionEmbeds(tabId);
+      if (recoveryCleanup.removed > 0) {
+        console.warn(`[opencli] Removed ${recoveryCleanup.removed} foreign extension frame(s) after attach failure on tab ${tabId}`);
+      }
+      await delay(ATTACH_RECOVERY_DELAY_MS);
+      try {
+        await tryAttach(tabId);
+      } catch {
+        throw new Error(`attach failed: ${msg}${hint}`);
+      }
+    } else if (msg.includes('Another debugger is already attached')) {
       try { await chrome.debugger.detach({ tabId }); } catch { /* ignore */ }
       try {
-        await chrome.debugger.attach({ tabId }, '1.3');
+        await tryAttach(tabId);
       } catch {
         throw new Error(`attach failed: ${msg}${hint}`);
       }
@@ -71,6 +145,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> {