@jackwener/opencli 1.0.0 → 1.0.3

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.
@@ -37,6 +38,15 @@ export class Page implements IPage {
     }
   }
 
+  /** Close the automation window in the extension */
+  async closeWindow(): Promise<void> {
+    try {
+      await sendCommand('close-window', {});
+    } catch {
+      // Window may already be closed or daemon may be down
+    }
+  }
+
   async evaluate(js: string): Promise<any> {
     const code = wrapForEval(js);
     return sendCommand('exec', { code, ...this._tabOpt() });
@@ -183,12 +193,12 @@ export class Page implements IPage {
     return sendCommand('exec', { code, ...this._tabOpt() });
   }
 
-  async consoleMessages(level: string = 'info'): Promise<any> {
-    // Console messages can't be retrospectively read via CDP Runtime.evaluate.
-    // Would need Runtime.consoleAPICalled event listener, which is not yet implemented.
-    if (process.env.OPENCLI_VERBOSE) {
-      console.error('[page] consoleMessages() not supported in lightweight mode — returning empty');
-    }
+  /**
+   * Console messages are not available in lightweight daemon mode.
+   * Would require CDP Runtime.consoleAPICalled event listener.
+   * @returns Always returns empty array.
+   */
+  async consoleMessages(_level: string = 'info'): Promise<any> {
     return [];
   }
 
@@ -260,46 +270,20 @@ export class Page implements IPage {
 
   async installInterceptor(pattern: string): Promise<void> {
     const { generateInterceptorJs } = await import('../interceptor.js');
-    await sendCommand('exec', {
-      code: generateInterceptorJs(JSON.stringify(pattern), {
-        arrayName: '__opencli_xhr',
-        patchGuard: '__opencli_interceptor_patched',
-      }),
-      ...this._tabOpt(),
-    });
+    // Must use evaluate() so wrapForEval() converts the arrow function into an IIFE;
+    // sendCommand('exec') sends the code as-is, and CDP never executes a bare arrow.
+    await this.evaluate(generateInterceptorJs(JSON.stringify(pattern), {
+      arrayName: '__opencli_xhr',
+      patchGuard: '__opencli_interceptor_patched',
+    }));
   }
 
   async getInterceptedRequests(): Promise<any[]> {
     const { generateReadInterceptedJs } = await import('../interceptor.js');
-    const result = await sendCommand('exec', {
-      code: generateReadInterceptedJs('__opencli_xhr'),
-      ...this._tabOpt(),
-    });
+    // Same as installInterceptor: must go through evaluate() for IIFE wrapping
+    const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
     return (result as any[]) || [];
   }
 }
 
-// ─── 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,5 @@
 import { afterEach, describe, it, expect, vi } from 'vitest';
-import { PlaywrightMCP, __test__ } from './browser/index.js';
+import { BrowserBridge, __test__ } from './browser/index.js';
 
 describe('browser helpers', () => {
   it('extracts tab entries from string snapshots', () => {
@@ -43,11 +43,57 @@ 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('PlaywrightMCP state', () => {
+describe('BrowserBridge state', () => {
   it('transitions to closed after close()', async () => {
-    const mcp = new PlaywrightMCP();
+    const mcp = new BrowserBridge();
 
     expect(mcp.state).toBe('idle');
 
@@ -57,21 +103,21 @@ describe('PlaywrightMCP state', () => {
   });
 
   it('rejects connect() after the session has been closed', async () => {
-    const mcp = new PlaywrightMCP();
+    const mcp = new BrowserBridge();
     await mcp.close();
 
     await expect(mcp.connect()).rejects.toThrow('Session is closed');
   });
 
   it('rejects connect() while already connecting', async () => {
-    const mcp = new PlaywrightMCP();
+    const mcp = new BrowserBridge();
     (mcp as any)._state = 'connecting';
 
     await expect(mcp.connect()).rejects.toThrow('Already connecting');
   });
 
   it('rejects connect() while closing', async () => {
-    const mcp = new PlaywrightMCP();
+    const mcp = new BrowserBridge();
     (mcp as any)._state = 'closing';
 
     await expect(mcp.connect()).rejects.toThrow('Session is closing');

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('未知');
+  });
+});

package/src/chaoxing.ts

@@ -0,0 +1,268 @@
+/**
+ * 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';
+
+// ── Utilities ────────────────────────────────────────────────────────
+
+/** Sleep for given milliseconds (anti-scraping delay). */
+export function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/** Execute a credentialed fetch in the browser context, returning JSON or text. */
+export async function fetchChaoxing(page: IPage, url: string): Promise<any> {
+  const urlJs = JSON.stringify(url);
+  return page.evaluate(`
+    async () => {
+      const res = await fetch(${urlJs}, { credentials: "include" });
+      const text = await res.text();
+      try { return JSON.parse(text); } catch {}
+      return text;
+    }
+  `);
+}
+
+/** Format a timestamp (seconds or milliseconds or date string) to YYYY-MM-DD HH:mm. */
+export function formatTimestamp(ts: unknown): string {
+  if (ts == null || ts === '' || ts === 0) return '';
+  if (typeof ts === 'string' && !/^\d+$/.test(ts.trim())) return ts.trim();
+  const num = Number(ts);
+  if (Number.isNaN(num) || num <= 0) return String(ts);
+  const millis = num > 1e12 ? num : num * 1000;
+  const d = new Date(millis);
+  if (Number.isNaN(d.getTime())) return String(ts);
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const dd = String(d.getDate()).padStart(2, '0');
+  const hh = String(d.getHours()).padStart(2, '0');
+  const mi = String(d.getMinutes()).padStart(2, '0');
+  return `${yyyy}-${mm}-${dd} ${hh}:${mi}`;
+}
+
+/** Map numeric work status to Chinese label. */
+export function workStatusLabel(status: unknown): string {
+  if (status == null || status === '') return '未知';
+  const s = Number(status);
+  if (s === 0) return '未交';
+  if (s === 1) return '已交';
+  if (s === 2) return '已批阅';
+  const str = String(status).trim();
+  return str || '未知';
+}
+
+// ── Course list ──────────────────────────────────────────────────────
+
+export interface ChaoxingCourse {
+  courseId: string;
+  classId: string;
+  cpi: string;
+  title: string;
+}
+
+/** Fetch enrolled course list via backclazzdata JSON API. */
+export async function getCourses(page: IPage): Promise<ChaoxingCourse[]> {
+  const resp = await fetchChaoxing(
+    page,
+    'https://mooc1-api.chaoxing.com/mycourse/backclazzdata?view=json&rss=1',
+  );
+  if (!resp || typeof resp !== 'object') return [];
+  const channelList: any[] = resp.channelList ?? [];
+  const courses: ChaoxingCourse[] = [];
+  for (const channel of channelList) {
+    const content = channel?.content;
+    if (!content) continue;
+    const courseData = content.course?.data;
+    if (!Array.isArray(courseData)) continue;
+    for (const c of courseData) {
+      courses.push({
+        courseId: String(c.id ?? ''),
+        classId: String(content.id ?? ''),
+        cpi: String(channel.cpi ?? ''),
+        title: String(c.name ?? ''),
+      });
+    }
+  }
+  return courses;
+}
+
+// ── Session & course entry ───────────────────────────────────────────
+
+/** Navigate to the interaction page to establish a Chaoxing session. */
+export async function initSession(page: IPage): Promise<void> {
+  await page.goto('https://mooc2-ans.chaoxing.com/mooc2-ans/visit/interaction');
+  await page.wait(3);
+}
+
+/**
+ * Enter a course via stucoursemiddle redirect (establishes course session + enc).
+ * After this call the browser is on the course page.
+ */
+export async function enterCourse(page: IPage, course: ChaoxingCourse): Promise<void> {
+  const url =
+    `https://mooc1.chaoxing.com/visit/stucoursemiddle` +
+    `?courseid=${course.courseId}&clazzid=${course.classId}&cpi=${course.cpi}&ismooc2=1&v=2`;
+  await page.goto(url);
+  await page.wait(3);
+}
+
+/**
+ * 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 async function getTabIframeUrl(page: IPage, tabName: string): Promise<string> {
+  const nameJs = JSON.stringify(tabName);
+  const result: any = await page.evaluate(`
+    async () => {
+      const tabs = document.querySelectorAll('a[data-url]');
+      let target = null;
+      for (const tab of tabs) {
+        if ((tab.innerText || '').trim() === ${nameJs}) { target = tab; break; }
+      }
+      if (!target) return '';
+      target.click();
+      await new Promise(r => setTimeout(r, 2000));
+      const iframe = document.getElementById('frame_content-hd') || document.querySelector('iframe');
+      return iframe?.src || '';
+    }
+  `);
+  return typeof result === 'string' ? result : '';
+}
+
+// ── Assignment parsing ───────────────────────────────────────────────
+
+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 async function parseAssignmentsFromDom(page: IPage, courseName: string): Promise<AssignmentRow[]> {
+  const raw: any[] = await page.evaluate(`
+    (() => {
+      const items = [];
+      // Each assignment is a li or div block; try multiple selectors
+      const blocks = document.querySelectorAll('.ulDiv li, .work-list-item, .listContent > div, ul > li');
+      for (const block of blocks) {
+        const text = (block.innerText || '').trim();
+        if (!text || text.length < 3) continue;
+        // Skip filter buttons and headers
+        if (/^(全部|已完成|未完成|筛选)$/.test(text)) continue;
+        items.push(text);
+      }
+      // Fallback: split body text by common patterns
+      if (items.length === 0) {
+        const body = (document.body?.innerText || '').trim();
+        return [body];
+      }
+      return items;
+    })()
+  `) ?? [];
+
+  const rows: AssignmentRow[] = [];
+  for (const text of raw) {
+    if (typeof text !== 'string' || text.length < 3) continue;
+    // Skip noise
+    if (/^(全部|已完成|未完成|筛选|暂无|提交的作业将经过)/.test(text)) continue;
+
+    const lines = text.split('\n').map((l: string) => l.trim()).filter(Boolean);
+    if (!lines.length) continue;
+
+    // First meaningful line is the title
+    const title = lines[0].replace(/\s+/g, ' ').trim();
+    if (!title || /^(全部|已完成|未完成|筛选)$/.test(title)) continue;
+
+    // Extract status: 未交 / 待批阅 / 已完成 / 已批阅
+    const statusMatch = text.match(/(未交|待批阅|已完成|已批阅)/);
+    const status = statusMatch?.[1] ?? '';
+
+    // Extract deadline: "剩余XXX" or date pattern
+    const remainMatch = text.match(/(剩余[\d天小时分钟秒]+)/);
+    const dateMatch = text.match(/(\d{4}[-/.]\d{1,2}[-/.]\d{1,2}(?:\s+\d{1,2}:\d{2})?)/);
+    const deadline = remainMatch?.[1] ?? dateMatch?.[1] ?? '';
+
+    // Extract score (exclude "分钟")
+    const scoreMatch = text.match(/(\d+(?:\.\d+)?)\s*分(?!钟)/);
+    const score = scoreMatch?.[1] ?? '';
+
+    rows.push({ course: courseName, title, deadline, status, score });
+  }
+  return rows;
+}
+
+// ── Exam parsing ─────────────────────────────────────────────────────
+
+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 async function parseExamsFromDom(page: IPage, courseName: string): Promise<ExamRow[]> {
+  const raw: any[] = await page.evaluate(`
+    (() => {
+      const items = [];
+      const blocks = document.querySelectorAll('.ulDiv li, .exam-list-item, .listContent > div, ul > li');
+      for (const block of blocks) {
+        const text = (block.innerText || '').trim();
+        if (!text || text.length < 3) continue;
+        if (/^(全部|已完成|未完成|筛选|暂无)$/.test(text)) continue;
+        items.push(text);
+      }
+      if (items.length === 0) {
+        const body = (document.body?.innerText || '').trim();
+        return [body];
+      }
+      return items;
+    })()
+  `) ?? [];
+
+  // Check for "暂无考试"
+  if (raw.length === 1 && typeof raw[0] === 'string' && raw[0].includes('暂无考试')) {
+    return [];
+  }
+
+  const rows: ExamRow[] = [];
+  for (const text of raw) {
+    if (typeof text !== 'string' || text.length < 3) continue;
+    if (/^(全部|已完成|未完成|筛选|暂无)/.test(text)) continue;
+
+    const lines = text.split('\n').map((l: string) => l.trim()).filter(Boolean);
+    if (!lines.length) continue;
+
+    const title = lines[0].replace(/\s+/g, ' ').trim();
+    if (!title || /^(全部|已完成|未完成|筛选)$/.test(title)) continue;
+
+    // Extract dates
+    const dates = text.match(/\d{4}[-/.]\d{1,2}[-/.]\d{1,2}\s+\d{1,2}:\d{2}/g) ?? [];
+    const start = dates[0] ?? '';
+    const end = dates[1] ?? '';
+
+    // Status
+    const statusMatch = text.match(/(未开始|进行中|已结束|已完成|未交|待批阅)/);
+    let status = statusMatch?.[1] ?? '';
+    if (!status && text.includes('剩余')) status = '进行中';
+
+    // Score (exclude "分钟")
+    const scoreMatch = text.match(/(\d+(?:\.\d+)?)\s*分(?!钟)/);
+    const score = scoreMatch?.[1] ?? '';
+
+    rows.push({ course: courseName, title, start, end, status, score });
+  }
+  return rows;
+}