@jackwener/opencli 1.3.2 → 1.4.0

package/dist/browser/index.d.ts

@@ -5,11 +5,12 @@
  * External code should import from './browser/index.js' (or './browser.js' via Node resolution).
  */
 export { Page } from './page.js';
-export { BrowserBridge, BrowserBridge as PlaywrightMCP } from './mcp.js';
+export { BrowserBridge } from './mcp.js';
 export { CDPBridge } from './cdp.js';
 export { isDaemonRunning } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
-export type { SnapshotOptions } from './dom-snapshot.js';
+export { generateStealthJs } from './stealth.js';
+export type { DomSnapshotOptions } from './dom-snapshot.js';
 import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
 import { withTimeoutMs } from '../runtime.js';
 export declare const __test__: {

package/dist/browser/index.js

@@ -5,10 +5,11 @@
  * External code should import from './browser/index.js' (or './browser.js' via Node resolution).
  */
 export { Page } from './page.js';
-export { BrowserBridge, BrowserBridge as PlaywrightMCP } from './mcp.js';
+export { BrowserBridge } from './mcp.js';
 export { CDPBridge } from './cdp.js';
 export { isDaemonRunning } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
+export { generateStealthJs } from './stealth.js';
 import { extractTabEntries, diffTabIndexes, appendLimited } from './tabs.js';
 import { __test__ as cdpTest } from './cdp.js';
 import { withTimeoutMs } from '../runtime.js';

package/dist/browser/mcp.d.ts

@@ -18,5 +18,3 @@ export declare class BrowserBridge {
     close(): Promise<void>;
     private _ensureDaemon;
 }
-/** @deprecated Use BrowserBridge instead */
-export declare const PlaywrightMCP: typeof BrowserBridge;

package/dist/browser/mcp.js

@@ -7,6 +7,7 @@ import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { Page } from './page.js';
 import { isDaemonRunning, isExtensionConnected } from './daemon-client.js';
+import { DEFAULT_DAEMON_PORT } from '../constants.js';
 const DAEMON_SPAWN_TIMEOUT = 10000; // 10s to wait for daemon + extension
 /**
  * Browser factory: manages daemon lifecycle and provides IPage instances.
@@ -95,8 +96,6 @@ export class BrowserBridge {
         }
         throw new Error('Failed to start opencli daemon. Try running manually:\n' +
             `  node ${daemonPath}\n` +
-            'Make sure port 19825 is available.');
+            `Make sure port ${DEFAULT_DAEMON_PORT} is available.`);
     }
 }
-/** @deprecated Use BrowserBridge instead */
-export const PlaywrightMCP = BrowserBridge;

package/dist/browser/page.d.ts

@@ -18,9 +18,10 @@ export declare class Page implements IPage {
     constructor(workspace?: string);
     /** Active tab ID, set after navigate and used in all subsequent commands */
     private _tabId;
-    /** Helper: spread tabId into command params if we have one */
-    private _tabOpt;
-    private _workspaceOpt;
+    /** Helper: spread workspace into command params */
+    private _wsOpt;
+    /** Helper: spread workspace + tabId into command params */
+    private _cmdOpts;
     goto(url: string, options?: {
         waitUntil?: 'load' | 'none';
         settleMs?: number;

package/dist/browser/page.js

@@ -12,7 +12,9 @@
 import { formatSnapshot } from '../snapshotFormatter.js';
 import { sendCommand } from './daemon-client.js';
 import { wrapForEval } from './utils.js';
+import { saveBase64ToFile } from '../utils.js';
 import { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
+import { generateStealthJs } from './stealth.js';
 import { clickJs, typeTextJs, pressKeyJs, waitForTextJs, scrollJs, autoScrollJs, networkRequestsJs, waitForDomStableJs, } from './dom-helpers.js';
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
@@ -24,38 +26,50 @@ export class Page {
     }
     /** 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() {
+    /** Helper: spread workspace into command params */
+    _wsOpt() {
         return { workspace: this.workspace };
     }
+    /** Helper: spread workspace + tabId into command params */
+    _cmdOpts() {
+        return {
+            workspace: this.workspace,
+            ...(this._tabId !== undefined && { tabId: this._tabId }),
+        };
+    }
     async goto(url, options) {
         const result = await sendCommand('navigate', {
             url,
-            ...this._workspaceOpt(),
-            ...this._tabOpt(),
+            ...this._cmdOpts(),
         });
         // Remember the tabId for subsequent exec calls
         if (result?.tabId) {
             this._tabId = result.tabId;
         }
+        // Inject stealth anti-detection patches (guard flag prevents double-injection).
+        try {
+            await sendCommand('exec', {
+                code: generateStealthJs(),
+                ...this._cmdOpts(),
+            });
+        }
+        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') {
             const maxMs = options?.settleMs ?? 1000;
             await sendCommand('exec', {
                 code: waitForDomStableJs(maxMs, Math.min(500, maxMs)),
-                ...this._workspaceOpt(),
-                ...this._tabOpt(),
+                ...this._cmdOpts(),
             });
         }
     }
     /** Close the automation window in the extension */
     async closeWindow() {
         try {
-            await sendCommand('close-window', { ...this._workspaceOpt() });
+            await sendCommand('close-window', { ...this._wsOpt() });
         }
         catch {
             // Window may already be closed or daemon may be down
@@ -63,10 +77,10 @@ export class Page {
     }
     async evaluate(js) {
         const code = wrapForEval(js);
-        return sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+        return sendCommand('exec', { code, ...this._cmdOpts() });
     }
     async getCookies(opts = {}) {
-        const result = await sendCommand('cookies', { ...this._workspaceOpt(), ...opts });
+        const result = await sendCommand('cookies', { ...this._wsOpt(), ...opts });
         return Array.isArray(result) ? result : [];
     }
     async snapshot(opts = {}) {
@@ -80,7 +94,7 @@ export class Page {
             bboxDedup: true,
         });
         try {
-            const result = await sendCommand('exec', { code: snapshotJs, ...this._workspaceOpt(), ...this._tabOpt() });
+            const result = await sendCommand('exec', { code: snapshotJs, ...this._cmdOpts() });
             // The advanced engine already produces a clean, pruned, LLM-friendly output.
             // Do NOT pass through formatSnapshot — its format is incompatible.
             return result;
@@ -120,7 +134,7 @@ export class Page {
         return buildTree(document.body, 0);
       })()
     `;
-        const raw = await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+        const raw = await sendCommand('exec', { code, ...this._cmdOpts() });
         if (opts.raw)
             return raw;
         if (typeof raw === 'string')
@@ -129,62 +143,62 @@ export class Page {
     }
     async click(ref) {
         const code = clickJs(ref);
-        await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+        await sendCommand('exec', { code, ...this._cmdOpts() });
     }
     async typeText(ref, text) {
         const code = typeTextJs(ref, text);
-        await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+        await sendCommand('exec', { code, ...this._cmdOpts() });
     }
     async pressKey(key) {
         const code = pressKeyJs(key);
-        await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+        await sendCommand('exec', { code, ...this._cmdOpts() });
     }
     async scrollTo(ref) {
         const code = scrollToRefJs(ref);
-        return sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+        return sendCommand('exec', { code, ...this._cmdOpts() });
     }
     async getFormState() {
         const code = getFormStateJs();
-        return (await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() }));
+        return (await sendCommand('exec', { code, ...this._cmdOpts() }));
     }
     async wait(options) {
         if (typeof options === 'number') {
             await new Promise(resolve => setTimeout(resolve, options * 1000));
             return;
         }
-        if (options.time) {
+        if (typeof options.time === 'number') {
             await new Promise(resolve => setTimeout(resolve, options.time * 1000));
             return;
         }
         if (options.text) {
             const timeout = (options.timeout ?? 30) * 1000;
             const code = waitForTextJs(options.text, timeout);
-            await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+            await sendCommand('exec', { code, ...this._cmdOpts() });
         }
     }
     async tabs() {
-        const result = await sendCommand('tabs', { op: 'list', ...this._workspaceOpt() });
+        const result = await sendCommand('tabs', { op: 'list', ...this._wsOpt() });
         return Array.isArray(result) ? result : [];
     }
     async closeTab(index) {
-        await sendCommand('tabs', { op: 'close', ...this._workspaceOpt(), ...(index !== undefined ? { index } : {}) });
+        await sendCommand('tabs', { op: 'close', ...this._wsOpt(), ...(index !== undefined ? { index } : {}) });
         // Invalidate cached tabId — the closed tab might have been our active one.
         // We can't know for sure (close-by-index doesn't return tabId), so reset.
         this._tabId = undefined;
     }
     async newTab() {
-        const result = await sendCommand('tabs', { op: 'new', ...this._workspaceOpt() });
+        const result = await sendCommand('tabs', { op: 'new', ...this._wsOpt() });
         if (result?.tabId)
             this._tabId = result.tabId;
     }
     async selectTab(index) {
-        const result = await sendCommand('tabs', { op: 'select', index, ...this._workspaceOpt() });
+        const result = await sendCommand('tabs', { op: 'select', index, ...this._wsOpt() });
         if (result?.selected)
             this._tabId = result.selected;
     }
     async networkRequests(includeStatic = false) {
         const code = networkRequestsJs(includeStatic);
-        const result = await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+        const result = await sendCommand('exec', { code, ...this._cmdOpts() });
         return Array.isArray(result) ? result : [];
     }
     /**
@@ -204,30 +218,25 @@ export class Page {
      */
     async screenshot(options = {}) {
         const base64 = await sendCommand('screenshot', {
-            ...this._workspaceOpt(),
+            ...this._cmdOpts(),
             format: options.format,
             quality: options.quality,
             fullPage: options.fullPage,
-            ...this._tabOpt(),
         });
         if (options.path) {
-            const fs = await import('node:fs');
-            const path = await import('node:path');
-            const dir = path.dirname(options.path);
-            await fs.promises.mkdir(dir, { recursive: true });
-            await fs.promises.writeFile(options.path, Buffer.from(base64, 'base64'));
+            await saveBase64ToFile(base64, options.path);
         }
         return base64;
     }
     async scroll(direction = 'down', amount = 500) {
         const code = scrollJs(direction, amount);
-        await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+        await sendCommand('exec', { code, ...this._cmdOpts() });
     }
     async autoScroll(options = {}) {
         const times = options.times ?? 3;
         const delayMs = options.delayMs ?? 2000;
         const code = autoScrollJs(times, delayMs);
-        await sendCommand('exec', { code, ...this._workspaceOpt(), ...this._tabOpt() });
+        await sendCommand('exec', { code, ...this._cmdOpts() });
     }
     async installInterceptor(pattern) {
         const { generateInterceptorJs } = await import('../interceptor.js');

package/dist/browser/stealth.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+/**
+ * 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 declare function generateStealthJs(): string;

package/dist/browser/stealth.js

@@ -0,0 +1,155 @@
+/**
+ * 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.
+ */
+/**
+ * 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: prevent double-injection across separate CDP evaluations.
+      // We cannot use a closure variable (each eval is a fresh scope), and
+      // window properties / Symbols are discoverable by anti-bot scripts.
+      // Instead, stash the flag in a non-enumerable getter on a built-in
+      // prototype that fingerprinters are unlikely to scan.
+      const _gProto = EventTarget.prototype;
+      const _gKey = '__lsn';  // looks like an internal listener cache
+      if (_gProto[_gKey]) return 'skipped';
+      try {
+        Object.defineProperty(_gProto, _gKey, { value: true, enumerable: false, configurable: true });
+      } catch {}
+
+      // 1. navigator.webdriver → false
+      //    Most common check; Playwright/Puppeteer/CDP set this to true.
+      //    Real Chrome returns false (not undefined) — returning undefined is
+      //    itself a detection signal for advanced fingerprinters.
+      try {
+        Object.defineProperty(navigator, 'webdriver', {
+          get: () => false,
+          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.
+      //    We use generic protocol patterns instead of product-specific names to
+      //    also catch our own injected code frames without leaking identifiers.
+      try {
+        const _origDescriptor = Object.getOwnPropertyDescriptor(Error.prototype, 'stack');
+        const _cdpPatterns = [
+          'puppeteer_evaluation_script',
+          'pptr:',
+          'debugger://',
+          '__playwright',
+          '__puppeteer',
+        ];
+        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,5 @@
 import { describe, it, expect, vi } from 'vitest';
-import { BrowserBridge, __test__ } from './browser/index.js';
+import { BrowserBridge, __test__, generateStealthJs } from './browser/index.js';
 import * as daemonClient from './browser/daemon-client.js';
 describe('browser helpers', () => {
     it('extracts tab entries from string snapshots', () => {
@@ -102,3 +102,49 @@ 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();
+        // Guard uses a non-enumerable property on a built-in prototype
+        expect(js).toContain("EventTarget.prototype");
+        // 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

@@ -16,9 +16,7 @@ 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);
-}
+import { isRecord } from './utils.js';
 function extractBalancedBlock(source, startIndex, openChar, closeChar) {
     let depth = 0;
     let quote = null;
@@ -112,7 +110,9 @@ export function parseTsArgsBlock(argsBlock) {
             help: helpMatch?.[1] ?? '',
             choices: parseInlineChoices(body),
         });
-        cursor = objectStart + body.length + 2;
+        cursor = objectStart + body.length;
+        if (cursor <= objectStart)
+            break; // safety: prevent infinite loop
     }
     return args;
 }
@@ -208,10 +208,16 @@ export function scanTs(filePath, site) {
         if (argsBlock) {
             entry.args = parseTsArgsBlock(argsBlock);
         }
-        // Extract navigateBefore: false
-        const navMatch = src.match(/navigateBefore\s*:\s*(true|false)/);
-        if (navMatch)
-            entry.navigateBefore = navMatch[1] === 'true' ? true : false;
+        // Extract navigateBefore: false / true / 'https://...'
+        const navBoolMatch = src.match(/navigateBefore\s*:\s*(true|false)/);
+        if (navBoolMatch) {
+            entry.navigateBefore = navBoolMatch[1] === 'true';
+        }
+        else {
+            const navStringMatch = src.match(/navigateBefore\s*:\s*['"`]([^'"`]+)['"`]/);
+            if (navStringMatch)
+                entry.navigateBefore = navStringMatch[1];
+        }
         return entry;
     }
     catch (err) {
@@ -226,7 +232,7 @@ export function scanTs(filePath, site) {
  */
 export function shouldReplaceManifestEntry(current, next) {
     if (current.type === next.type)
-        return true;
+        return false;
     return current.type === 'yaml' && next.type === 'ts';
 }
 export function buildManifest() {

package/dist/build-manifest.test.js

@@ -113,4 +113,16 @@ describe('manifest helper rules', () => {
         fs.writeFileSync(file, `export function helper() { return 'noop'; }`);
         expect(scanTs(file, 'demo')).toBeNull();
     });
+    it('keeps literal domain and navigateBefore for TS adapters', () => {
+        const file = path.join(process.cwd(), 'src', 'clis', 'xueqiu', 'fund-holdings.ts');
+        const entry = scanTs(file, 'xueqiu');
+        expect(entry).toMatchObject({
+            site: 'xueqiu',
+            name: 'fund-holdings',
+            domain: 'danjuanfunds.com',
+            navigateBefore: 'https://danjuanfunds.com/my-money',
+            type: 'ts',
+            modulePath: 'xueqiu/fund-holdings.js',
+        });
+    });
 });

package/dist/cascade.js

@@ -10,6 +10,7 @@
  * automatically finds the minimum-privilege strategy that works.
  */
 import { Strategy } from './registry.js';
+import { getErrorMessage } from './errors.js';
 /** Strategy cascade order (simplest → most complex) */
 const CASCADE_ORDER = [
     Strategy.PUBLIC,
@@ -98,7 +99,7 @@ export async function probeEndpoint(page, url, strategy, _opts = {}) {
     }
     catch (err) {
         result.success = false;
-        result.error = err.message ?? String(err);
+        result.error = getErrorMessage(err);
     }
     return result;
 }
@@ -107,9 +108,10 @@ export async function probeEndpoint(page, url, strategy, _opts = {}) {
  * Returns the simplest working strategy.
  */
 export async function cascadeProbe(page, url, opts = {}) {
-    const maxIdx = opts.maxStrategy
+    const rawIdx = opts.maxStrategy
         ? CASCADE_ORDER.indexOf(opts.maxStrategy)
         : CASCADE_ORDER.indexOf(Strategy.HEADER); // Don't auto-try INTERCEPT/UI
+    const maxIdx = rawIdx === -1 ? CASCADE_ORDER.indexOf(Strategy.HEADER) : rawIdx;
     const probes = [];
     for (let i = 0; i <= Math.min(maxIdx, CASCADE_ORDER.length - 1); i++) {
         const strategy = CASCADE_ORDER[i];