@jackwener/opencli 1.3.1 → 1.3.3

package/src/browser/page.ts

@@ -15,6 +15,7 @@ import type { BrowserCookie, IPage, ScreenshotOptions, SnapshotOptions, WaitOpti
 import { sendCommand } from './daemon-client.js';
 import { wrapForEval } from './utils.js';
 import { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
+import { generateStealthJs } from './stealth.js';
 import {
   clickJs,
   typeTextJs,
@@ -54,6 +55,16 @@ export class Page implements IPage {
     if (result?.tabId) {
       this._tabId = result.tabId;
     }
+    // Inject stealth anti-detection patches (guard flag prevents double-injection).
+    try {
+      await sendCommand('exec', {
+        code: generateStealthJs(),
+        ...this._workspaceOpt(),
+        ...this._tabOpt(),
+      });
+    } catch {
+      // Non-fatal: stealth is best-effort
+    }
     // Smart settle: use DOM stability detection instead of fixed sleep.
     // settleMs is now a timeout cap (default 1000ms), not a fixed wait.
     if (options?.waitUntil !== 'none') {

package/src/browser/stealth.ts

@@ -0,0 +1,142 @@
+/**
+ * Stealth anti-detection module.
+ *
+ * Generates JS code that patches browser globals to hide automation
+ * fingerprints (e.g. navigator.webdriver, missing chrome object, empty
+ * plugin list). Injected before page scripts run so that websites cannot
+ * detect CDP / extension-based control.
+ *
+ * Inspired by puppeteer-extra-plugin-stealth.
+ */
+
+/** Guard flag set on `window` to prevent double-injection. */
+export const STEALTH_GUARD = '__opencli_stealth_applied';
+
+/**
+ * Return a self-contained JS string that, when evaluated in a page context,
+ * applies all stealth patches. Safe to call multiple times — the guard flag
+ * ensures patches are applied only once.
+ */
+export function generateStealthJs(): string {
+  return `
+    (() => {
+      // Guard: skip if already applied
+      if (window.${STEALTH_GUARD}) return 'skipped';
+      // Use defineProperty so the guard flag is non-enumerable (not a detection vector).
+      Object.defineProperty(window, '${STEALTH_GUARD}', { value: true, configurable: true });
+
+      // 1. navigator.webdriver → undefined
+      //    Most common check; Playwright/Puppeteer/CDP set this to true.
+      try {
+        Object.defineProperty(navigator, 'webdriver', {
+          get: () => undefined,
+          configurable: true,
+        });
+      } catch {}
+
+      // 2. window.chrome stub
+      //    Real Chrome exposes window.chrome with runtime, loadTimes, csi.
+      //    Headless/automated Chrome may not have it.
+      try {
+        if (!window.chrome) {
+          window.chrome = {
+            runtime: {
+              onConnect: { addListener: () => {}, removeListener: () => {} },
+              onMessage: { addListener: () => {}, removeListener: () => {} },
+            },
+            loadTimes: () => ({}),
+            csi: () => ({}),
+          };
+        }
+      } catch {}
+
+      // 3. navigator.plugins — fake population only if empty
+      //    Real user browser already has plugins; only patch in automated/headless
+      //    contexts where the list is empty (overwriting real plugins with fakes
+      //    would be counterproductive and detectable).
+      try {
+        if (!navigator.plugins || navigator.plugins.length === 0) {
+          const fakePlugins = [
+            { name: 'PDF Viewer', filename: 'internal-pdf-viewer', description: 'Portable Document Format' },
+            { name: 'Chrome PDF Viewer', filename: 'internal-pdf-viewer', description: '' },
+            { name: 'Chromium PDF Viewer', filename: 'internal-pdf-viewer', description: '' },
+            { name: 'Microsoft Edge PDF Viewer', filename: 'internal-pdf-viewer', description: '' },
+            { name: 'WebKit built-in PDF', filename: 'internal-pdf-viewer', description: '' },
+          ];
+          fakePlugins.item = (i) => fakePlugins[i] || null;
+          fakePlugins.namedItem = (n) => fakePlugins.find(p => p.name === n) || null;
+          fakePlugins.refresh = () => {};
+          Object.defineProperty(navigator, 'plugins', {
+            get: () => fakePlugins,
+            configurable: true,
+          });
+        }
+      } catch {}
+
+      // 4. navigator.languages — guarantee non-empty
+      //    Some automated contexts return undefined or empty array.
+      try {
+        if (!navigator.languages || navigator.languages.length === 0) {
+          Object.defineProperty(navigator, 'languages', {
+            get: () => ['en-US', 'en'],
+            configurable: true,
+          });
+        }
+      } catch {}
+
+      // 5. Permissions.query — normalize notification permission
+      //    Headless Chrome throws on Permissions.query({ name: 'notifications' }).
+      try {
+        const origQuery = window.Permissions?.prototype?.query;
+        if (origQuery) {
+          window.Permissions.prototype.query = function (parameters) {
+            if (parameters?.name === 'notifications') {
+              return Promise.resolve({ state: Notification.permission, onchange: null });
+            }
+            return origQuery.call(this, parameters);
+          };
+        }
+      } catch {}
+
+      // 6. Clean automation artifacts
+      //    Remove properties left by Playwright, Puppeteer, or CDP injection.
+      try {
+        delete window.__playwright;
+        delete window.__puppeteer;
+        // ChromeDriver injects cdc_ prefixed globals; the suffix varies by version,
+        // so scan window for any matching property rather than hardcoding names.
+        for (const prop of Object.getOwnPropertyNames(window)) {
+          if (prop.startsWith('cdc_') || prop.startsWith('__cdc_')) {
+            try { delete window[prop]; } catch {}
+          }
+        }
+      } catch {}
+
+      // 7. CDP stack trace cleanup
+      //    Runtime.evaluate injects scripts whose source URLs appear in Error
+      //    stack traces (e.g. __puppeteer_evaluation_script__, pptr:, debugger://).
+      //    Websites detect automation by doing: new Error().stack and inspecting it.
+      //    We override the stack property getter on Error.prototype to filter them.
+      //    Note: Error.prepareStackTrace is V8/Node-only and not available in
+      //    browser page context, so we use a property descriptor approach instead.
+      try {
+        const _origDescriptor = Object.getOwnPropertyDescriptor(Error.prototype, 'stack');
+        const _cdpPatterns = ['puppeteer_evaluation_script', 'pptr:', 'debugger://', '__opencli'];
+        if (_origDescriptor && _origDescriptor.get) {
+          Object.defineProperty(Error.prototype, 'stack', {
+            get: function () {
+              const raw = _origDescriptor.get.call(this);
+              if (typeof raw !== 'string') return raw;
+              return raw.split('\\n').filter(line =>
+                !_cdpPatterns.some(p => line.includes(p))
+              ).join('\\n');
+            },
+            configurable: true,
+          });
+        }
+      } catch {}
+
+      return 'applied';
+    })()
+  `;
+}

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 { BrowserBridge, __test__, generateStealthJs } from './browser/index.js';
+import { STEALTH_GUARD } from './browser/stealth.js';
 import * as daemonClient from './browser/daemon-client.js';
 
 describe('browser helpers', () => {
@@ -133,3 +134,52 @@ describe('BrowserBridge state', () => {
     await expect(mcp.connect()).rejects.toThrow('Browser Extension is not connected');
   });
 });
+
+describe('stealth anti-detection', () => {
+  it('generates non-empty JS string', () => {
+    const js = generateStealthJs();
+    expect(typeof js).toBe('string');
+    expect(js.length).toBeGreaterThan(100);
+  });
+
+  it('contains all 7 anti-detection patches', () => {
+    const js = generateStealthJs();
+    // 1. webdriver
+    expect(js).toContain('navigator');
+    expect(js).toContain('webdriver');
+    // 2. chrome stub
+    expect(js).toContain('window.chrome');
+    // 3. plugins
+    expect(js).toContain('plugins');
+    expect(js).toContain('PDF Viewer');
+    // 4. languages
+    expect(js).toContain('languages');
+    // 5. permissions
+    expect(js).toContain('Permissions');
+    expect(js).toContain('notifications');
+    // 6. automation artifacts (dynamic cdc_ scan)
+    expect(js).toContain('__playwright');
+    expect(js).toContain('__puppeteer');
+    expect(js).toContain('getOwnPropertyNames');
+    expect(js).toContain('cdc_');
+    // 7. CDP stack trace cleanup
+    expect(js).toContain('Error.prototype');
+    expect(js).toContain('puppeteer_evaluation_script');
+    expect(js).toContain('getOwnPropertyDescriptor');
+  });
+
+  it('includes guard flag to prevent double-injection', () => {
+    const js = generateStealthJs();
+    expect(js).toContain(STEALTH_GUARD);
+    // Guard should check early and return 'skipped'
+    expect(js).toContain("return 'skipped'");
+    // Normal path returns 'applied'
+    expect(js).toContain("return 'applied'");
+  });
+
+  it('generates syntactically valid JS', () => {
+    const js = generateStealthJs();
+    // Should not throw when parsed
+    expect(() => new Function(js)).not.toThrow();
+  });
+});

package/src/build-manifest.ts

@@ -13,6 +13,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import yaml from 'js-yaml';
+import { getErrorMessage } from './errors.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const CLIS_DIR = path.resolve(__dirname, 'clis');
@@ -73,9 +74,6 @@ function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-function getErrorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
 
 function extractBalancedBlock(
   source: string,

package/src/cli.ts

@@ -183,6 +183,30 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
       process.exitCode = r.ok ? 0 : 1;
     });
 
+  // ── Built-in: record ─────────────────────────────────────────────────────
+
+  program
+    .command('record')
+    .description('Record API calls from a live browser session → generate YAML candidates')
+    .argument('<url>', 'URL to open and record')
+    .option('--site <name>', 'Site name (inferred from URL if omitted)')
+    .option('--out <dir>', 'Output directory for candidates')
+    .option('--poll <ms>', 'Poll interval in milliseconds', '2000')
+    .option('--timeout <ms>', 'Auto-stop after N milliseconds (default: 60000)', '60000')
+    .action(async (url, opts) => {
+      const { recordSession, renderRecordSummary } = await import('./record.js');
+      const result = await recordSession({
+        BrowserFactory: getBrowserFactory(),
+        url,
+        site: opts.site,
+        outDir: opts.out,
+        pollMs: parseInt(opts.poll, 10),
+        timeoutMs: parseInt(opts.timeout, 10),
+      });
+      console.log(renderRecordSummary(result));
+      process.exitCode = result.candidateCount > 0 ? 0 : 1;
+    });
+
   program
     .command('cascade')
     .description('Strategy cascade: find simplest working strategy')
@@ -233,10 +257,11 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
     .argument('<source>', 'Plugin source (e.g. github:user/repo)')
     .action(async (source: string) => {
       const { installPlugin } = await import('./plugin.js');
+      const { discoverPlugins } = await import('./discovery.js');
       try {
         const name = installPlugin(source);
-        console.log(chalk.green(`✅ Plugin "${name}" installed successfully.`));
-        console.log(chalk.dim(`   Restart opencli to use the new commands.`));
+        await discoverPlugins();
+        console.log(chalk.green(`✅ Plugin "${name}" installed successfully. Commands are ready to use.`));
       } catch (err: any) {
         console.error(chalk.red(`Error: ${err.message}`));
         process.exitCode = 1;
@@ -258,6 +283,24 @@ export function runCli(BUILTIN_CLIS: string, USER_CLIS: string): void {
       }
     });
 
+  pluginCmd
+    .command('update')
+    .description('Update a plugin to the latest version')
+    .argument('<name>', 'Plugin name')
+    .action(async (name: string) => {
+      const { updatePlugin } = await import('./plugin.js');
+      const { discoverPlugins } = await import('./discovery.js');
+      try {
+        updatePlugin(name);
+        await discoverPlugins();
+        console.log(chalk.green(`✅ Plugin "${name}" updated successfully.`));
+      } catch (err: any) {
+        console.error(chalk.red(`Error: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+
   pluginCmd
     .command('list')
     .description('List installed plugins')

package/src/clis/bilibili/download.ts

@@ -8,18 +8,9 @@
  *   - yt-dlp must be installed: pip install yt-dlp
  */
 
-import * as fs from 'node:fs';
-import * as path from 'node:path';
 import { cli, Strategy } from '../../registry.js';
-import {
-  ytdlpDownload,
-  checkYtdlp,
-  sanitizeFilename,
-  getTempDir,
-  exportCookiesToNetscape,
-  formatCookieHeader,
-} from '../../download/index.js';
-import { DownloadProgressTracker, formatBytes } from '../../download/progress.js';
+import { checkYtdlp, sanitizeFilename } from '../../download/index.js';
+import { downloadMedia } from '../../download/media-download.js';
 
 cli({
   site: 'bilibili',
@@ -63,21 +54,8 @@ cli({
 
     const title = sanitizeFilename(data?.title || 'video');
 
-    // Extract cookies for authenticated downloads
-    const cookies = await page.getCookies({ domain: 'bilibili.com' });
-    const cookieString = formatCookieHeader(cookies);
-
-    // Create output directory
-    fs.mkdirSync(output, { recursive: true });
-
-    // Export cookies to Netscape format for yt-dlp
-    let cookiesFile: string | undefined;
-    if (cookies.length > 0) {
-      const tempDir = getTempDir();
-      fs.mkdirSync(tempDir, { recursive: true });
-      cookiesFile = path.join(tempDir, `bilibili_cookies_${Date.now()}.txt`);
-      exportCookiesToNetscape(cookies, cookiesFile);
-    }
+    // Extract cookies for yt-dlp
+    const browserCookies = await page.getCookies({ domain: 'bilibili.com' });
 
     // Build yt-dlp format string based on quality
     let format = 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best';
@@ -89,62 +67,26 @@ cli({
       format = 'bestvideo[height<=480][ext=mp4]+bestaudio[ext=m4a]/best[height<=480]';
     }
 
-    const destPath = path.join(output, `${bvid}_${title}.mp4`);
-
-    const tracker = new DownloadProgressTracker(1, true);
-    const progressBar = tracker.onFileStart(`${bvid}.mp4`, 0);
-
-    try {
-      const result = await ytdlpDownload(
-        `https://www.bilibili.com/video/${bvid}`,
-        destPath,
-        {
-          cookiesFile,
-          format,
-          extraArgs: [
-            '--merge-output-format', 'mp4',
-            '--embed-thumbnail',
-          ],
-          onProgress: (percent) => {
-            if (progressBar) progressBar.update(percent, 100);
-          },
-        },
-      );
-
-      if (progressBar) {
-        progressBar.complete(result.success, result.success ? formatBytes(result.size) : undefined);
-      }
-
-      tracker.onFileComplete(result.success);
-      tracker.finish();
-
-      // Cleanup cookies file
-      if (cookiesFile && fs.existsSync(cookiesFile)) {
-        fs.unlinkSync(cookiesFile);
-      }
-
-      return [{
-        bvid,
-        title: data?.title || 'video',
-        status: result.success ? 'success' : 'failed',
-        size: result.success ? formatBytes(result.size) : (result.error || 'unknown error'),
-      }];
-    } catch (err: any) {
-      if (progressBar) progressBar.fail(err.message);
-      tracker.onFileComplete(false);
-      tracker.finish();
-
-      // Cleanup cookies file
-      if (cookiesFile && fs.existsSync(cookiesFile)) {
-        fs.unlinkSync(cookiesFile);
-      }
-
-      return [{
-        bvid,
-        title: data?.title || 'video',
-        status: 'failed',
-        size: err.message,
-      }];
-    }
+    const videoUrl = `https://www.bilibili.com/video/${bvid}`;
+    const filename = `${bvid}_${title}.mp4`;
+
+    const results = await downloadMedia(
+      [{ type: 'video-ytdlp', url: videoUrl, filename }],
+      {
+        output,
+        browserCookies,
+        filenamePrefix: bvid,
+        ytdlpExtraArgs: ['-f', format, '--merge-output-format', 'mp4', '--embed-thumbnail'],
+      },
+    );
+
+    // Map results to bilibili-specific columns
+    const r = results[0] || { status: 'failed', size: '-' };
+    return [{
+      bvid,
+      title: data?.title || 'video',
+      status: r.status,
+      size: r.size,
+    }];
   },
 });

package/src/clis/bilibili/utils.ts

@@ -3,6 +3,7 @@
  */
 
 import type { IPage } from '../../types.js';
+import { AuthRequiredError } from '../../errors.js';
 
 const MIXIN_KEY_ENC_TAB = [
   46,47,18,2,53,8,23,32,15,50,10,31,58,3,45,35,27,43,5,49,
@@ -98,7 +99,7 @@ export async function fetchJson(page: IPage, url: string): Promise<any> {
 export async function getSelfUid(page: IPage): Promise<string> {
   const nav = await getNavData(page);
   const mid = nav?.data?.mid;
-  if (!mid) throw new Error('Not logged in to Bilibili');
+  if (!mid) throw new AuthRequiredError('bilibili.com');
   return String(mid);
 }
 

package/src/clis/chaoxing/assignments.ts

@@ -1,4 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
+import { AuthRequiredError } from '../../errors.js';
 import {
   getCourses, initSession, enterCourse, getTabIframeUrl,
   parseAssignmentsFromDom, sleep,
@@ -33,7 +34,7 @@ cli({
 
     // 2. Get courses
     const courses = await getCourses(page);
-    if (!courses.length) throw new Error('未获取到课程列表，请确认已登录学习通');
+    if (!courses.length) throw new AuthRequiredError('mooc2-ans.chaoxing.com', '未获取到课程列表');
 
     const filtered = courseFilter
       ? courses.filter(c => c.title.includes(courseFilter))

package/src/clis/doubao/ask.ts

@@ -0,0 +1,40 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { DOUBAO_DOMAIN, getDoubaoTranscriptLines, getDoubaoVisibleTurns, sendDoubaoMessage, waitForDoubaoResponse } from './common.js';
+
+export const askCommand = cli({
+  site: 'doubao',
+  name: 'ask',
+  description: 'Send a prompt and wait for the Doubao response',
+  domain: DOUBAO_DOMAIN,
+  strategy: Strategy.COOKIE,
+  browser: true,
+  navigateBefore: false,
+  timeoutSeconds: 180,
+  args: [
+    { name: 'text', required: true, positional: true, help: 'Prompt to send' },
+    { name: 'timeout', required: false, help: 'Max seconds to wait (default: 60)', default: '60' },
+  ],
+  columns: ['Role', 'Text'],
+  func: async (page: IPage, kwargs: any) => {
+    const text = kwargs.text as string;
+    const timeout = parseInt(kwargs.timeout as string, 10) || 60;
+    const beforeTurns = await getDoubaoVisibleTurns(page);
+    const beforeLines = await getDoubaoTranscriptLines(page);
+
+    await sendDoubaoMessage(page, text);
+    const response = await waitForDoubaoResponse(page, beforeLines, beforeTurns, text, timeout);
+
+    if (!response) {
+      return [
+        { Role: 'User', Text: text },
+        { Role: 'System', Text: `No response within ${timeout}s. Doubao may still be generating.` },
+      ];
+    }
+
+    return [
+      { Role: 'User', Text: text },
+      { Role: 'Assistant', Text: response },
+    ];
+  },
+});