@jackwener/opencli 1.0.1 → 1.0.3

package/extension/manifest.json

@@ -1,6 +1,6 @@
 {
   "manifest_version": 3,
-  "name": "opencli Browser Bridge",
+  "name": "OpenCLI",
   "version": "0.2.0",
   "description": "Bridge between opencli CLI and your browser — execute commands, read cookies, manage tabs.",
   "permissions": [
@@ -21,7 +21,7 @@
     "128": "icons/icon-128.png"
   },
   "action": {
-    "default_title": "opencli Browser Bridge",
+    "default_title": "OpenCLI",
     "default_icon": {
       "16": "icons/icon-16.png",
       "32": "icons/icon-32.png"

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.
@@ -155,7 +155,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(() => {

package/package.json

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

package/src/browser/cdp.ts

@@ -0,0 +1,295 @@
+/**
+ * CDP client — implements IPage by connecting directly to a Chrome/Electron CDP WebSocket.
+ */
+
+import { WebSocket } from 'ws';
+import type { IPage } from '../types.js';
+import { wrapForEval } from './utils.js';
+
+export interface CDPTarget {
+  type?: string;
+  url?: string;
+  title?: string;
+  webSocketDebuggerUrl?: string;
+}
+
+export class CDPBridge {
+  private _ws: WebSocket | null = null;
+  private _idCounter = 0;
+  private _pending = new Map<number, { resolve: (val: any) => void; reject: (err: Error) => void }>();
+
+  async connect(opts?: { timeout?: number }): Promise<IPage> {
+    const endpoint = process.env.OPENCLI_CDP_ENDPOINT;
+    if (!endpoint) throw new Error('OPENCLI_CDP_ENDPOINT is not set');
+
+    // If it's a direct ws:// URL, use it. Otherwise, fetch the /json endpoint to find a page.
+    let wsUrl = endpoint;
+    if (endpoint.startsWith('http')) {
+      const res = await fetch(`${endpoint.replace(/\/$/, '')}/json`);
+      if (!res.ok) throw new Error(`Failed to fetch CDP targets: ${res.statusText}`);
+      const targets = await res.json() as CDPTarget[];
+      const target = selectCDPTarget(targets);
+      if (!target || !target.webSocketDebuggerUrl) {
+        throw new Error('No inspectable targets found at CDP endpoint');
+      }
+      wsUrl = target.webSocketDebuggerUrl;
+    }
+
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      const timeout = setTimeout(() => reject(new Error('CDP connect timeout')), opts?.timeout ?? 10000);
+
+      ws.on('open', () => {
+        clearTimeout(timeout);
+        this._ws = ws;
+        resolve(new CDPPage(this));
+      });
+
+      ws.on('error', (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+
+      ws.on('message', (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          if (msg.id && this._pending.has(msg.id)) {
+            const { resolve, reject } = this._pending.get(msg.id)!;
+            this._pending.delete(msg.id);
+            if (msg.error) {
+              reject(new Error(msg.error.message));
+            } else {
+              resolve(msg.result);
+            }
+          }
+        } catch (e) {
+          // ignore parsing errors
+        }
+      });
+    });
+  }
+
+  async close(): Promise<void> {
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+    for (const p of this._pending.values()) {
+      p.reject(new Error('CDP connection closed'));
+    }
+    this._pending.clear();
+  }
+
+  async send(method: string, params: any = {}): Promise<any> {
+    if (!this._ws || this._ws.readyState !== WebSocket.OPEN) {
+      throw new Error('CDP connection is not open');
+    }
+    const id = ++this._idCounter;
+    return new Promise((resolve, reject) => {
+      this._pending.set(id, { resolve, reject });
+      this._ws!.send(JSON.stringify({ id, method, params }));
+    });
+  }
+}
+
+class CDPPage implements IPage {
+  constructor(private bridge: CDPBridge) {}
+
+  async goto(url: string): Promise<void> {
+    await this.bridge.send('Page.navigate', { url });
+    await new Promise(r => setTimeout(r, 1000));
+  }
+
+  async evaluate(js: string): Promise<any> {
+    const expression = wrapForEval(js);
+    const result = await this.bridge.send('Runtime.evaluate', {
+      expression,
+      returnByValue: true,
+      awaitPromise: true
+    });
+    if (result.exceptionDetails) {
+      throw new Error('Evaluate error: ' + (result.exceptionDetails.exception?.description || 'Unknown exception'));
+    }
+    return result.result?.value;
+  }
+
+  async snapshot(opts?: any): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+  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 this.evaluate(code);
+  }
+  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 this.evaluate(code);
+  }
+  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 this.evaluate(code);
+  }
+  async wait(options: any): Promise<void> {
+    if (typeof options === 'number') {
+      await new Promise(resolve => setTimeout(resolve, options * 1000));
+      return;
+    }
+    if (options.time) {
+      await new Promise(resolve => setTimeout(resolve, options.time * 1000));
+      return;
+    }
+    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 this.evaluate(code);
+    }
+  }
+  async tabs(): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+  async closeTab(index?: number): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  async newTab(): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  async selectTab(index: number): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  async networkRequests(includeStatic?: boolean): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+  async consoleMessages(level?: string): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+  async scroll(direction?: string, amount?: number): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  async autoScroll(options?: any): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  async installInterceptor(pattern: string): Promise<void> {
+    throw new Error('Method not implemented.');
+  }
+  async getInterceptedRequests(): Promise<any[]> {
+    throw new Error('Method not implemented.');
+  }
+  async screenshot(options?: any): Promise<string> {
+    throw new Error('Method not implemented.');
+  }
+}
+function selectCDPTarget(targets: CDPTarget[]): CDPTarget | undefined {
+  const preferredPattern = compilePreferredPattern(process.env.OPENCLI_CDP_TARGET);
+
+  const ranked = targets
+    .map((target, index) => ({ target, index, score: scoreCDPTarget(target, preferredPattern) }))
+    .filter(({ score }) => Number.isFinite(score))
+    .sort((a, b) => {
+      if (b.score !== a.score) return b.score - a.score;
+      return a.index - b.index;
+    });
+
+  return ranked[0]?.target;
+}
+
+function scoreCDPTarget(target: CDPTarget, preferredPattern?: RegExp): number {
+  if (!target.webSocketDebuggerUrl) return Number.NEGATIVE_INFINITY;
+
+  const type = (target.type ?? '').toLowerCase();
+  const url = (target.url ?? '').toLowerCase();
+  const title = (target.title ?? '').toLowerCase();
+  const haystack = `${title} ${url}`;
+
+  if (!haystack.trim() && !type) return Number.NEGATIVE_INFINITY;
+  if (haystack.includes('devtools')) return Number.NEGATIVE_INFINITY;
+
+  let score = 0;
+
+  if (preferredPattern && preferredPattern.test(haystack)) score += 1000;
+
+  if (type === 'app') score += 120;
+  else if (type === 'webview') score += 100;
+  else if (type === 'page') score += 80;
+  else if (type === 'iframe') score += 20;
+
+  if (url.startsWith('http://localhost') || url.startsWith('https://localhost')) score += 90;
+  if (url.startsWith('file://')) score += 60;
+  if (url.startsWith('http://127.0.0.1') || url.startsWith('https://127.0.0.1')) score += 50;
+  if (url.startsWith('about:blank')) score -= 120;
+  if (url === '' || url === 'about:blank') score -= 40;
+
+  if (title && title !== 'devtools') score += 25;
+  if (title.includes('antigravity')) score += 120;
+  if (title.includes('codex')) score += 120;
+  if (title.includes('cursor')) score += 120;
+  if (title.includes('chatwise')) score += 120;
+  if (title.includes('notion')) score += 120;
+  if (title.includes('discord')) score += 120;
+  if (title.includes('netease')) score += 120;
+
+  if (url.includes('antigravity')) score += 100;
+  if (url.includes('codex')) score += 100;
+  if (url.includes('cursor')) score += 100;
+  if (url.includes('chatwise')) score += 100;
+  if (url.includes('notion')) score += 100;
+  if (url.includes('discord')) score += 100;
+  if (url.includes('netease')) score += 100;
+
+  return score;
+}
+
+function compilePreferredPattern(raw: string | undefined): RegExp | undefined {
+  const value = raw?.trim();
+  if (!value) return undefined;
+  return new RegExp(escapeRegExp(value.toLowerCase()));
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export const __test__ = {
+  selectCDPTarget,
+  scoreCDPTarget,
+};

package/src/browser/index.ts

@@ -7,9 +7,11 @@
 
 export { Page } from './page.js';
 export { BrowserBridge, BrowserBridge as PlaywrightMCP } from './mcp.js';
+export { CDPBridge } from './cdp.js';
 export { isDaemonRunning } from './daemon-client.js';
 
 import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
+import { __test__ as cdpTest } from './cdp.js';
 import { withTimeoutMs } from '../runtime.js';
 
 export const __test__ = {
@@ -17,4 +19,6 @@ export const __test__ = {
   diffTabIndexes,
   appendLimited,
   withTimeoutMs,
+  selectCDPTarget: cdpTest.selectCDPTarget,
+  scoreCDPTarget: cdpTest.scoreCDPTarget,
 };

package/src/browser/page.ts

@@ -13,6 +13,7 @@
 import { formatSnapshot } from '../snapshotFormatter.js';
 import type { IPage } from '../types.js';
 import { sendCommand } from './daemon-client.js';
+import { wrapForEval } from './utils.js';
 
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
@@ -285,27 +286,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

@@ -43,6 +43,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', () => {

package/src/chaoxing.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+import { formatTimestamp, workStatusLabel } from './chaoxing.js';
+
+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/);
+  });
+
+  it('formats second timestamp', () => {
+    const ts = Math.floor(new Date('2026-06-01T12:00:00Z').getTime() / 1000);
+    const result = formatTimestamp(ts);
+    expect(result).toMatch(/2026-06-01/);
+  });
+
+  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('未知');
+  });
+});