@jackwener/opencli 1.6.2 → 1.6.3

package/extension/src/background.ts

@@ -1,878 +0,0 @@
-/**
- * OpenCLI — Service Worker (background script).
- *
- * Connects to the opencli daemon via WebSocket, receives commands,
- * dispatches them to Chrome APIs (debugger/tabs/cookies), returns results.
- */
-
-import type { Command, Result } from './protocol';
-import { DAEMON_WS_URL, DAEMON_PING_URL, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY } from './protocol';
-import * as executor from './cdp';
-
-let ws: WebSocket | null = null;
-let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
-let reconnectAttempts = 0;
-
-// ─── Console log forwarding ──────────────────────────────────────────
-// Hook console.log/warn/error to forward logs to daemon via WebSocket.
-
-const _origLog = console.log.bind(console);
-const _origWarn = console.warn.bind(console);
-const _origError = console.error.bind(console);
-
-function forwardLog(level: 'info' | 'warn' | 'error', args: unknown[]): void {
-  if (!ws || ws.readyState !== WebSocket.OPEN) return;
-  try {
-    const msg = args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ');
-    ws.send(JSON.stringify({ type: 'log', level, msg, ts: Date.now() }));
-  } catch { /* don't recurse */ }
-}
-
-console.log = (...args: unknown[]) => { _origLog(...args); forwardLog('info', args); };
-console.warn = (...args: unknown[]) => { _origWarn(...args); forwardLog('warn', args); };
-console.error = (...args: unknown[]) => { _origError(...args); forwardLog('error', args); };
-
-// ─── WebSocket connection ────────────────────────────────────────────
-
-/**
- * Probe the daemon via its /ping HTTP endpoint before attempting a WebSocket
- * connection.  fetch() failures are silently catchable; new WebSocket() is not
- * — Chrome logs ERR_CONNECTION_REFUSED to the extension error page before any
- * JS handler can intercept it.  By keeping the probe inside connect() every
- * call site remains unchanged and the guard can never be accidentally skipped.
- */
-async function connect(): Promise<void> {
-  if (ws?.readyState === WebSocket.OPEN || ws?.readyState === WebSocket.CONNECTING) return;
-
-  try {
-    const res = await fetch(DAEMON_PING_URL, { signal: AbortSignal.timeout(1000) });
-    if (!res.ok) return; // unexpected response — not our daemon
-  } catch {
-    return; // daemon not running — skip WebSocket to avoid console noise
-  }
-
-  try {
-    ws = new WebSocket(DAEMON_WS_URL);
-  } catch {
-    scheduleReconnect();
-    return;
-  }
-
-  ws.onopen = () => {
-    console.log('[opencli] Connected to daemon');
-    reconnectAttempts = 0; // Reset on successful connection
-    if (reconnectTimer) {
-      clearTimeout(reconnectTimer);
-      reconnectTimer = null;
-    }
-    // Send version so the daemon can report mismatches to the CLI
-    ws?.send(JSON.stringify({ type: 'hello', version: chrome.runtime.getManifest().version }));
-  };
-
-  ws.onmessage = async (event) => {
-    try {
-      const command = JSON.parse(event.data as string) as Command;
-      const result = await handleCommand(command);
-      ws?.send(JSON.stringify(result));
-    } catch (err) {
-      console.error('[opencli] Message handling error:', err);
-    }
-  };
-
-  ws.onclose = () => {
-    console.log('[opencli] Disconnected from daemon');
-    ws = null;
-    scheduleReconnect();
-  };
-
-  ws.onerror = () => {
-    ws?.close();
-  };
-}
-
-/**
- * After MAX_EAGER_ATTEMPTS (reaching 60s backoff), stop scheduling reconnects.
- * The keepalive alarm (~24s) will still call connect() periodically, but at a
- * much lower frequency — reducing console noise when the daemon is not running.
- */
-const MAX_EAGER_ATTEMPTS = 6; // 2s, 4s, 8s, 16s, 32s, 60s — then stop
-
-function scheduleReconnect(): void {
-  if (reconnectTimer) return;
-  reconnectAttempts++;
-  if (reconnectAttempts > MAX_EAGER_ATTEMPTS) return; // let keepalive alarm handle it
-  const delay = Math.min(WS_RECONNECT_BASE_DELAY * Math.pow(2, reconnectAttempts - 1), WS_RECONNECT_MAX_DELAY);
-  reconnectTimer = setTimeout(() => {
-    reconnectTimer = null;
-    void connect();
-  }, delay);
-}
-
-// ─── Automation window isolation ─────────────────────────────────────
-// All opencli operations happen in a dedicated Chrome window so the
-// user's active browsing session is never touched.
-// The window auto-closes after 120s of idle (no commands).
-
-type AutomationSession = {
-  windowId: number;
-  idleTimer: ReturnType<typeof setTimeout> | null;
-  idleDeadlineAt: number;
-  owned: boolean;
-  preferredTabId: number | null;
-};
-
-const automationSessions = new Map<string, AutomationSession>();
-const WINDOW_IDLE_TIMEOUT = 30000; // 30s — quick cleanup after command finishes
-
-function getWorkspaceKey(workspace?: string): string {
-  return workspace?.trim() || 'default';
-}
-
-function resetWindowIdleTimer(workspace: string): void {
-  const session = automationSessions.get(workspace);
-  if (!session) return;
-  if (session.idleTimer) clearTimeout(session.idleTimer);
-  session.idleDeadlineAt = Date.now() + WINDOW_IDLE_TIMEOUT;
-  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)`);
-    } catch {
-      // Already gone
-    }
-    automationSessions.delete(workspace);
-  }, WINDOW_IDLE_TIMEOUT);
-}
-
-/** Get or create the dedicated automation window.
- *  @param initialUrl — if provided (http/https), used as the initial page instead of about:blank.
- *    This avoids an extra blank-page→target-domain navigation on first command.
- */
-async function getAutomationWindow(workspace: string, initialUrl?: string): Promise<number> {
-  // Check if our window is still alive
-  const existing = automationSessions.get(workspace);
-  if (existing) {
-    try {
-      await chrome.windows.get(existing.windowId);
-      return existing.windowId;
-    } catch {
-      // Window was closed by user
-      automationSessions.delete(workspace);
-    }
-  }
-
-  // Use the target URL directly if it's a safe navigation URL, otherwise fall back to about:blank.
-  const startUrl = (initialUrl && isSafeNavigationUrl(initialUrl)) ? initialUrl : BLANK_PAGE;
-
-  // Note: Do NOT set `state` parameter here. Chrome 146+ rejects 'normal' as an invalid
-  // state value for windows.create(). The window defaults to 'normal' state anyway.
-  const win = await chrome.windows.create({
-    url: startUrl,
-    focused: false,
-    width: 1280,
-    height: 900,
-    type: 'normal',
-  });
-  const session: AutomationSession = {
-    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}, start=${startUrl})`);
-  resetWindowIdleTimer(workspace);
-  // Wait for the initial tab to finish loading instead of a fixed 200ms sleep.
-  const tabs = await chrome.tabs.query({ windowId: win.id! });
-  if (tabs[0]?.id) {
-    await new Promise<void>((resolve) => {
-      const timeout = setTimeout(resolve, 500); // fallback cap
-      const listener = (tabId: number, info: chrome.tabs.TabChangeInfo) => {
-        if (tabId === tabs[0].id && info.status === 'complete') {
-          chrome.tabs.onUpdated.removeListener(listener);
-          clearTimeout(timeout);
-          resolve();
-        }
-      };
-      // Check if already complete before listening
-      if (tabs[0].status === 'complete') {
-        clearTimeout(timeout);
-        resolve();
-      } else {
-        chrome.tabs.onUpdated.addListener(listener);
-      }
-    });
-  }
-  return session.windowId;
-}
-
-// Clean up when the automation window is closed
-chrome.windows.onRemoved.addListener((windowId) => {
-  for (const [workspace, session] of automationSessions.entries()) {
-    if (session.windowId === windowId) {
-      console.log(`[opencli] Automation window closed (${workspace})`);
-      if (session.idleTimer) clearTimeout(session.idleTimer);
-      automationSessions.delete(workspace);
-    }
-  }
-});
-
-// ─── Lifecycle events ────────────────────────────────────────────────
-
-let initialized = false;
-
-function initialize(): void {
-  if (initialized) return;
-  initialized = true;
-  chrome.alarms.create('keepalive', { periodInMinutes: 0.4 }); // ~24 seconds
-  executor.registerListeners();
-  void connect();
-  console.log('[opencli] OpenCLI extension initialized');
-}
-
-chrome.runtime.onInstalled.addListener(() => {
-  initialize();
-});
-
-chrome.runtime.onStartup.addListener(() => {
-  initialize();
-});
-
-chrome.alarms.onAlarm.addListener((alarm) => {
-  if (alarm.name === 'keepalive') void connect();
-});
-
-// ─── Popup status API ───────────────────────────────────────────────
-
-chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
-  if (msg?.type === 'getStatus') {
-    sendResponse({
-      connected: ws?.readyState === WebSocket.OPEN,
-      reconnecting: reconnectTimer !== null,
-    });
-  }
-  return false;
-});
-
-// ─── Command dispatcher ─────────────────────────────────────────────
-
-async function handleCommand(cmd: Command): Promise<Result> {
-  const workspace = getWorkspaceKey(cmd.workspace);
-  // Reset idle timer on every command (window stays alive while active)
-  resetWindowIdleTimer(workspace);
-  try {
-    switch (cmd.action) {
-      case 'exec':
-        return await handleExec(cmd, workspace);
-      case 'navigate':
-        return await handleNavigate(cmd, workspace);
-      case 'tabs':
-        return await handleTabs(cmd, workspace);
-      case 'cookies':
-        return await handleCookies(cmd);
-      case 'screenshot':
-        return await handleScreenshot(cmd, workspace);
-      case 'close-window':
-        return await handleCloseWindow(cmd, workspace);
-      case 'cdp':
-        return await handleCdp(cmd, workspace);
-      case 'sessions':
-        return await handleSessions(cmd);
-      case 'set-file-input':
-        return await handleSetFileInput(cmd, workspace);
-      case 'insert-text':
-        return await handleInsertText(cmd, workspace);
-      case 'bind-current':
-        return await handleBindCurrent(cmd, workspace);
-      case 'network-capture-start':
-        return await handleNetworkCaptureStart(cmd, workspace);
-      case 'network-capture-read':
-        return await handleNetworkCaptureRead(cmd, workspace);
-      default:
-        return { id: cmd.id, ok: false, error: `Unknown action: ${cmd.action}` };
-    }
-  } catch (err) {
-    return {
-      id: cmd.id,
-      ok: false,
-      error: err instanceof Error ? err.message : String(err),
-    };
-  }
-}
-
-// ─── Action handlers ─────────────────────────────────────────────────
-
-/** Internal blank page used when no user URL is provided. */
-const BLANK_PAGE = 'about:blank';
-
-/** Check if a URL can be attached via CDP — only allow http(s) and blank pages. */
-function isDebuggableUrl(url?: string): boolean {
-  if (!url) return true;  // empty/undefined = tab still loading, allow it
-  return url.startsWith('http://') || url.startsWith('https://') || url === 'about:blank' || url.startsWith('data:');
-}
-
-/** Check if a URL is safe for user-facing navigation (http/https only). */
-function isSafeNavigationUrl(url: string): boolean {
-  return url.startsWith('http://') || url.startsWith('https://');
-}
-
-/** Minimal URL normalization for same-page comparison: root slash + default port only. */
-function normalizeUrlForComparison(url?: string): string {
-  if (!url) return '';
-  try {
-    const parsed = new URL(url);
-    if ((parsed.protocol === 'https:' && parsed.port === '443') || (parsed.protocol === 'http:' && parsed.port === '80')) {
-      parsed.port = '';
-    }
-    const pathname = parsed.pathname === '/' ? '' : parsed.pathname;
-    return `${parsed.protocol}//${parsed.host}${pathname}${parsed.search}${parsed.hash}`;
-  } catch {
-    return url;
-  }
-}
-
-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 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,
-  });
-}
-
-type ResolvedTab = { tabId: number; tab: chrome.tabs.Tab | null };
-
-/**
- * Resolve target tab in the automation window, returning both the tabId and
- * the Tab object (when available) so callers can skip a redundant chrome.tabs.get().
- */
-async function resolveTab(tabId: number | undefined, workspace: string, initialUrl?: string): Promise<ResolvedTab> {
-  // Even when an explicit tabId is provided, validate it is still debuggable.
-  if (tabId !== undefined) {
-    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;
-      if (isDebuggableUrl(tab.url) && matchesSession) return { tabId, tab };
-      if (session && !matchesSession && session.preferredTabId === null && isDebuggableUrl(tab.url)) {
-        // Tab drifted to another window but content is still valid.
-        // Try to move it back instead of abandoning it.
-        console.warn(`[opencli] Tab ${tabId} drifted to window ${tab.windowId}, moving back to ${session.windowId}`);
-        try {
-          await chrome.tabs.move(tabId, { windowId: session.windowId, index: -1 });
-          const moved = await chrome.tabs.get(tabId);
-          if (moved.windowId === session.windowId && isDebuggableUrl(moved.url)) {
-            return { tabId, tab: moved };
-          }
-        } catch (moveErr) {
-          console.warn(`[opencli] Failed to move tab back: ${moveErr}`);
-        }
-      } else if (!isDebuggableUrl(tab.url)) {
-        console.warn(`[opencli] Tab ${tabId} URL is not debuggable (${tab.url}), re-resolving`);
-      }
-    } catch {
-      console.warn(`[opencli] Tab ${tabId} no longer exists, re-resolving`);
-    }
-  }
-
-  const existingSession = automationSessions.get(workspace);
-  if (existingSession?.preferredTabId !== null) {
-    try {
-      const preferredTab = await chrome.tabs.get(existingSession.preferredTabId);
-      if (isDebuggableUrl(preferredTab.url)) return { tabId: preferredTab.id!, tab: preferredTab };
-    } catch {
-      automationSessions.delete(workspace);
-    }
-  }
-
-  // Get (or create) the automation window
-  const windowId = await getAutomationWindow(workspace, initialUrl);
-
-  // Prefer an existing debuggable tab
-  const tabs = await chrome.tabs.query({ windowId });
-  const debuggableTab = tabs.find(t => t.id && isDebuggableUrl(t.url));
-  if (debuggableTab?.id) return { tabId: debuggableTab.id, tab: debuggableTab };
-
-  // No debuggable tab — another extension may have hijacked the tab URL.
-  const reuseTab = tabs.find(t => t.id);
-  if (reuseTab?.id) {
-    await chrome.tabs.update(reuseTab.id, { url: BLANK_PAGE });
-    await new Promise(resolve => setTimeout(resolve, 300));
-    try {
-      const updated = await chrome.tabs.get(reuseTab.id);
-      if (isDebuggableUrl(updated.url)) return { tabId: reuseTab.id, tab: updated };
-      console.warn(`[opencli] data: URI was intercepted (${updated.url}), creating fresh tab`);
-    } catch {
-      // Tab was closed during navigation
-    }
-  }
-
-  // Fallback: create a new tab
-  const newTab = await chrome.tabs.create({ windowId, url: BLANK_PAGE, active: true });
-  if (!newTab.id) throw new Error('Failed to create tab in automation window');
-  return { tabId: newTab.id, tab: newTab };
-}
-
-/** Convenience wrapper returning just the tabId (used by most handlers) */
-async function resolveTabId(tabId: number | undefined, workspace: string, initialUrl?: string): Promise<number> {
-  const resolved = await resolveTab(tabId, workspace, initialUrl);
-  return resolved.tabId;
-}
-
-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 {
-    automationSessions.delete(workspace);
-    return [];
-  }
-}
-
-async function listAutomationWebTabs(workspace: string): Promise<chrome.tabs.Tab[]> {
-  const tabs = await listAutomationTabs(workspace);
-  return tabs.filter((tab) => isDebuggableUrl(tab.url));
-}
-
-async function handleExec(cmd: Command, workspace: string): Promise<Result> {
-  if (!cmd.code) return { id: cmd.id, ok: false, error: 'Missing code' };
-  const tabId = await resolveTabId(cmd.tabId, workspace);
-  try {
-    const aggressive = workspace.startsWith('operate:');
-    const data = await executor.evaluateAsync(tabId, cmd.code, aggressive);
-    return { id: cmd.id, ok: true, data };
-  } catch (err) {
-    return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-
-async function handleNavigate(cmd: Command, workspace: string): Promise<Result> {
-  if (!cmd.url) return { id: cmd.id, ok: false, error: 'Missing url' };
-  if (!isSafeNavigationUrl(cmd.url)) {
-    return { id: cmd.id, ok: false, error: 'Blocked URL scheme -- only http:// and https:// are allowed' };
-  }
-  // Pass target URL so that first-time window creation can start on the right domain
-  const resolved = await resolveTab(cmd.tabId, workspace, cmd.url);
-  const tabId = resolved.tabId;
-
-  const beforeTab = resolved.tab ?? await chrome.tabs.get(tabId);
-  const beforeNormalized = normalizeUrlForComparison(beforeTab.url);
-  const targetUrl = cmd.url;
-
-  // Fast-path: tab is already at the target URL and fully loaded.
-  if (beforeTab.status === 'complete' && isTargetUrl(beforeTab.url, targetUrl)) {
-    return {
-      id: cmd.id,
-      ok: true,
-      data: { title: beforeTab.title, url: beforeTab.url, tabId, timedOut: false },
-    };
-  }
-
-  // Detach any existing debugger before top-level navigation.
-  // Some sites (observed on creator.xiaohongshu.com flows) can invalidate the
-  // current inspected target during navigation, which leaves a stale CDP attach
-  // state and causes the next Runtime.evaluate to fail with
-  // "Inspected target navigated or closed". Resetting here forces a clean
-  // re-attach after navigation.
-  await executor.detach(tabId);
-
-  await chrome.tabs.update(tabId, { url: targetUrl });
-
-  // Wait until navigation completes. Resolve when status is 'complete' AND either:
-  // - the URL matches the target (handles same-URL / canonicalized navigations), OR
-  // - the URL differs from the pre-navigation URL (handles redirects).
-  let timedOut = false;
-  await new Promise<void>((resolve) => {
-    let settled = false;
-    let checkTimer: ReturnType<typeof setTimeout> | null = null;
-    let timeoutTimer: ReturnType<typeof setTimeout> | null = null;
-
-    const finish = () => {
-      if (settled) return;
-      settled = true;
-      chrome.tabs.onUpdated.removeListener(listener);
-      if (checkTimer) clearTimeout(checkTimer);
-      if (timeoutTimer) clearTimeout(timeoutTimer);
-      resolve();
-    };
-
-    const isNavigationDone = (url: string | undefined): boolean => {
-      return isTargetUrl(url, targetUrl) || normalizeUrlForComparison(url) !== beforeNormalized;
-    };
-
-    const listener = (id: number, info: chrome.tabs.TabChangeInfo, tab: chrome.tabs.Tab) => {
-      if (id !== tabId) return;
-      if (info.status === 'complete' && isNavigationDone(tab.url ?? info.url)) {
-        finish();
-      }
-    };
-    chrome.tabs.onUpdated.addListener(listener);
-
-    // Also check if the tab already navigated (e.g. instant cache hit)
-    checkTimer = setTimeout(async () => {
-      try {
-        const currentTab = await chrome.tabs.get(tabId);
-        if (currentTab.status === 'complete' && isNavigationDone(currentTab.url)) {
-          finish();
-        }
-      } catch { /* tab gone */ }
-    }, 100);
-
-    // Timeout fallback with warning
-    timeoutTimer = setTimeout(() => {
-      timedOut = true;
-      console.warn(`[opencli] Navigate to ${targetUrl} timed out after 15s`);
-      finish();
-    }, 15000);
-  });
-
-  let tab = await chrome.tabs.get(tabId);
-
-  // Post-navigation drift detection: if the tab moved to another window
-  // during navigation (e.g. a tab-management extension regrouped it),
-  // try to move it back to maintain session isolation.
-  const session = automationSessions.get(workspace);
-  if (session && tab.windowId !== session.windowId) {
-    console.warn(`[opencli] Tab ${tabId} drifted to window ${tab.windowId} during navigation, moving back to ${session.windowId}`);
-    try {
-      await chrome.tabs.move(tabId, { windowId: session.windowId, index: -1 });
-      tab = await chrome.tabs.get(tabId);
-    } catch (moveErr) {
-      console.warn(`[opencli] Failed to recover drifted tab: ${moveErr}`);
-    }
-  }
-
-  return {
-    id: cmd.id,
-    ok: true,
-    data: { title: tab.title, url: tab.url, tabId, timedOut },
-  };
-}
-
-async function handleTabs(cmd: Command, workspace: string): Promise<Result> {
-  switch (cmd.op) {
-    case 'list': {
-      const tabs = await listAutomationWebTabs(workspace);
-      const data = tabs
-        .map((t, i) => ({
-          index: i,
-          tabId: t.id,
-          url: t.url,
-          title: t.title,
-          active: t.active,
-        }));
-      return { id: cmd.id, ok: true, data };
-    }
-    case 'new': {
-      if (cmd.url && !isSafeNavigationUrl(cmd.url)) {
-        return { id: cmd.id, ok: false, error: 'Blocked URL scheme -- only http:// and https:// are allowed' };
-      }
-      const windowId = await getAutomationWindow(workspace);
-      const tab = await chrome.tabs.create({ windowId, url: cmd.url ?? BLANK_PAGE, active: true });
-      return { id: cmd.id, ok: true, data: { tabId: tab.id, url: tab.url } };
-    }
-    case 'close': {
-      if (cmd.index !== undefined) {
-        const tabs = await listAutomationWebTabs(workspace);
-        const target = tabs[cmd.index];
-        if (!target?.id) return { id: cmd.id, ok: false, error: `Tab index ${cmd.index} not found` };
-        await chrome.tabs.remove(target.id);
-        await executor.detach(target.id);
-        return { id: cmd.id, ok: true, data: { closed: target.id } };
-      }
-      const tabId = await resolveTabId(cmd.tabId, workspace);
-      await chrome.tabs.remove(tabId);
-      await executor.detach(tabId);
-      return { id: cmd.id, ok: true, data: { closed: tabId } };
-    }
-    case 'select': {
-      if (cmd.index === undefined && cmd.tabId === undefined)
-        return { id: cmd.id, ok: false, error: 'Missing index or tabId' };
-      if (cmd.tabId !== undefined) {
-        const session = automationSessions.get(workspace);
-        let tab: chrome.tabs.Tab;
-        try {
-          tab = await chrome.tabs.get(cmd.tabId);
-        } catch {
-          return { id: cmd.id, ok: false, error: `Tab ${cmd.tabId} no longer exists` };
-        }
-        if (!session || tab.windowId !== session.windowId) {
-          return { id: cmd.id, ok: false, error: `Tab ${cmd.tabId} is not in the automation window` };
-        }
-        await chrome.tabs.update(cmd.tabId, { active: true });
-        return { id: cmd.id, ok: true, data: { selected: cmd.tabId } };
-      }
-      const tabs = await listAutomationWebTabs(workspace);
-      const target = tabs[cmd.index!];
-      if (!target?.id) return { id: cmd.id, ok: false, error: `Tab index ${cmd.index} not found` };
-      await chrome.tabs.update(target.id, { active: true });
-      return { id: cmd.id, ok: true, data: { selected: target.id } };
-    }
-    default:
-      return { id: cmd.id, ok: false, error: `Unknown tabs op: ${cmd.op}` };
-  }
-}
-
-async function handleCookies(cmd: Command): Promise<Result> {
-  if (!cmd.domain && !cmd.url) {
-    return { id: cmd.id, ok: false, error: 'Cookie scope required: provide domain or url to avoid dumping all cookies' };
-  }
-  const details: chrome.cookies.GetAllDetails = {};
-  if (cmd.domain) details.domain = cmd.domain;
-  if (cmd.url) details.url = cmd.url;
-  const cookies = await chrome.cookies.getAll(details);
-  const data = cookies.map((c) => ({
-    name: c.name,
-    value: c.value,
-    domain: c.domain,
-    path: c.path,
-    secure: c.secure,
-    httpOnly: c.httpOnly,
-    expirationDate: c.expirationDate,
-  }));
-  return { id: cmd.id, ok: true, data };
-}
-
-async function handleScreenshot(cmd: Command, workspace: string): Promise<Result> {
-  const tabId = await resolveTabId(cmd.tabId, workspace);
-  try {
-    const data = await executor.screenshot(tabId, {
-      format: cmd.format,
-      quality: cmd.quality,
-      fullPage: cmd.fullPage,
-    });
-    return { id: cmd.id, ok: true, data };
-  } catch (err) {
-    return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-
-/** CDP methods permitted via the 'cdp' passthrough action. */
-const CDP_ALLOWLIST = new Set([
-  // Agent DOM context
-  'Accessibility.getFullAXTree',
-  'DOM.getDocument',
-  'DOM.getBoxModel',
-  'DOM.getContentQuads',
-  'DOM.querySelectorAll',
-  'DOM.scrollIntoViewIfNeeded',
-  'DOMSnapshot.captureSnapshot',
-  // Native input events
-  'Input.dispatchMouseEvent',
-  'Input.dispatchKeyEvent',
-  'Input.insertText',
-  // Page metrics & screenshots
-  'Page.getLayoutMetrics',
-  'Page.captureScreenshot',
-  // Runtime.enable needed for CDP attach setup (Runtime.evaluate goes through 'exec' action)
-  'Runtime.enable',
-  // Emulation (used by screenshot full-page)
-  'Emulation.setDeviceMetricsOverride',
-  'Emulation.clearDeviceMetricsOverride',
-]);
-
-async function handleCdp(cmd: Command, workspace: string): Promise<Result> {
-  if (!cmd.cdpMethod) return { id: cmd.id, ok: false, error: 'Missing cdpMethod' };
-  if (!CDP_ALLOWLIST.has(cmd.cdpMethod)) {
-    return { id: cmd.id, ok: false, error: `CDP method not permitted: ${cmd.cdpMethod}` };
-  }
-  const tabId = await resolveTabId(cmd.tabId, workspace);
-  try {
-    const aggressive = workspace.startsWith('operate:');
-    await executor.ensureAttached(tabId, aggressive);
-    const data = await chrome.debugger.sendCommand(
-      { tabId },
-      cmd.cdpMethod,
-      cmd.cdpParams ?? {},
-    );
-    return { id: cmd.id, ok: true, data };
-  } catch (err) {
-    return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-
-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
-      }
-    }
-    if (session.idleTimer) clearTimeout(session.idleTimer);
-    automationSessions.delete(workspace);
-  }
-  return { id: cmd.id, ok: true, data: { closed: true } };
-}
-
-async function handleSetFileInput(cmd: Command, workspace: string): Promise<Result> {
-  if (!cmd.files || !Array.isArray(cmd.files) || cmd.files.length === 0) {
-    return { id: cmd.id, ok: false, error: 'Missing or empty files array' };
-  }
-  const tabId = await resolveTabId(cmd.tabId, workspace);
-  try {
-    await executor.setFileInputFiles(tabId, cmd.files, cmd.selector);
-    return { id: cmd.id, ok: true, data: { count: cmd.files.length } };
-  } catch (err) {
-    return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-
-async function handleInsertText(cmd: Command, workspace: string): Promise<Result> {
-  if (typeof cmd.text !== 'string') {
-    return { id: cmd.id, ok: false, error: 'Missing text payload' };
-  }
-  const tabId = await resolveTabId(cmd.tabId, workspace);
-  try {
-    await executor.insertText(tabId, cmd.text);
-    return { id: cmd.id, ok: true, data: { inserted: true } };
-  } catch (err) {
-    return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-
-async function handleNetworkCaptureStart(cmd: Command, workspace: string): Promise<Result> {
-  const tabId = await resolveTabId(cmd.tabId, workspace);
-  try {
-    await executor.startNetworkCapture(tabId, cmd.pattern);
-    return { id: cmd.id, ok: true, data: { started: true } };
-  } catch (err) {
-    return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-
-async function handleNetworkCaptureRead(cmd: Command, workspace: string): Promise<Result> {
-  const tabId = await resolveTabId(cmd.tabId, workspace);
-  try {
-    const data = await executor.readNetworkCapture(tabId);
-    return { id: cmd.id, ok: true, data };
-  } catch (err) {
-    return { id: cmd.id, ok: false, error: err instanceof Error ? err.message : String(err) };
-  }
-}
-
-async function handleSessions(cmd: Command): Promise<Result> {
-  const now = Date.now();
-  const data = await Promise.all([...automationSessions.entries()].map(async ([workspace, session]) => ({
-    workspace,
-    windowId: session.windowId,
-    tabCount: (await chrome.tabs.query({ windowId: session.windowId })).filter((tab) => isDebuggableUrl(tab.url)).length,
-    idleMsRemaining: Math.max(0, session.idleDeadlineAt - now),
-  })));
-  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) {
-      const session = automationSessions.get(workspace);
-      if (session?.idleTimer) clearTimeout(session.idleTimer);
-      automationSessions.delete(workspace);
-      return;
-    }
-    setWorkspaceSession(workspace, {
-      windowId,
-      owned: true,
-      preferredTabId: null,
-    });
-  },
-  setSession: (workspace: string, session: { windowId: number; owned: boolean; preferredTabId: number | null }) => {
-    setWorkspaceSession(workspace, session);
-  },
-};