@jackwener/opencli 1.3.3 → 1.4.1

package/dist/browser/page.js

@@ -12,6 +12,7 @@
 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';
@@ -25,18 +26,21 @@ 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) {
@@ -46,8 +50,7 @@ export class Page {
         try {
             await sendCommand('exec', {
                 code: generateStealthJs(),
-                ...this._workspaceOpt(),
-                ...this._tabOpt(),
+                ...this._cmdOpts(),
             });
         }
         catch {
@@ -59,15 +62,14 @@ export class Page {
             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
@@ -75,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 = {}) {
@@ -92,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;
@@ -132,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')
@@ -141,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 : [];
     }
     /**
@@ -216,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

@@ -8,8 +8,6 @@
  *
  * Inspired by puppeteer-extra-plugin-stealth.
  */
-/** Guard flag set on `window` to prevent double-injection. */
-export declare 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

package/dist/browser/stealth.js

@@ -8,8 +8,6 @@
  *
  * 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
@@ -18,16 +16,25 @@ export const STEALTH_GUARD = '__opencli_stealth_applied';
 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 });
+      // 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 → undefined
+      // 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: () => undefined,
+          get: () => false,
           configurable: true,
         });
       } catch {}
@@ -117,9 +124,17 @@ export function generateStealthJs() {
       //    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://', '__opencli'];
+        const _cdpPatterns = [
+          'puppeteer_evaluation_script',
+          'pptr:',
+          'debugger://',
+          '__playwright',
+          '__puppeteer',
+        ];
         if (_origDescriptor && _origDescriptor.get) {
           Object.defineProperty(Error.prototype, 'stack', {
             get: function () {

package/dist/browser.test.js

@@ -1,6 +1,5 @@
 import { describe, it, expect, vi } from 'vitest';
 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', () => {
@@ -136,7 +135,8 @@ describe('stealth anti-detection', () => {
     });
     it('includes guard flag to prevent double-injection', () => {
         const js = generateStealthJs();
-        expect(js).toContain(STEALTH_GUARD);
+        // 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'

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];