@jackwener/opencli 1.0.1 → 1.0.4

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;
+}

package/src/cli.ts

@@ -0,0 +1,205 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { executeCommand } from './engine.js';
+import { Strategy, type CliCommand, fullName, getRegistry, strategyLabel } from './registry.js';
+import { render as renderOutput } from './output.js';
+import { BrowserBridge, CDPBridge } from './browser/index.js';
+import { browserSession, DEFAULT_BROWSER_COMMAND_TIMEOUT, runWithTimeout } from './runtime.js';
+import { PKG_VERSION } from './version.js';
+import { printCompletionScript } from './completion.js';
+import { CliError } from './errors.js';
+import { shouldUseBrowserSession } from './capabilityRouting.js';
+
+export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
+  const program = new Command();
+  program.name('opencli').description('Make any website your CLI. Zero setup. AI-powered.').version(PKG_VERSION);
+
+  // ── Built-in commands ──────────────────────────────────────────────────────
+
+  program.command('list').description('List all available CLI commands').option('-f, --format <fmt>', 'Output format: table, json, yaml, md, csv', 'table').option('--json', 'JSON output (deprecated)')
+    .action((opts) => {
+      const registry = getRegistry();
+      const commands = [...registry.values()].sort((a, b) => fullName(a).localeCompare(fullName(b)));
+      const rows = commands.map(c => ({
+        command: fullName(c),
+        site: c.site,
+        name: c.name,
+        description: c.description,
+        strategy: strategyLabel(c),
+        browser: c.browser,
+        args: c.args.map(a => a.name).join(', '),
+      }));
+      const fmt = opts.json && opts.format === 'table' ? 'json' : opts.format;
+      if (fmt !== 'table') {
+        renderOutput(rows, {
+          fmt,
+          columns: ['command', 'site', 'name', 'description', 'strategy', 'browser', 'args'],
+          title: 'opencli/list',
+          source: 'opencli list',
+        });
+        return;
+      }
+      const sites = new Map<string, CliCommand[]>();
+      for (const cmd of commands) { const g = sites.get(cmd.site) ?? []; g.push(cmd); sites.set(cmd.site, g); }
+      console.log(); console.log(chalk.bold('  opencli') + chalk.dim(' — available commands')); console.log();
+      for (const [site, cmds] of sites) {
+        console.log(chalk.bold.cyan(`  ${site}`));
+        for (const cmd of cmds) { const tag = strategyLabel(cmd) === 'public' ? chalk.green('[public]') : chalk.yellow(`[${strategyLabel(cmd)}]`); console.log(`    ${cmd.name} ${tag}${cmd.description ? chalk.dim(` — ${cmd.description}`) : ''}`); }
+        console.log();
+      }
+      console.log(chalk.dim(`  ${commands.length} commands across ${sites.size} sites`)); console.log();
+    });
+
+  program.command('validate').description('Validate CLI definitions').argument('[target]', 'site or site/name')
+    .action(async (target) => {
+      const { validateClisWithTarget, renderValidationReport } = await import('./validate.js');
+      console.log(renderValidationReport(validateClisWithTarget([BUILTIN_CLIS, USER_CLIS], target)));
+    });
+
+  program.command('verify').description('Validate + smoke test').argument('[target]').option('--smoke', 'Run smoke tests', false)
+    .action(async (target, opts) => {
+      const { verifyClis, renderVerifyReport } = await import('./verify.js');
+      const r = await verifyClis({ builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, target, smoke: opts.smoke });
+      console.log(renderVerifyReport(r));
+      process.exitCode = r.ok ? 0 : 1;
+    });
+
+  program.command('explore').alias('probe').description('Explore a website: discover APIs, stores, and recommend strategies').argument('<url>').option('--site <name>').option('--goal <text>').option('--wait <s>', '', '3').option('--auto', 'Enable interactive fuzzing (simulate clicks to trigger lazy APIs)').option('--click <labels>', 'Comma-separated labels to click before fuzzing (e.g. "字幕,CC,评论")')
+    .action(async (url, opts) => { const { exploreUrl, renderExploreSummary } = await import('./explore.js'); const clickLabels = opts.click ? opts.click.split(',').map((s: string) => s.trim()) : undefined; const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge; const workspace = `explore:${opts.site ?? (() => { try { return new URL(url).host; } catch { return 'default'; } })()}`; console.log(renderExploreSummary(await exploreUrl(url, { BrowserFactory: BrowserFactory as any, site: opts.site, goal: opts.goal, waitSeconds: parseFloat(opts.wait), auto: opts.auto, clickLabels, workspace }))); });
+
+  program.command('synthesize').description('Synthesize CLIs from explore').argument('<target>').option('--top <n>', '', '3')
+    .action(async (target, opts) => { const { synthesizeFromExplore, renderSynthesizeSummary } = await import('./synthesize.js'); console.log(renderSynthesizeSummary(synthesizeFromExplore(target, { top: parseInt(opts.top) }))); });
+
+  program.command('generate').description('One-shot: explore → synthesize → register').argument('<url>').option('--goal <text>').option('--site <name>')
+    .action(async (url, opts) => { const { generateCliFromUrl, renderGenerateSummary } = await import('./generate.js'); const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge; const workspace = `generate:${opts.site ?? (() => { try { return new URL(url).host; } catch { return 'default'; } })()}`; const r = await generateCliFromUrl({ url, BrowserFactory: BrowserFactory as any, builtinClis: BUILTIN_CLIS, userClis: USER_CLIS, goal: opts.goal, site: opts.site, workspace }); console.log(renderGenerateSummary(r)); process.exitCode = r.ok ? 0 : 1; });
+
+  program.command('cascade').description('Strategy cascade: find simplest working strategy').argument('<url>').option('--site <name>')
+    .action(async (url, opts) => {
+      const { cascadeProbe, renderCascadeResult } = await import('./cascade.js');
+      const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge;
+      const result = await browserSession(BrowserFactory as any, async (page) => {
+        // Navigate to the site first for cookie context
+        try { const siteUrl = new URL(url); await page.goto(`${siteUrl.protocol}//${siteUrl.host}`); await page.wait(2); } catch {}
+        return cascadeProbe(page, url);
+      }, { workspace: `cascade:${opts.site ?? (() => { try { return new URL(url).host; } catch { return 'default'; } })()}` });
+      console.log(renderCascadeResult(result));
+    });
+
+  program.command('doctor')
+    .description('Diagnose opencli browser bridge connectivity')
+    .option('--live', 'Test browser connectivity (requires Chrome running)', false)
+    .option('--sessions', 'Show active automation sessions', false)
+    .action(async (opts) => {
+      const { runBrowserDoctor, renderBrowserDoctorReport } = await import('./doctor.js');
+      const report = await runBrowserDoctor({ live: opts.live, sessions: opts.sessions, cliVersion: PKG_VERSION });
+      console.log(renderBrowserDoctorReport(report));
+    });
+
+  program.command('setup')
+    .description('Interactive setup: verify browser bridge connectivity')
+    .action(async () => {
+      const { runSetup } = await import('./setup.js');
+      await runSetup({ cliVersion: PKG_VERSION });
+    });
+
+  program.command('completion')
+    .description('Output shell completion script')
+    .argument('<shell>', 'Shell type: bash, zsh, or fish')
+    .action((shell) => {
+      printCompletionScript(shell);
+    });
+
+  // ── Antigravity serve (built-in, long-running) ──────────────────────────────
+
+  const antigravityCmd = program.command('antigravity').description('antigravity commands');
+  antigravityCmd.command('serve')
+    .description('Start Anthropic-compatible API proxy for Antigravity')
+    .option('--port <port>', 'Server port (default: 8082)', '8082')
+    .action(async (opts) => {
+      const { startServe } = await import('./clis/antigravity/serve.js');
+      await startServe({ port: parseInt(opts.port) });
+    });
+
+  // ── Dynamic site commands ──────────────────────────────────────────────────
+
+  const registry = getRegistry();
+  const siteGroups = new Map<string, Command>();
+  // Pre-seed with the antigravity command registered above to avoid duplicates
+  siteGroups.set('antigravity', antigravityCmd);
+
+  for (const [, cmd] of registry) {
+    let siteCmd = siteGroups.get(cmd.site);
+    if (!siteCmd) { siteCmd = program.command(cmd.site).description(`${cmd.site} commands`); siteGroups.set(cmd.site, siteCmd); }
+    const subCmd = siteCmd.command(cmd.name).description(cmd.description);
+
+    // Register positional args first, then named options
+    const positionalArgs: typeof cmd.args = [];
+    for (const arg of cmd.args) {
+      if (arg.positional) {
+        const bracket = arg.required ? `<${arg.name}>` : `[${arg.name}]`;
+        subCmd.argument(bracket, arg.help ?? '');
+        positionalArgs.push(arg);
+      } else {
+        const flag = arg.required ? `--${arg.name} <value>` : `--${arg.name} [value]`;
+        if (arg.required) subCmd.requiredOption(flag, arg.help ?? '');
+        else if (arg.default != null) subCmd.option(flag, arg.help ?? '', String(arg.default));
+        else subCmd.option(flag, arg.help ?? '');
+      }
+    }
+    subCmd.option('-f, --format <fmt>', 'Output format: table, json, yaml, md, csv', 'table').option('-v, --verbose', 'Debug output', false);
+
+    subCmd.action(async (...actionArgs: any[]) => {
+      // Commander passes positional args first, then options object, then the Command
+      const actionOpts = actionArgs[positionalArgs.length] ?? {};
+      const startTime = Date.now();
+      const kwargs: Record<string, any> = {};
+      
+      // Collect positional args
+      for (let i = 0; i < positionalArgs.length; i++) {
+        const arg = positionalArgs[i];
+        const v = actionArgs[i];
+        if (v !== undefined) kwargs[arg.name] = v;
+      }
+      
+      // Collect named options
+      for (const arg of cmd.args) {
+        if (arg.positional) continue;
+        const camelName = arg.name.replace(/-([a-z])/g, (_m, ch: string) => ch.toUpperCase());
+        const v = actionOpts[arg.name] ?? actionOpts[camelName];
+        if (v !== undefined) kwargs[arg.name] = v;
+      }
+
+      try {
+        if (actionOpts.verbose) process.env.OPENCLI_VERBOSE = '1';
+        let result: any;
+        if (shouldUseBrowserSession(cmd)) {
+          const BrowserFactory = process.env.OPENCLI_CDP_ENDPOINT ? CDPBridge : BrowserBridge;
+          result = await browserSession(BrowserFactory as any, async (page) => {
+            // Cookie/header strategies require same-origin context for credentialed fetch.
+            if ((cmd.strategy === Strategy.COOKIE || cmd.strategy === Strategy.HEADER) && cmd.domain) {
+              try { await page.goto(`https://${cmd.domain}`); await page.wait(2); } catch {}
+            }
+            return runWithTimeout(executeCommand(cmd, page, kwargs, actionOpts.verbose), { timeout: cmd.timeoutSeconds ?? DEFAULT_BROWSER_COMMAND_TIMEOUT, label: fullName(cmd) });
+          }, { workspace: `site:${cmd.site}` });
+        } else { result = await executeCommand(cmd, null, kwargs, actionOpts.verbose); }
+        if (actionOpts.verbose && (!result || (Array.isArray(result) && result.length === 0))) {
+          console.error(chalk.yellow(`[Verbose] Warning: Command returned an empty result. If the website structural API changed or requires authentication, check the network or update the adapter.`));
+        }
+        const resolved = getRegistry().get(fullName(cmd)) ?? cmd;
+        renderOutput(result, { fmt: actionOpts.format, columns: resolved.columns, title: `${resolved.site}/${resolved.name}`, elapsed: (Date.now() - startTime) / 1000, source: fullName(resolved), footerExtra: resolved.footerExtra?.(kwargs) });
+      } catch (err: any) { 
+        if (err instanceof CliError) {
+          console.error(chalk.red(`Error [${err.code}]: ${err.message}`));
+          if (err.hint) console.error(chalk.yellow(`Hint: ${err.hint}`));
+        } else if (actionOpts.verbose && err.stack) {
+          console.error(chalk.red(err.stack));
+        } else {
+          console.error(chalk.red(`Error: ${err.message ?? err}`));
+        }
+        process.exitCode = 1; 
+      }
+    });
+  }
+
+  program.parse();
+}

package/src/clis/antigravity/SKILL.md

@@ -17,6 +17,11 @@ The agent must configure the endpoint environment variable locally before invoki
 export OPENCLI_CDP_ENDPOINT="http://127.0.0.1:9224"
 \`\`\`
 
+If the endpoint exposes multiple inspectable targets, also set:
+\`\`\`bash
+export OPENCLI_CDP_TARGET="antigravity"
+\`\`\`
+
 ## High-Level Capabilities
 1. **Send Messages (`opencli antigravity send <message>`)**: Type and send a message directly into the chat UI.
 2. **Read History (`opencli antigravity read`)**: Scrape the raw chat transcript from the main UI container.