@jackwener/opencli 1.3.1 → 1.3.3

package/dist/browser/stealth.js

@@ -0,0 +1,140 @@
+/**
+ * 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() {
+    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/dist/browser.test.js

@@ -1,5 +1,6 @@
 import { 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', () => {
     it('extracts tab entries from string snapshots', () => {
@@ -102,3 +103,48 @@ 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/dist/build-manifest.js

@@ -12,15 +12,13 @@ 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');
 const OUTPUT = path.resolve(__dirname, '..', 'dist', 'cli-manifest.json');
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
 function extractBalancedBlock(source, startIndex, openChar, closeChar) {
     let depth = 0;
     let quote = null;