@jackwener/opencli 1.5.7 → 1.5.9

package/extension/manifest.json

@@ -5,6 +5,7 @@
   "description": "Browser automation bridge for the OpenCLI CLI tool. Executes commands in isolated Chrome windows via a local daemon.",
   "permissions": [
     "debugger",
+    "scripting",
     "tabs",
     "cookies",
     "activeTab",
@@ -35,4 +36,4 @@
     "extension_pages": "script-src 'self'; object-src 'self'"
   },
   "homepage_url": "https://github.com/jackwener/opencli"
-}
+}

package/extension/src/background.test.ts

@@ -200,7 +200,7 @@ describe('background tab isolation', () => {
     ]));
   });
 
-  it('rebinds site:notebooklm to the active notebook tab instead of a home tab', async () => {
+  it('keeps site:notebooklm inside its owned automation window instead of rebinding to a user tab', async () => {
     const { chrome, tabs } = createChromeMock();
     tabs[0].url = 'https://notebooklm.google.com/';
     tabs[0].title = 'NotebookLM Home';
@@ -213,184 +213,28 @@ describe('background tab isolation', () => {
 
     const tabId = await mod.__test__.resolveTabId(undefined, 'site:notebooklm');
 
-    expect(tabId).toBe(2);
+    expect(tabId).toBe(1);
     expect(mod.__test__.getSession('site:notebooklm')).toEqual(expect.objectContaining({
-      windowId: 2,
-      preferredTabId: 2,
-      owned: false,
+      windowId: 1,
     }));
   });
 
-  it('prefers a notebook tab over an active home tab for site:notebooklm', async () => {
+  it('idle timeout closes the automation window 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();
+    vi.stubGlobal('chrome', chrome);
 
     const mod = await import('./background');
-    mod.__test__.setSession('site:notebooklm', {
-      windowId: 2,
-      preferredTabId: 2,
-      owned: false,
-    });
+    mod.__test__.setAutomationWindowId('site:notebooklm', 1);
 
     mod.__test__.resetWindowIdleTimer('site:notebooklm');
     await vi.advanceTimersByTimeAsync(30001);
 
-    expect(chrome.windows.remove).not.toHaveBeenCalled();
+    expect(chrome.windows.remove).toHaveBeenCalledWith(1);
     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,8 +117,6 @@ type AutomationSession = {
   windowId: number;
   idleTimer: ReturnType<typeof setTimeout> | null;
   idleDeadlineAt: number;
-  owned: boolean;
-  preferredTabId: number | null;
 };
 
 const automationSessions = new Map<string, AutomationSession>();
@@ -136,11 +134,6 @@ 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)`);
@@ -180,8 +173,6 @@ 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})`);
@@ -263,8 +254,6 @@ 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}` };
     }
@@ -312,57 +301,7 @@ 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 {
+function setWorkspaceSession(workspace: string, session: Pick<AutomationSession, 'windowId'>): void {
   const existing = automationSessions.get(workspace);
   if (existing?.idleTimer) clearTimeout(existing.idleTimer);
   automationSessions.set(workspace, {
@@ -372,29 +311,6 @@ function setWorkspaceSession(workspace: string, session: Omit<AutomationSession,
   });
 }
 
-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.
@@ -408,9 +324,7 @@ async function resolveTabId(tabId: number | undefined, workspace: string): Promi
     try {
       const tab = await chrome.tabs.get(tabId);
       const session = automationSessions.get(workspace);
-      const matchesSession = session
-        ? (session.preferredTabId !== null ? session.preferredTabId === tabId : tab.windowId === session.windowId)
-        : false;
+      const matchesSession = session ? 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`);
@@ -424,19 +338,6 @@ 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);
 
@@ -469,14 +370,6 @@ 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 {
@@ -688,12 +581,10 @@ 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) {
-    if (session.owned) {
-      try {
-        await chrome.windows.remove(session.windowId);
-      } catch {
-        // Window may already be closed
-      }
+    try {
+      await chrome.windows.remove(session.windowId);
+    } catch {
+      // Window may already be closed
     }
     if (session.idleTimer) clearTimeout(session.idleTimer);
     automationSessions.delete(workspace);
@@ -725,49 +616,11 @@ 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,
@@ -781,11 +634,9 @@ export const __test__ = {
     }
     setWorkspaceSession(workspace, {
       windowId,
-      owned: true,
-      preferredTabId: null,
     });
   },
-  setSession: (workspace: string, session: { windowId: number; owned: boolean; preferredTabId: number | null }) => {
+  setSession: (workspace: string, session: { windowId: number }) => {
     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}`);
       }

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' | 'bind-current';
+export type Action = 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input';
 
 export interface Command {
   /** Unique request ID */
@@ -26,10 +26,6 @@ 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 */

package/package.json

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