@jackwener/opencli 1.0.3 → 1.0.4

package/dist/browser/dom-helpers.js

@@ -0,0 +1,109 @@
+/**
+ * Shared DOM operation JS generators.
+ *
+ * Used by both Page (daemon mode) and CDPPage (direct CDP mode)
+ * to eliminate code duplication for click, type, press, wait, scroll, etc.
+ */
+/** Generate JS to click an element by ref */
+export function clickJs(ref) {
+    const safeRef = JSON.stringify(ref);
+    return `
+    (() => {
+      const ref = ${safeRef};
+      const el = document.querySelector('[data-ref="' + ref + '"]')
+        || document.querySelectorAll('a, button, input, [role="button"], [tabindex]')[parseInt(ref, 10) || 0];
+      if (!el) throw new Error('Element not found: ' + ref);
+      el.scrollIntoView({ behavior: 'instant', block: 'center' });
+      el.click();
+      return 'clicked';
+    })()
+  `;
+}
+/** Generate JS to type text into an element by ref */
+export function typeTextJs(ref, text) {
+    const safeRef = JSON.stringify(ref);
+    const safeText = JSON.stringify(text);
+    return `
+    (() => {
+      const ref = ${safeRef};
+      const el = document.querySelector('[data-ref="' + ref + '"]')
+        || document.querySelectorAll('input, textarea, [contenteditable]')[parseInt(ref, 10) || 0];
+      if (!el) throw new Error('Element not found: ' + ref);
+      el.focus();
+      el.value = ${safeText};
+      el.dispatchEvent(new Event('input', { bubbles: true }));
+      el.dispatchEvent(new Event('change', { bubbles: true }));
+      return 'typed';
+    })()
+  `;
+}
+/** Generate JS to press a keyboard key */
+export function pressKeyJs(key) {
+    return `
+    (() => {
+      const el = document.activeElement || document.body;
+      el.dispatchEvent(new KeyboardEvent('keydown', { key: ${JSON.stringify(key)}, bubbles: true }));
+      el.dispatchEvent(new KeyboardEvent('keyup', { key: ${JSON.stringify(key)}, bubbles: true }));
+      return 'pressed';
+    })()
+  `;
+}
+/** Generate JS to wait for text to appear in the page */
+export function waitForTextJs(text, timeoutMs) {
+    return `
+    new Promise((resolve, reject) => {
+      const deadline = Date.now() + ${timeoutMs};
+      const check = () => {
+        if (document.body.innerText.includes(${JSON.stringify(text)})) return resolve('found');
+        if (Date.now() > deadline) return reject(new Error('Text not found: ' + ${JSON.stringify(text)}));
+        setTimeout(check, 200);
+      };
+      check();
+    })
+  `;
+}
+/** Generate JS for scroll */
+export function scrollJs(direction, amount) {
+    const dx = direction === 'left' ? -amount : direction === 'right' ? amount : 0;
+    const dy = direction === 'up' ? -amount : direction === 'down' ? amount : 0;
+    return `window.scrollBy(${dx}, ${dy})`;
+}
+/** Generate JS for auto-scroll with lazy-load detection */
+export function autoScrollJs(times, delayMs) {
+    return `
+    (async () => {
+      for (let i = 0; i < ${times}; i++) {
+        const lastHeight = document.body.scrollHeight;
+        window.scrollTo(0, lastHeight);
+        await new Promise(resolve => {
+          let timeoutId;
+          const observer = new MutationObserver(() => {
+            if (document.body.scrollHeight > lastHeight) {
+              clearTimeout(timeoutId);
+              observer.disconnect();
+              setTimeout(resolve, 100);
+            }
+          });
+          observer.observe(document.body, { childList: true, subtree: true });
+          timeoutId = setTimeout(() => { observer.disconnect(); resolve(null); }, ${delayMs});
+        });
+      }
+    })()
+  `;
+}
+/** Generate JS to read performance resource entries as network requests */
+export function networkRequestsJs(includeStatic) {
+    return `
+    (() => {
+      const entries = performance.getEntriesByType('resource');
+      return entries
+        ${includeStatic ? '' : '.filter(e => !["img", "font", "css", "script"].some(t => e.initiatorType === t))'}
+        .map(e => ({
+          url: e.name,
+          type: e.initiatorType,
+          duration: Math.round(e.duration),
+          size: e.transferSize || 0,
+        }));
+    })()
+  `;
+}

package/dist/browser/mcp.d.ts

@@ -13,6 +13,7 @@ export declare class BrowserBridge {
     get state(): BrowserBridgeState;
     connect(opts?: {
         timeout?: number;
+        workspace?: string;
     }): Promise<IPage>;
     close(): Promise<void>;
     private _ensureDaemon;

package/dist/browser/mcp.js

@@ -29,8 +29,8 @@ export class BrowserBridge {
             throw new Error('Session is closed');
         this._state = 'connecting';
         try {
-            await this._ensureDaemon();
-            this._page = new Page();
+            await this._ensureDaemon(opts.timeout);
+            this._page = new Page(opts.workspace);
             this._state = 'connected';
             return this._page;
         }
@@ -48,9 +48,14 @@ export class BrowserBridge {
         this._page = null;
         this._state = 'closed';
     }
-    async _ensureDaemon() {
-        if (await isDaemonRunning())
+    async _ensureDaemon(timeoutSeconds) {
+        const timeoutMs = Math.max(1, timeoutSeconds ?? Math.ceil(DAEMON_SPAWN_TIMEOUT / 1000)) * 1000;
+        if (await isExtensionConnected())
             return;
+        if (await isDaemonRunning()) {
+            throw new Error('Daemon is running but the Browser Extension is not connected.\n' +
+                'Please install and enable the opencli Browser Bridge extension in Chrome.');
+        }
         // Find daemon relative to this file — works for both:
         //   npx tsx src/main.ts  → src/browser/mcp.ts  → src/daemon.ts
         //   node dist/main.js    → dist/browser/mcp.js → dist/daemon.js
@@ -75,7 +80,7 @@ export class BrowserBridge {
         });
         this._daemonProc.unref();
         // Wait for daemon to be ready AND extension to connect
-        const deadline = Date.now() + DAEMON_SPAWN_TIMEOUT;
+        const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
             await new Promise(resolve => setTimeout(resolve, 300));
             if (await isExtensionConnected())

package/dist/browser/page.d.ts

@@ -14,14 +14,21 @@ import type { IPage } from '../types.js';
  * Page — implements IPage by talking to the daemon via HTTP.
  */
 export declare class Page implements IPage {
+    private readonly workspace;
+    constructor(workspace?: string);
     /** Active tab ID, set after navigate and used in all subsequent commands */
     private _tabId;
     /** Helper: spread tabId into command params if we have one */
     private _tabOpt;
+    private _workspaceOpt;
     goto(url: string): Promise<void>;
     /** Close the automation window in the extension */
     closeWindow(): Promise<void>;
     evaluate(js: string): Promise<any>;
+    getCookies(opts?: {
+        domain?: string;
+        url?: string;
+    }): Promise<any[]>;
     snapshot(opts?: {
         interactive?: boolean;
         compact?: boolean;

package/dist/browser/page.js

@@ -12,19 +12,28 @@
 import { formatSnapshot } from '../snapshotFormatter.js';
 import { sendCommand } from './daemon-client.js';
 import { wrapForEval } from './utils.js';
+import { clickJs, typeTextJs, pressKeyJs, waitForTextJs, scrollJs, autoScrollJs, networkRequestsJs, } from './dom-helpers.js';
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
  */
 export class Page {
+    workspace;
+    constructor(workspace = 'default') {
+        this.workspace = workspace;
+    }
     /** Active tab ID, set after navigate and used in all subsequent commands */
     _tabId;
     /** Helper: spread tabId into command params if we have one */
     _tabOpt() {
         return this._tabId !== undefined ? { tabId: this._tabId } : {};
     }
+    _workspaceOpt() {
+        return { workspace: this.workspace };
+    }
     async goto(url) {
         const result = await sendCommand('navigate', {
             url,
+            ...this._workspaceOpt(),
             ...this._tabOpt(),
         });
         // Remember the tabId for subsequent exec calls
@@ -35,7 +44,7 @@ export class Page {
     /** Close the automation window in the extension */
     async closeWindow() {
         try {
-            await sendCommand('close-window', {});
+            await sendCommand('close-window', { ...this._workspaceOpt() });
         }
         catch {
             // Window may already be closed or daemon may be down
@@ -43,7 +52,11 @@ export class Page {
     }
     async evaluate(js) {
         const code = wrapForEval(js);
-        return sendCommand('exec', { code, ...this._tabOpt() });
+        return sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+    }
+    async getCookies(opts = {}) {
+        const result = await sendCommand('cookies', { ...this._workspaceOpt(), ...opts });
+        return Array.isArray(result) ? result : [];
     }
     async snapshot(opts = {}) {
         const maxDepth = Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200));
@@ -74,7 +87,7 @@ export class Page {
         return buildTree(document.body, 0);
       })()
     `;
-        const raw = await sendCommand('exec', { code, ...this._tabOpt() });
+        const raw = await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
         if (opts.raw)
             return raw;
         if (typeof raw === 'string')
@@ -82,48 +95,16 @@ export class Page {
         return raw;
     }
     async click(ref) {
-        const safeRef = JSON.stringify(ref);
-        const code = `
-      (() => {
-        const ref = ${safeRef};
-        const el = document.querySelector('[data-ref="' + ref + '"]')
-          || document.querySelectorAll('a, button, input, [role="button"], [tabindex]')[parseInt(ref, 10) || 0];
-        if (!el) throw new Error('Element not found: ' + ref);
-        el.scrollIntoView({ behavior: 'instant', block: 'center' });
-        el.click();
-        return 'clicked';
-      })()
-    `;
-        await sendCommand('exec', { code, ...this._tabOpt() });
+        const code = clickJs(ref);
+        await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
     }
     async typeText(ref, text) {
-        const safeRef = JSON.stringify(ref);
-        const safeText = JSON.stringify(text);
-        const code = `
-      (() => {
-        const ref = ${safeRef};
-        const el = document.querySelector('[data-ref="' + ref + '"]')
-          || document.querySelectorAll('input, textarea, [contenteditable]')[parseInt(ref, 10) || 0];
-        if (!el) throw new Error('Element not found: ' + ref);
-        el.focus();
-        el.value = ${safeText};
-        el.dispatchEvent(new Event('input', { bubbles: true }));
-        el.dispatchEvent(new Event('change', { bubbles: true }));
-        return 'typed';
-      })()
-    `;
-        await sendCommand('exec', { code, ...this._tabOpt() });
+        const code = typeTextJs(ref, text);
+        await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
     }
     async pressKey(key) {
-        const code = `
-      (() => {
-        const el = document.activeElement || document.body;
-        el.dispatchEvent(new KeyboardEvent('keydown', { key: ${JSON.stringify(key)}, bubbles: true }));
-        el.dispatchEvent(new KeyboardEvent('keyup', { key: ${JSON.stringify(key)}, bubbles: true }));
-        return 'pressed';
-      })()
-    `;
-        await sendCommand('exec', { code, ...this._tabOpt() });
+        const code = pressKeyJs(key);
+        await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
     }
     async wait(options) {
         if (typeof options === 'number') {
@@ -136,47 +117,25 @@ export class Page {
         }
         if (options.text) {
             const timeout = (options.timeout ?? 30) * 1000;
-            const code = `
-        new Promise((resolve, reject) => {
-          const deadline = Date.now() + ${timeout};
-          const check = () => {
-            if (document.body.innerText.includes(${JSON.stringify(options.text)})) return resolve('found');
-            if (Date.now() > deadline) return reject(new Error('Text not found: ' + ${JSON.stringify(options.text)}));
-            setTimeout(check, 200);
-          };
-          check();
-        })
-      `;
-            await sendCommand('exec', { code, ...this._tabOpt() });
+            const code = waitForTextJs(options.text, timeout);
+            await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
         }
     }
     async tabs() {
-        return sendCommand('tabs', { op: 'list' });
+        return sendCommand('tabs', { op: 'list', ...this._workspaceOpt() });
     }
     async closeTab(index) {
-        await sendCommand('tabs', { op: 'close', ...(index !== undefined ? { index } : {}) });
+        await sendCommand('tabs', { op: 'close', ...this._workspaceOpt(), ...(index !== undefined ? { index } : {}) });
     }
     async newTab() {
-        await sendCommand('tabs', { op: 'new' });
+        await sendCommand('tabs', { op: 'new', ...this._workspaceOpt() });
     }
     async selectTab(index) {
-        await sendCommand('tabs', { op: 'select', index });
+        await sendCommand('tabs', { op: 'select', index, ...this._workspaceOpt() });
     }
     async networkRequests(includeStatic = false) {
-        const code = `
-      (() => {
-        const entries = performance.getEntriesByType('resource');
-        return entries
-          ${includeStatic ? '' : '.filter(e => !["img", "font", "css", "script"].some(t => e.initiatorType === t))'}
-          .map(e => ({
-            url: e.name,
-            type: e.initiatorType,
-            duration: Math.round(e.duration),
-            size: e.transferSize || 0,
-          }));
-      })()
-    `;
-        return sendCommand('exec', { code, ...this._tabOpt() });
+        const code = networkRequestsJs(includeStatic);
+        return sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
     }
     /**
      * Console messages are not available in lightweight daemon mode.
@@ -195,6 +154,7 @@ export class Page {
      */
     async screenshot(options = {}) {
         const base64 = await sendCommand('screenshot', {
+            ...this._workspaceOpt(),
             format: options.format,
             quality: options.quality,
             fullPage: options.fullPage,
@@ -204,43 +164,20 @@ export class Page {
             const fs = await import('node:fs');
             const path = await import('node:path');
             const dir = path.dirname(options.path);
-            fs.mkdirSync(dir, { recursive: true });
-            fs.writeFileSync(options.path, Buffer.from(base64, 'base64'));
+            await fs.promises.mkdir(dir, { recursive: true });
+            await fs.promises.writeFile(options.path, Buffer.from(base64, 'base64'));
         }
         return base64;
     }
     async scroll(direction = 'down', amount = 500) {
-        const dx = direction === 'left' ? -amount : direction === 'right' ? amount : 0;
-        const dy = direction === 'up' ? -amount : direction === 'down' ? amount : 0;
-        await sendCommand('exec', {
-            code: `window.scrollBy(${dx}, ${dy})`,
-            ...this._tabOpt(),
-        });
+        const code = scrollJs(direction, amount);
+        await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
     }
     async autoScroll(options = {}) {
         const times = options.times ?? 3;
         const delayMs = options.delayMs ?? 2000;
-        const code = `
-      (async () => {
-        for (let i = 0; i < ${times}; i++) {
-          const lastHeight = document.body.scrollHeight;
-          window.scrollTo(0, lastHeight);
-          await new Promise(resolve => {
-            let timeoutId;
-            const observer = new MutationObserver(() => {
-              if (document.body.scrollHeight > lastHeight) {
-                clearTimeout(timeoutId);
-                observer.disconnect();
-                setTimeout(resolve, 100);
-              }
-            });
-            observer.observe(document.body, { childList: true, subtree: true });
-            timeoutId = setTimeout(() => { observer.disconnect(); resolve(null); }, ${delayMs});
-          });
-        }
-      })()
-    `;
-        await sendCommand('exec', { code, ...this._tabOpt() });
+        const code = autoScrollJs(times, delayMs);
+        await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
     }
     async installInterceptor(pattern) {
         const { generateInterceptorJs } = await import('../interceptor.js');

package/dist/browser.test.js

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi } from 'vitest';
 import { BrowserBridge, __test__ } from './browser/index.js';
+import * as daemonClient from './browser/daemon-client.js';
 describe('browser helpers', () => {
     it('extracts tab entries from string snapshots', () => {
         const entries = __test__.extractTabEntries('Tab 0 https://example.com\nTab 1 Chrome Extension');
@@ -94,4 +95,10 @@ describe('BrowserBridge state', () => {
         mcp._state = 'closing';
         await expect(mcp.connect()).rejects.toThrow('Session is closing');
     });
+    it('fails fast when daemon is running but extension is disconnected', async () => {
+        vi.spyOn(daemonClient, 'isExtensionConnected').mockResolvedValue(false);
+        vi.spyOn(daemonClient, 'isDaemonRunning').mockResolvedValue(true);
+        const mcp = new BrowserBridge();
+        await expect(mcp.connect()).rejects.toThrow('Browser Extension is not connected');
+    });
 });

package/dist/build-manifest.js

@@ -73,7 +73,7 @@ export function parseTsArgsBlock(argsBlock) {
     const args = [];
     let cursor = 0;
     while (cursor < argsBlock.length) {
-        const nameMatch = argsBlock.slice(cursor).match(/\{\s*name\s*:\s*['"`](\w+)['"`]/);
+        const nameMatch = argsBlock.slice(cursor).match(/\{\s*name\s*:\s*['"`]([^'"`]+)['"`]/);
         if (!nameMatch || nameMatch.index === undefined)
             break;
         const objectStart = cursor + nameMatch.index;
@@ -186,6 +186,8 @@ function scanTs(filePath, site) {
         const browserMatch = src.match(/browser\s*:\s*(true|false)/);
         if (browserMatch)
             entry.browser = browserMatch[1] === 'true';
+        else
+            entry.browser = entry.strategy !== 'public';
         // Extract columns
         const colMatch = src.match(/columns\s*:\s*\[([^\]]*)\]/);
         if (colMatch) {

package/dist/build-manifest.test.js

@@ -23,4 +23,38 @@ describe('parseTsArgsBlock', () => {
             },
         ]);
     });
+    it('keeps hyphenated arg names from TS adapters', () => {
+        const args = parseTsArgsBlock(`
+      {
+        name: 'tweet-url',
+        help: 'Single tweet URL to download',
+      },
+      {
+        name: 'download-images',
+        type: 'boolean',
+        default: false,
+        help: 'Download images locally',
+      },
+    `);
+        expect(args).toEqual([
+            {
+                name: 'tweet-url',
+                type: 'str',
+                default: undefined,
+                required: false,
+                positional: undefined,
+                help: 'Single tweet URL to download',
+                choices: undefined,
+            },
+            {
+                name: 'download-images',
+                type: 'boolean',
+                default: false,
+                required: false,
+                positional: undefined,
+                help: 'Download images locally',
+                choices: undefined,
+            },
+        ]);
+    });
 });

package/dist/capabilityRouting.d.ts

@@ -0,0 +1,2 @@
+import { type CliCommand } from './registry.js';
+export declare function shouldUseBrowserSession(cmd: CliCommand): boolean;

package/dist/capabilityRouting.js

@@ -0,0 +1,30 @@
+import { Strategy } from './registry.js';
+const BROWSER_ONLY_STEPS = new Set([
+    'navigate',
+    'click',
+    'type',
+    'wait',
+    'press',
+    'snapshot',
+    'evaluate',
+    'intercept',
+    'tap',
+]);
+function pipelineNeedsBrowserSession(pipeline) {
+    return pipeline.some((step) => {
+        if (!step || typeof step !== 'object')
+            return false;
+        return Object.keys(step).some((op) => BROWSER_ONLY_STEPS.has(op));
+    });
+}
+export function shouldUseBrowserSession(cmd) {
+    if (!cmd.browser)
+        return false;
+    if (cmd.func)
+        return true;
+    if (!cmd.pipeline || cmd.pipeline.length === 0)
+        return true;
+    if (cmd.strategy !== Strategy.PUBLIC)
+        return true;
+    return pipelineNeedsBrowserSession(cmd.pipeline);
+}

package/dist/capabilityRouting.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/capabilityRouting.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import { Strategy } from './registry.js';
+import { shouldUseBrowserSession } from './capabilityRouting.js';
+function makeCmd(partial) {
+    return {
+        site: 'test',
+        name: 'command',
+        description: '',
+        args: [],
+        ...partial,
+    };
+}
+describe('shouldUseBrowserSession', () => {
+    it('skips browser session for public fetch-only pipelines', () => {
+        expect(shouldUseBrowserSession(makeCmd({
+            browser: true,
+            strategy: Strategy.PUBLIC,
+            pipeline: [{ fetch: 'https://example.com/api' }, { select: 'items' }],
+        }))).toBe(false);
+    });
+    it('keeps browser session for public pipelines with browser-only steps', () => {
+        expect(shouldUseBrowserSession(makeCmd({
+            browser: true,
+            strategy: Strategy.PUBLIC,
+            pipeline: [{ navigate: 'https://example.com' }, { evaluate: '() => []' }],
+        }))).toBe(true);
+    });
+    it('keeps browser session for non-public strategies', () => {
+        expect(shouldUseBrowserSession(makeCmd({
+            browser: true,
+            strategy: Strategy.COOKIE,
+            pipeline: [{ fetch: 'https://example.com/api' }],
+        }))).toBe(true);
+    });
+    it('keeps browser session for function adapters', () => {
+        expect(shouldUseBrowserSession(makeCmd({
+            browser: true,
+            strategy: Strategy.PUBLIC,
+            func: async () => [],
+        }))).toBe(true);
+    });
+});

package/dist/chaoxing.test.js

@@ -1,16 +1,23 @@
 import { describe, expect, it } from 'vitest';
 import { formatTimestamp, workStatusLabel } from './chaoxing.js';
+function localDatePrefixFromMillis(ts) {
+    const d = new Date(ts);
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, '0');
+    const dd = String(d.getDate()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd}`;
+}
 describe('formatTimestamp', () => {
     it('formats millisecond timestamp', () => {
-        // 2026-01-15 08:30 UTC+8
         const ts = new Date('2026-01-15T00:30:00Z').getTime();
         const result = formatTimestamp(ts);
-        expect(result).toMatch(/2026-01-15/);
+        expect(result).toMatch(new RegExp(`^${localDatePrefixFromMillis(ts)}\\s`));
     });
     it('formats second timestamp', () => {
-        const ts = Math.floor(new Date('2026-06-01T12:00:00Z').getTime() / 1000);
+        const millis = new Date('2026-06-01T12:00:00Z').getTime();
+        const ts = Math.floor(millis / 1000);
         const result = formatTimestamp(ts);
-        expect(result).toMatch(/2026-06-01/);
+        expect(result).toMatch(new RegExp(`^${localDatePrefixFromMillis(millis)}\\s`));
     });
     it('returns empty for null/undefined/0', () => {
         expect(formatTimestamp(null)).toBe('');