@jackwener/opencli 1.0.1 → 1.0.4

package/src/browser/page.ts

@@ -13,11 +13,23 @@
 import { formatSnapshot } from '../snapshotFormatter.js';
 import type { IPage } from '../types.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 implements IPage {
+  constructor(private readonly workspace: string = 'default') {}
+
   /** Active tab ID, set after navigate and used in all subsequent commands */
   private _tabId: number | undefined;
 
@@ -26,9 +38,14 @@ export class Page implements IPage {
     return this._tabId !== undefined ? { tabId: this._tabId } : {};
   }
 
+  private _workspaceOpt(): { workspace: string } {
+    return { workspace: this.workspace };
+  }
+
   async goto(url: string): Promise<void> {
     const result = await sendCommand('navigate', {
       url,
+      ...this._workspaceOpt(),
       ...this._tabOpt(),
     }) as { tabId?: number };
     // Remember the tabId for subsequent exec calls
@@ -40,7 +57,7 @@ export class Page implements IPage {
   /** Close the automation window in the extension */
   async closeWindow(): Promise<void> {
     try {
-      await sendCommand('close-window', {});
+      await sendCommand('close-window', { ...this._workspaceOpt() });
     } catch {
       // Window may already be closed or daemon may be down
     }
@@ -48,7 +65,12 @@ export class Page implements IPage {
 
   async evaluate(js: string): Promise<any> {
     const code = wrapForEval(js);
-    return sendCommand('exec', { code, ...this._tabOpt() });
+    return sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+  }
+
+  async getCookies(opts: { domain?: string; url?: string } = {}): Promise<any[]> {
+    const result = await sendCommand('cookies', { ...this._workspaceOpt(), ...opts });
+    return Array.isArray(result) ? result : [];
   }
 
   async snapshot(opts: { interactive?: boolean; compact?: boolean; maxDepth?: number; raw?: boolean } = {}): Promise<any> {
@@ -80,57 +102,25 @@ export class Page implements IPage {
         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') return formatSnapshot(raw, opts);
     return raw;
   }
 
   async click(ref: string): Promise<void> {
-    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: string, text: string): Promise<void> {
-    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: string): Promise<void> {
-    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: number | { text?: string; time?: number; timeout?: number }): Promise<void> {
@@ -144,52 +134,30 @@ export class Page implements IPage {
     }
     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(): Promise<any> {
-    return sendCommand('tabs', { op: 'list' });
+    return sendCommand('tabs', { op: 'list', ...this._workspaceOpt() });
   }
 
   async closeTab(index?: number): Promise<void> {
-    await sendCommand('tabs', { op: 'close', ...(index !== undefined ? { index } : {}) });
+    await sendCommand('tabs', { op: 'close', ...this._workspaceOpt(), ...(index !== undefined ? { index } : {}) });
   }
 
   async newTab(): Promise<void> {
-    await sendCommand('tabs', { op: 'new' });
+    await sendCommand('tabs', { op: 'new', ...this._workspaceOpt() });
   }
 
   async selectTab(index: number): Promise<void> {
-    await sendCommand('tabs', { op: 'select', index });
+    await sendCommand('tabs', { op: 'select', index, ...this._workspaceOpt() });
   }
 
   async networkRequests(includeStatic: boolean = false): Promise<any> {
-    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() });
   }
 
   /**
@@ -215,6 +183,7 @@ export class Page implements IPage {
     path?: string;
   } = {}): Promise<string> {
     const base64 = await sendCommand('screenshot', {
+      ...this._workspaceOpt(),
       format: options.format,
       quality: options.quality,
       fullPage: options.fullPage,
@@ -225,46 +194,23 @@ export class Page implements IPage {
       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: string = 'down', amount: number = 500): Promise<void> {
-    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: { times?: number; delayMs?: number } = {}): Promise<void> {
     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: string): Promise<void> {
@@ -285,27 +231,4 @@ export class Page implements IPage {
   }
 }
 
-// ─── Helpers ─────────────────────────────────────────────────────────
-
-/**
- * Wrap JS code for CDP Runtime.evaluate:
- * - Already an IIFE `(...)()` → send as-is
- * - Arrow/function literal → wrap as IIFE `(code)()`
- * - `new Promise(...)` or raw expression → send as-is (expression)
- */
-function wrapForEval(js: string): string {
-  const code = js.trim();
-  if (!code) return 'undefined';
-
-  // Already an IIFE: `(async () => { ... })()` or `(function() {...})()`
-  if (/^\([\s\S]*\)\s*\(.*\)\s*$/.test(code)) return code;
-
-  // Arrow function: `() => ...` or `async () => ...`
-  if (/^(async\s+)?(\([^)]*\)|[A-Za-z_]\w*)\s*=>/.test(code)) return `(${code})()`;
-
-  // Function declaration: `function ...` or `async function ...`
-  if (/^(async\s+)?function[\s(]/.test(code)) return `(${code})()`;
-
-  // Everything else: bare expression, `new Promise(...)`, etc. → evaluate directly
-  return code;
-}
+// (End of file)

package/src/browser/utils.ts

@@ -0,0 +1,27 @@
+/**
+ * Utility functions for browser operations
+ */
+
+/**
+ * Wrap JS code for CDP Runtime.evaluate:
+ * - Already an IIFE `(...)()` → send as-is
+ * - Arrow/function literal → wrap as IIFE `(code)()`
+ * - `new Promise(...)` or raw expression → send as-is (expression)
+ */
+export function wrapForEval(js: string): string {
+  if (typeof js !== 'string') return 'undefined';
+  const code = js.trim();
+  if (!code) return 'undefined';
+
+  // Already an IIFE: `(async () => { ... })()` or `(function() {...})()`
+  if (/^\([\s\S]*\)\s*\(.*\)\s*$/.test(code)) return code;
+
+  // Arrow function: `() => ...` or `async () => ...`
+  if (/^(async\s+)?(\([^)]*\)|[A-Za-z_]\w*)\s*=>/.test(code)) return `(${code})()`;
+
+  // Function declaration: `function ...` or `async function ...`
+  if (/^(async\s+)?function[\s(]/.test(code)) return `(${code})()`;
+
+  // Everything else: bare expression, `new Promise(...)`, etc. → evaluate directly
+  return code;
+}

package/src/browser.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, 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', () => {
@@ -43,6 +44,52 @@ describe('browser helpers', () => {
   it('times out slow promises', async () => {
     await expect(__test__.withTimeoutMs(new Promise(() => {}), 10, 'timeout')).rejects.toThrow('timeout');
   });
+
+  it('prefers the real Electron app target over DevTools and blank pages', () => {
+    const target = __test__.selectCDPTarget([
+      {
+        type: 'page',
+        title: 'DevTools - localhost:9224',
+        url: 'devtools://devtools/bundled/inspector.html',
+        webSocketDebuggerUrl: 'ws://127.0.0.1:9224/devtools',
+      },
+      {
+        type: 'page',
+        title: '',
+        url: 'about:blank',
+        webSocketDebuggerUrl: 'ws://127.0.0.1:9224/blank',
+      },
+      {
+        type: 'app',
+        title: 'Antigravity',
+        url: 'http://localhost:3000/',
+        webSocketDebuggerUrl: 'ws://127.0.0.1:9224/app',
+      },
+    ]);
+
+    expect(target?.webSocketDebuggerUrl).toBe('ws://127.0.0.1:9224/app');
+  });
+
+  it('honors OPENCLI_CDP_TARGET when multiple inspectable targets exist', () => {
+    vi.stubEnv('OPENCLI_CDP_TARGET', 'codex');
+
+    const target = __test__.selectCDPTarget([
+      {
+        type: 'app',
+        title: 'Cursor',
+        url: 'http://localhost:3000/cursor',
+        webSocketDebuggerUrl: 'ws://127.0.0.1:9226/cursor',
+      },
+      {
+        type: 'app',
+        title: 'OpenAI Codex',
+        url: 'http://localhost:3000/codex',
+        webSocketDebuggerUrl: 'ws://127.0.0.1:9226/codex',
+      },
+    ]);
+
+    expect(target?.webSocketDebuggerUrl).toBe('ws://127.0.0.1:9226/codex');
+  });
 });
 
 describe('BrowserBridge state', () => {
@@ -76,4 +123,13 @@ describe('BrowserBridge state', () => {
 
     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/src/build-manifest.test.ts

@@ -25,4 +25,40 @@ 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/src/build-manifest.ts

@@ -114,7 +114,7 @@ export function parseTsArgsBlock(argsBlock: string): ManifestEntry['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;
@@ -231,6 +231,7 @@ function scanTs(filePath: string, site: string): ManifestEntry {
     // Extract browser: false (some adapters bypass browser entirely)
     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*\[([^\]]*)\]/);

package/src/capabilityRouting.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from 'vitest';
+import { Strategy, type CliCommand } from './registry.js';
+import { shouldUseBrowserSession } from './capabilityRouting.js';
+
+function makeCmd(partial: Partial<CliCommand>): CliCommand {
+  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/src/capabilityRouting.ts

@@ -0,0 +1,28 @@
+import { Strategy, type CliCommand } from './registry.js';
+
+const BROWSER_ONLY_STEPS = new Set([
+  'navigate',
+  'click',
+  'type',
+  'wait',
+  'press',
+  'snapshot',
+  'evaluate',
+  'intercept',
+  'tap',
+]);
+
+function pipelineNeedsBrowserSession(pipeline: Record<string, unknown>[]): boolean {
+  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: CliCommand): boolean {
+  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 as Record<string, unknown>[]);
+}

package/src/chaoxing.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import { formatTimestamp, workStatusLabel } from './chaoxing.js';
+
+function localDatePrefixFromMillis(ts: number): string {
+  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', () => {
+    const ts = new Date('2026-01-15T00:30:00Z').getTime();
+    const result = formatTimestamp(ts);
+    expect(result).toMatch(new RegExp(`^${localDatePrefixFromMillis(ts)}\\s`));
+  });
+
+  it('formats second timestamp', () => {
+    const millis = new Date('2026-06-01T12:00:00Z').getTime();
+    const ts = Math.floor(millis / 1000);
+    const result = formatTimestamp(ts);
+    expect(result).toMatch(new RegExp(`^${localDatePrefixFromMillis(millis)}\\s`));
+  });
+
+  it('returns empty for null/undefined/0', () => {
+    expect(formatTimestamp(null)).toBe('');
+    expect(formatTimestamp(undefined)).toBe('');
+    expect(formatTimestamp(0)).toBe('');
+    expect(formatTimestamp('')).toBe('');
+  });
+
+  it('passes through readable date strings', () => {
+    expect(formatTimestamp('2026-03-20 23:59')).toBe('2026-03-20 23:59');
+  });
+});
+
+describe('workStatusLabel', () => {
+  it('maps numeric status codes', () => {
+    expect(workStatusLabel(0)).toBe('未交');
+    expect(workStatusLabel(1)).toBe('已交');
+    expect(workStatusLabel(2)).toBe('已批阅');
+  });
+
+  it('passes through string status', () => {
+    expect(workStatusLabel('已交')).toBe('已交');
+  });
+
+  it('returns 未知 for empty/null', () => {
+    expect(workStatusLabel(null)).toBe('未知');
+    expect(workStatusLabel('')).toBe('未知');
+  });
+});