@jackwener/opencli 1.0.1 → 1.0.4

package/extension/src/background.test.ts

@@ -0,0 +1,151 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+type Listener<T extends (...args: any[]) => void> = { addListener: (fn: T) => void };
+
+type MockTab = {
+  id: number;
+  windowId: number;
+  url?: string;
+  title?: string;
+  active?: boolean;
+  status?: string;
+};
+
+class MockWebSocket {
+  static OPEN = 1;
+  static CONNECTING = 0;
+  readyState = MockWebSocket.CONNECTING;
+  onopen: (() => void) | null = null;
+  onmessage: ((event: { data: string }) => void) | null = null;
+  onclose: (() => void) | null = null;
+  onerror: (() => void) | null = null;
+
+  constructor(_url: string) {}
+  send(_data: string): void {}
+  close(): void {
+    this.onclose?.();
+  }
+}
+
+function createChromeMock() {
+  let nextTabId = 10;
+  const tabs: MockTab[] = [
+    { id: 1, windowId: 1, url: 'https://automation.example', title: 'automation', active: true, status: 'complete' },
+    { id: 2, windowId: 2, url: 'https://user.example', title: 'user', active: true, status: 'complete' },
+    { 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 create = vi.fn(async ({ windowId, url, active }: { windowId?: number; url?: string; active?: boolean }) => {
+    const tab: MockTab = {
+      id: nextTabId++,
+      windowId: windowId ?? 999,
+      url,
+      title: url ?? 'blank',
+      active: !!active,
+      status: 'complete',
+    };
+    tabs.push(tab);
+    return tab;
+  });
+  const update = vi.fn(async (tabId: number, updates: { active?: boolean; url?: string }) => {
+    const tab = tabs.find((entry) => entry.id === tabId);
+    if (!tab) throw new Error(`Unknown tab ${tabId}`);
+    if (updates.active !== undefined) tab.active = updates.active;
+    if (updates.url !== undefined) tab.url = updates.url;
+    return tab;
+  });
+
+  const chrome = {
+    tabs: {
+      query,
+      create,
+      update,
+      remove: vi.fn(async (_tabId: number) => {}),
+      get: vi.fn(async (tabId: number) => {
+        const tab = tabs.find((entry) => entry.id === tabId);
+        if (!tab) throw new Error(`Unknown tab ${tabId}`);
+        return tab;
+      }),
+      onUpdated: { addListener: vi.fn(), removeListener: vi.fn() } as Listener<(id: number, info: chrome.tabs.TabChangeInfo) => void>,
+    },
+    windows: {
+      get: vi.fn(async (windowId: number) => ({ id: windowId })),
+      create: vi.fn(async ({ url, focused, width, height, type }: any) => ({ id: 1, url, focused, width, height, type })),
+      remove: vi.fn(async (_windowId: number) => {}),
+      onRemoved: { addListener: vi.fn() } as Listener<(windowId: number) => void>,
+    },
+    alarms: {
+      create: vi.fn(),
+      onAlarm: { addListener: vi.fn() } as Listener<(alarm: { name: string }) => void>,
+    },
+    runtime: {
+      onInstalled: { addListener: vi.fn() } as Listener<() => void>,
+      onStartup: { addListener: vi.fn() } as Listener<() => void>,
+    },
+    cookies: {
+      getAll: vi.fn(async () => []),
+    },
+  };
+
+  return { chrome, tabs, query, create, update };
+}
+
+describe('background tab isolation', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.stubGlobal('WebSocket', MockWebSocket);
+  });
+
+  it('lists only automation-window web tabs', async () => {
+    const { chrome } = createChromeMock();
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    mod.__test__.setAutomationWindowId('site:twitter', 1);
+
+    const result = await mod.__test__.handleTabs({ id: '1', action: 'tabs', op: 'list', workspace: 'site:twitter' }, 'site:twitter');
+
+    expect(result.ok).toBe(true);
+    expect(result.data).toEqual([
+      {
+        index: 0,
+        tabId: 1,
+        url: 'https://automation.example',
+        title: 'automation',
+        active: true,
+      },
+    ]);
+  });
+
+  it('creates new tabs inside the automation window', async () => {
+    const { chrome, create } = createChromeMock();
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    mod.__test__.setAutomationWindowId('site:twitter', 1);
+
+    const result = await mod.__test__.handleTabs({ id: '2', action: 'tabs', op: 'new', url: 'https://new.example', workspace: 'site:twitter' }, 'site:twitter');
+
+    expect(result.ok).toBe(true);
+    expect(create).toHaveBeenCalledWith({ windowId: 1, url: 'https://new.example', active: true });
+  });
+
+  it('reports sessions per workspace', async () => {
+    const { chrome } = createChromeMock();
+    vi.stubGlobal('chrome', chrome);
+
+    const mod = await import('./background');
+    mod.__test__.setAutomationWindowId('site:twitter', 1);
+    mod.__test__.setAutomationWindowId('site:zhihu', 2);
+
+    const result = await mod.__test__.handleSessions({ id: '3', action: 'sessions' });
+    expect(result.ok).toBe(true);
+    expect(result.data).toEqual(expect.arrayContaining([
+      expect.objectContaining({ workspace: 'site:twitter', windowId: 1 }),
+      expect.objectContaining({ workspace: 'site:zhihu', windowId: 2 }),
+    ]));
+  });
+});

package/extension/src/background.ts

@@ -1,5 +1,5 @@
 /**
- * opencli Browser Bridge — Service Worker (background script).
+ * OpenCLI — Service Worker (background script).
  *
  * Connects to the opencli daemon via WebSocket, receives commands,
  * dispatches them to Chrome APIs (debugger/tabs/cookies), returns results.
@@ -90,36 +90,48 @@ function scheduleReconnect(): void {
 // user's active browsing session is never touched.
 // The window auto-closes after 30s of idle (no commands).
 
-let automationWindowId: number | null = null;
-let windowIdleTimer: ReturnType<typeof setTimeout> | null = null;
+type AutomationSession = {
+  windowId: number;
+  idleTimer: ReturnType<typeof setTimeout> | null;
+  idleDeadlineAt: number;
+};
+
+const automationSessions = new Map<string, AutomationSession>();
 const WINDOW_IDLE_TIMEOUT = 30000; // 30s
 
-function resetWindowIdleTimer(): void {
-  if (windowIdleTimer) clearTimeout(windowIdleTimer);
-  windowIdleTimer = setTimeout(async () => {
-    if (automationWindowId !== null) {
-      try {
-        await chrome.windows.remove(automationWindowId);
-        console.log(`[opencli] Automation window ${automationWindowId} closed (idle timeout)`);
-      } catch {
-        // Already gone
-      }
-      automationWindowId = null;
+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;
+    try {
+      await chrome.windows.remove(current.windowId);
+      console.log(`[opencli] Automation window ${current.windowId} (${workspace}) closed (idle timeout)`);
+    } catch {
+      // Already gone
     }
-    windowIdleTimer = null;
+    automationSessions.delete(workspace);
   }, WINDOW_IDLE_TIMEOUT);
 }
 
 /** Get or create the dedicated automation window. */
-async function getAutomationWindow(): Promise<number> {
+async function getAutomationWindow(workspace: string): Promise<number> {
   // Check if our window is still alive
-  if (automationWindowId !== null) {
+  const existing = automationSessions.get(workspace);
+  if (existing) {
     try {
-      await chrome.windows.get(automationWindowId);
-      return automationWindowId;
+      await chrome.windows.get(existing.windowId);
+      return existing.windowId;
     } catch {
       // Window was closed by user
-      automationWindowId = null;
+      automationSessions.delete(workspace);
     }
   }
 
@@ -131,17 +143,25 @@ async function getAutomationWindow(): Promise<number> {
     height: 900,
     type: 'normal',
   });
-  automationWindowId = win.id!;
-  console.log(`[opencli] Created automation window ${automationWindowId}`);
-  return automationWindowId;
+  const session: AutomationSession = {
+    windowId: win.id!,
+    idleTimer: null,
+    idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
+  };
+  automationSessions.set(workspace, session);
+  console.log(`[opencli] Created automation window ${session.windowId} (${workspace})`);
+  resetWindowIdleTimer(workspace);
+  return session.windowId;
 }
 
 // Clean up when the automation window is closed
 chrome.windows.onRemoved.addListener((windowId) => {
-  if (windowId === automationWindowId) {
-    console.log('[opencli] Automation window closed');
-    automationWindowId = null;
-    if (windowIdleTimer) { clearTimeout(windowIdleTimer); windowIdleTimer = null; }
+  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);
+    }
   }
 });
 
@@ -155,7 +175,7 @@ function initialize(): void {
   chrome.alarms.create('keepalive', { periodInMinutes: 0.4 }); // ~24 seconds
   executor.registerListeners();
   connect();
-  console.log('[opencli] Browser Bridge extension initialized');
+  console.log('[opencli] OpenCLI extension initialized');
 }
 
 chrome.runtime.onInstalled.addListener(() => {
@@ -173,22 +193,25 @@ chrome.alarms.onAlarm.addListener((alarm) => {
 // ─── 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();
+  resetWindowIdleTimer(workspace);
   try {
     switch (cmd.action) {
       case 'exec':
-        return await handleExec(cmd);
+        return await handleExec(cmd, workspace);
       case 'navigate':
-        return await handleNavigate(cmd);
+        return await handleNavigate(cmd, workspace);
       case 'tabs':
-        return await handleTabs(cmd);
+        return await handleTabs(cmd, workspace);
       case 'cookies':
         return await handleCookies(cmd);
       case 'screenshot':
-        return await handleScreenshot(cmd);
+        return await handleScreenshot(cmd, workspace);
       case 'close-window':
-        return await handleCloseWindow(cmd);
+        return await handleCloseWindow(cmd, workspace);
+      case 'sessions':
+        return await handleSessions(cmd);
       default:
         return { id: cmd.id, ok: false, error: `Unknown action: ${cmd.action}` };
     }
@@ -214,11 +237,11 @@ function isWebUrl(url?: string): boolean {
  * If explicit tabId is given, use that directly.
  * Otherwise, find or create a tab in the dedicated automation window.
  */
-async function resolveTabId(tabId?: number): Promise<number> {
+async function resolveTabId(tabId: number | undefined, workspace: string): Promise<number> {
   if (tabId !== undefined) return tabId;
 
   // Get (or create) the automation window
-  const windowId = await getAutomationWindow();
+  const windowId = await getAutomationWindow(workspace);
 
   // Find the active tab in our automation window
   const tabs = await chrome.tabs.query({ windowId });
@@ -234,9 +257,25 @@ async function resolveTabId(tabId?: number): Promise<number> {
   return newTab.id;
 }
 
-async function handleExec(cmd: Command): Promise<Result> {
+async function listAutomationTabs(workspace: string): Promise<chrome.tabs.Tab[]> {
+  const session = automationSessions.get(workspace);
+  if (!session) 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) => isWebUrl(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);
+  const tabId = await resolveTabId(cmd.tabId, workspace);
   try {
     const data = await executor.evaluateAsync(tabId, cmd.code);
     return { id: cmd.id, ok: true, data };
@@ -245,9 +284,9 @@ async function handleExec(cmd: Command): Promise<Result> {
   }
 }
 
-async function handleNavigate(cmd: Command): Promise<Result> {
+async function handleNavigate(cmd: Command, workspace: string): Promise<Result> {
   if (!cmd.url) return { id: cmd.id, ok: false, error: 'Missing url' };
-  const tabId = await resolveTabId(cmd.tabId);
+  const tabId = await resolveTabId(cmd.tabId, workspace);
   await chrome.tabs.update(tabId, { url: cmd.url });
 
   // Wait for page to finish loading, checking current status first to avoid race
@@ -275,12 +314,11 @@ async function handleNavigate(cmd: Command): Promise<Result> {
   return { id: cmd.id, ok: true, data: { title: tab.title, url: tab.url, tabId } };
 }
 
-async function handleTabs(cmd: Command): Promise<Result> {
+async function handleTabs(cmd: Command, workspace: string): Promise<Result> {
   switch (cmd.op) {
     case 'list': {
-      const tabs = await chrome.tabs.query({});
+      const tabs = await listAutomationWebTabs(workspace);
       const data = tabs
-        .filter((t) => isWebUrl(t.url))
         .map((t, i) => ({
           index: i,
           tabId: t.id,
@@ -291,19 +329,20 @@ async function handleTabs(cmd: Command): Promise<Result> {
       return { id: cmd.id, ok: true, data };
     }
     case 'new': {
-      const tab = await chrome.tabs.create({ url: cmd.url, active: true });
+      const windowId = await getAutomationWindow(workspace);
+      const tab = await chrome.tabs.create({ windowId, url: cmd.url ?? 'about:blank', active: true });
       return { id: cmd.id, ok: true, data: { tabId: tab.id, url: tab.url } };
     }
     case 'close': {
       if (cmd.index !== undefined) {
-        const tabs = await chrome.tabs.query({});
+        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);
         executor.detach(target.id);
         return { id: cmd.id, ok: true, data: { closed: target.id } };
       }
-      const tabId = await resolveTabId(cmd.tabId);
+      const tabId = await resolveTabId(cmd.tabId, workspace);
       await chrome.tabs.remove(tabId);
       executor.detach(tabId);
       return { id: cmd.id, ok: true, data: { closed: tabId } };
@@ -315,7 +354,7 @@ async function handleTabs(cmd: Command): Promise<Result> {
         await chrome.tabs.update(cmd.tabId, { active: true });
         return { id: cmd.id, ok: true, data: { selected: cmd.tabId } };
       }
-      const tabs = await chrome.tabs.query({});
+      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 });
@@ -343,8 +382,8 @@ async function handleCookies(cmd: Command): Promise<Result> {
   return { id: cmd.id, ok: true, data };
 }
 
-async function handleScreenshot(cmd: Command): Promise<Result> {
-  const tabId = await resolveTabId(cmd.tabId);
+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,
@@ -357,14 +396,46 @@ async function handleScreenshot(cmd: Command): Promise<Result> {
   }
 }
 
-async function handleCloseWindow(cmd: Command): Promise<Result> {
-  if (automationWindowId !== null) {
+async function handleCloseWindow(cmd: Command, workspace: string): Promise<Result> {
+  const session = automationSessions.get(workspace);
+  if (session) {
     try {
-      await chrome.windows.remove(automationWindowId);
+      await chrome.windows.remove(session.windowId);
     } catch {
       // Window may already be closed
     }
-    automationWindowId = null;
+    if (session.idleTimer) clearTimeout(session.idleTimer);
+    automationSessions.delete(workspace);
   }
   return { id: cmd.id, ok: true, data: { closed: true } };
 }
+
+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) => isWebUrl(tab.url)).length,
+    idleMsRemaining: Math.max(0, session.idleDeadlineAt - now),
+  })));
+  return { id: cmd.id, ok: true, data };
+}
+
+export const __test__ = {
+  handleTabs,
+  handleSessions,
+  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;
+    }
+    automationSessions.set(workspace, {
+      windowId,
+      idleTimer: null,
+      idleDeadlineAt: Date.now() + WINDOW_IDLE_TIMEOUT,
+    });
+  },
+};

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';
+export type Action = 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions';
 
 export interface Command {
   /** Unique request ID */
@@ -16,6 +16,8 @@ export interface Command {
   tabId?: number;
   /** JS code to evaluate in page context (exec action) */
   code?: string;
+  /** Logical workspace for automation session reuse */
+  workspace?: string;
   /** URL to navigate to (navigate action) */
   url?: string;
   /** Sub-operation for tabs: list, new, close, select */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "publishConfig": {
     "access": "public"
   },
@@ -26,7 +26,10 @@
     "prepublishOnly": "npm run build",
     "test": "vitest run",
     "test:site": "node scripts/test-site.mjs",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs"
   },
   "keywords": [
     "cli",
@@ -49,10 +52,11 @@
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
-    "@types/ws": "^8.5.13",
     "@types/node": "^22.13.10",
+    "@types/ws": "^8.5.13",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",
+    "vitepress": "^1.6.4",
     "vitest": "^4.1.0"
   }
 }