@jackwener/opencli 1.0.1 → 1.0.4

package/dist/browser/page.js

@@ -11,19 +11,29 @@
  */
 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
@@ -34,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
@@ -42,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));
@@ -73,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')
@@ -81,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') {
@@ -135,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.
@@ -194,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,
@@ -203,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');
@@ -257,26 +195,4 @@ export class Page {
         return result || [];
     }
 }
-// ─── 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) {
-    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/dist/browser/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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 declare function wrapForEval(js: string): string;

package/dist/browser/utils.js

@@ -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) {
+    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/dist/browser.test.js

@@ -1,5 +1,6 @@
-import { describe, it, expect } from 'vitest';
+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');
@@ -30,6 +31,47 @@ 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', () => {
     it('transitions to closed after close()', async () => {
@@ -53,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.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Chaoxing (学习通) shared helpers.
+ *
+ * Flow: initSession → getCourses → enterCourse → getTabIframeUrl → navigate → parse DOM
+ * Chaoxing has no flat "list all assignments" API; data is behind session-gated
+ * course pages loaded as iframes.
+ */
+import type { IPage } from './types.js';
+/** Sleep for given milliseconds (anti-scraping delay). */
+export declare function sleep(ms: number): Promise<void>;
+/** Execute a credentialed fetch in the browser context, returning JSON or text. */
+export declare function fetchChaoxing(page: IPage, url: string): Promise<any>;
+/** Format a timestamp (seconds or milliseconds or date string) to YYYY-MM-DD HH:mm. */
+export declare function formatTimestamp(ts: unknown): string;
+/** Map numeric work status to Chinese label. */
+export declare function workStatusLabel(status: unknown): string;
+export interface ChaoxingCourse {
+    courseId: string;
+    classId: string;
+    cpi: string;
+    title: string;
+}
+/** Fetch enrolled course list via backclazzdata JSON API. */
+export declare function getCourses(page: IPage): Promise<ChaoxingCourse[]>;
+/** Navigate to the interaction page to establish a Chaoxing session. */
+export declare function initSession(page: IPage): Promise<void>;
+/**
+ * Enter a course via stucoursemiddle redirect (establishes course session + enc).
+ * After this call the browser is on the course page.
+ */
+export declare function enterCourse(page: IPage, course: ChaoxingCourse): Promise<void>;
+/**
+ * On the course page, click a tab (作业 / 考试) and return the iframe src
+ * that gets loaded. Returns empty string if the tab is not found.
+ */
+export declare function getTabIframeUrl(page: IPage, tabName: string): Promise<string>;
+export interface AssignmentRow {
+    course: string;
+    title: string;
+    deadline: string;
+    status: string;
+    score: string;
+}
+/**
+ * Parse assignments from the current page DOM (the 作业列表 page).
+ * The page uses `.ulDiv li` items with status/deadline/score info.
+ */
+export declare function parseAssignmentsFromDom(page: IPage, courseName: string): Promise<AssignmentRow[]>;
+export interface ExamRow {
+    course: string;
+    title: string;
+    start: string;
+    end: string;
+    status: string;
+    score: string;
+}
+/** Parse exams from the current page DOM (the 考试列表 page). */
+export declare function parseExamsFromDom(page: IPage, courseName: string): Promise<ExamRow[]>;