@jackwener/opencli 1.7.3 → 1.7.5

package/dist/src/registry.test.js

@@ -43,6 +43,17 @@ describe('cli() registration', () => {
         });
         expect(cmd.strategy).toBe(Strategy.PUBLIC);
     });
+    it('preserves LOCAL strategy on registration', () => {
+        const cmd = cli({
+            site: 'test-registry',
+            name: 'local-strategy',
+            description: 'reads local credentials',
+            strategy: Strategy.LOCAL,
+            browser: false,
+        });
+        expect(cmd.strategy).toBe(Strategy.LOCAL);
+        expect(cmd.browser).toBe(false);
+    });
     it('overwrites existing command on re-registration', () => {
         cli({ site: 'test-registry', name: 'overwrite', description: 'v1' });
         cli({ site: 'test-registry', name: 'overwrite', description: 'v2' });
@@ -148,6 +159,17 @@ describe('normalizeCommand (via registerCommand)', () => {
         expect(cmd.browser).toBe(false);
         expect(cmd.navigateBefore).toBeUndefined();
     });
+    it('LOCAL → browser false, navigateBefore undefined', () => {
+        registerCommand({
+            site: 'test-norm', name: 'local', description: '', args: [],
+            strategy: Strategy.LOCAL,
+        });
+        const cmd = getRegistry().get('test-norm/local');
+        expect(cmd.strategy).toBe(Strategy.LOCAL);
+        expect(strategyLabel(cmd)).toBe('local');
+        expect(cmd.browser).toBe(false);
+        expect(cmd.navigateBefore).toBeUndefined();
+    });
     it('explicit navigateBefore: false overrides COOKIE + domain', () => {
         registerCommand({
             site: 'test-norm', name: 'cookie-override', description: '', args: [],

package/dist/src/types.d.ts

@@ -58,9 +58,9 @@ export interface IPage {
     getFormState(): Promise<any>;
     wait(options: number | WaitOptions): Promise<void>;
     tabs(): Promise<any>;
-    closeTab?(index?: number): Promise<void>;
-    newTab?(): Promise<void>;
-    selectTab(index: number): Promise<void>;
+    closeTab?(target?: number | string): Promise<void>;
+    newTab?(url?: string): Promise<string | undefined>;
+    selectTab(target: number | string): Promise<void>;
     networkRequests(includeStatic?: boolean): Promise<any>;
     consoleMessages(level?: string): Promise<any>;
     scroll(direction?: string, amount?: number): Promise<void>;
@@ -72,7 +72,7 @@ export interface IPage {
     getInterceptedRequests(): Promise<any[]>;
     waitForCapture(timeout?: number): Promise<void>;
     screenshot(options?: ScreenshotOptions): Promise<string>;
-    startNetworkCapture?(pattern?: string): Promise<void>;
+    startNetworkCapture?(pattern?: string): Promise<boolean>;
     readNetworkCapture?(): Promise<unknown[]>;
     /**
      * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
@@ -89,10 +89,19 @@ export interface IPage {
     getCurrentUrl?(): Promise<string | null>;
     /** Returns the active page identity (targetId), or undefined if not yet resolved. */
     getActivePage?(): string | undefined;
-    /** @deprecated Use getActivePage() instead */
-    getActiveTabId?(): number | undefined;
+    /** Bind the page object to a specific page identity (targetId). */
+    setActivePage?(page?: string): void;
     /** Send a raw CDP command via chrome.debugger passthrough. */
     cdp?(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    /** List cross-origin iframe targets in snapshot order. */
+    frames?(): Promise<Array<{
+        index: number;
+        frameId: string;
+        url: string;
+        name: string;
+    }>>;
+    /** Evaluate JavaScript inside a cross-origin iframe identified by its frame index. */
+    evaluateInFrame?(js: string, frameIndex: number): Promise<unknown>;
     /** Click at native coordinates via CDP Input.dispatchMouseEvent. */
     nativeClick?(x: number, y: number): Promise<void>;
     /** Type text via CDP Input.insertText. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "1.7.3",
+  "version": "1.7.5",
   "publishConfig": {
     "access": "public"
   },

package/clis/twitter/lists-parser.js

@@ -1,77 +0,0 @@
-const MEMBER_PATTERNS = [
-    /([\d.,]+(?:\s?[KMB千萬万亿])?)\s*members?/i,
-    /([\d.,]+(?:\s?[KMB千萬万亿])?)\s*位成员/,
-];
-const FOLLOWER_PATTERNS = [
-    /([\d.,]+(?:\s?[KMB千萬万亿])?)\s*followers?/i,
-    /([\d.,]+(?:\s?[KMB千萬万亿])?)\s*位关注者/,
-];
-const PRIVATE_PATTERNS = [/\bprivate\b/i, /锁定列表/];
-const EMPTY_STATE_PATTERNS = [
-    /hasn't created any lists/i,
-    /has not created any lists/i,
-    /no lists yet/i,
-    /没有创建任何列表/,
-    /还没有创建任何列表/,
-];
-function normalizeText(text) {
-    return String(text || '').replace(/\s+/g, ' ').trim();
-}
-function matchMetric(text, patterns) {
-    for (const pattern of patterns) {
-        const match = text.match(pattern);
-        if (match)
-            return normalizeText(match[1]);
-    }
-    return '0';
-}
-function looksLikeMetadata(line) {
-    const text = normalizeText(line);
-    if (!text)
-        return true;
-    if (text.startsWith('@'))
-        return true;
-    if (MEMBER_PATTERNS.some((pattern) => pattern.test(text)))
-        return true;
-    if (FOLLOWER_PATTERNS.some((pattern) => pattern.test(text)))
-        return true;
-    if (PRIVATE_PATTERNS.some((pattern) => pattern.test(text)))
-        return true;
-    if (/^(public|pinned)$/i.test(text))
-        return true;
-    if (/^(lists?|你的列表)$/i.test(text))
-        return true;
-    return false;
-}
-export function parseListCards(cards) {
-    const seen = new Set();
-    const results = [];
-    for (const card of cards || []) {
-        const href = normalizeText(card?.href);
-        const rawText = String(card?.text || '');
-        if (!href || seen.has(href))
-            continue;
-        seen.add(href);
-        const text = normalizeText(rawText);
-        if (!text)
-            continue;
-        const lines = rawText
-            .split('\n')
-            .map((line) => normalizeText(line))
-            .filter(Boolean);
-        const name = lines.find((line) => !looksLikeMetadata(line));
-        if (!name)
-            continue;
-        results.push({
-            name,
-            members: matchMetric(text, MEMBER_PATTERNS),
-            followers: matchMetric(text, FOLLOWER_PATTERNS),
-            mode: PRIVATE_PATTERNS.some((pattern) => pattern.test(text)) ? 'private' : 'public',
-        });
-    }
-    return results;
-}
-export function isEmptyListsState(text) {
-    const normalized = normalizeText(text);
-    return EMPTY_STATE_PATTERNS.some((pattern) => pattern.test(normalized));
-}

package/clis/twitter/lists.d.ts

@@ -1,5 +0,0 @@
-import { Argument, Column } from '@jackwener/opencli/types';
-declare const args: Argument[];
-declare const columns: Column[];
-export { args, columns };
-export default {};

package/dist/src/cascade.d.ts

@@ -1,46 +0,0 @@
-/**
- * Strategy Cascade: automatic strategy downgrade chain.
- *
- * Probes an API endpoint starting from the simplest strategy (PUBLIC)
- * and automatically downgrades through the strategy tiers until one works:
- *
- *   PUBLIC → COOKIE → HEADER → INTERCEPT → UI
- *
- * This eliminates the need for manual strategy selection — the system
- * automatically finds the minimum-privilege strategy that works.
- */
-import { Strategy } from './registry.js';
-import type { IPage } from './types.js';
-interface ProbeResult {
-    strategy: Strategy;
-    success: boolean;
-    statusCode?: number;
-    hasData?: boolean;
-    error?: string;
-    responsePreview?: string;
-}
-interface CascadeResult {
-    bestStrategy: Strategy;
-    probes: ProbeResult[];
-    confidence: number;
-}
-/**
- * Probe an endpoint with a specific strategy.
- * Returns whether the probe succeeded and basic response info.
- */
-export declare function probeEndpoint(page: IPage, url: string, strategy: Strategy, _opts?: {
-    timeout?: number;
-}): Promise<ProbeResult>;
-/**
- * Run the cascade: try each strategy in order until one works.
- * Returns the simplest working strategy.
- */
-export declare function cascadeProbe(page: IPage, url: string, opts?: {
-    maxStrategy?: Strategy;
-    timeout?: number;
-}): Promise<CascadeResult>;
-/**
- * Render cascade results for display.
- */
-export declare function renderCascadeResult(result: CascadeResult): string;
-export {};

package/dist/src/cascade.js

@@ -1,135 +0,0 @@
-/**
- * Strategy Cascade: automatic strategy downgrade chain.
- *
- * Probes an API endpoint starting from the simplest strategy (PUBLIC)
- * and automatically downgrades through the strategy tiers until one works:
- *
- *   PUBLIC → COOKIE → HEADER → INTERCEPT → UI
- *
- * This eliminates the need for manual strategy selection — the system
- * 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,
-    Strategy.COOKIE,
-    Strategy.HEADER,
-    Strategy.INTERCEPT,
-    Strategy.UI,
-];
-/**
- * Build the JavaScript source for a fetch probe.
- * Shared logic for PUBLIC, COOKIE, and HEADER strategies.
- */
-function buildFetchProbeJs(url, opts) {
-    const credentialsLine = opts.credentials ? `credentials: 'include',` : '';
-    const headerSetup = opts.extractCsrf
-        ? `
-      const cookies = document.cookie.split(';').map(c => c.trim());
-      const csrf = cookies.find(c => c.startsWith('ct0=') || c.startsWith('csrf_token=') || c.startsWith('_csrf='))?.split('=').slice(1).join('=');
-      const headers = {};
-      if (csrf) { headers['X-Csrf-Token'] = csrf; headers['X-XSRF-Token'] = csrf; }
-    `
-        : 'const headers = {};';
-    return `
-    async () => {
-      try {
-        ${headerSetup}
-        const resp = await fetch(${JSON.stringify(url)}, {
-          ${credentialsLine}
-          headers
-        });
-        const status = resp.status;
-        if (!resp.ok) return { status, ok: false };
-        const text = await resp.text();
-        let hasData = false;
-        try {
-          const json = JSON.parse(text);
-          hasData = !!json && (Array.isArray(json) ? json.length > 0 :
-            typeof json === 'object' && Object.keys(json).length > 0);
-          // Check for API-level error codes (common in Chinese sites)
-          if (json.code !== undefined && json.code !== 0) hasData = false;
-        } catch {}
-        return { status, ok: true, hasData, preview: text.slice(0, 200) };
-      } catch (e) { return { ok: false, error: e.message }; }
-    }
-  `;
-}
-/** Strategy → fetch probe options mapping for strategies that support probing. */
-const PROBE_OPTIONS = {
-    [Strategy.PUBLIC]: {},
-    [Strategy.COOKIE]: { credentials: true },
-    [Strategy.HEADER]: { credentials: true, extractCsrf: true },
-};
-/**
- * Probe an endpoint with a specific strategy.
- * Returns whether the probe succeeded and basic response info.
- */
-export async function probeEndpoint(page, url, strategy, _opts = {}) {
-    const result = { strategy, success: false };
-    try {
-        const opts = PROBE_OPTIONS[strategy];
-        if (opts) {
-            const resp = (await page.evaluate(buildFetchProbeJs(url, opts)));
-            result.statusCode = resp?.status;
-            result.success = !!(resp?.ok && resp?.hasData);
-            result.hasData = resp?.hasData;
-            result.responsePreview = resp?.preview;
-        }
-        else {
-            // INTERCEPT / UI require site-specific implementation.
-            result.error = `Strategy ${strategy} requires site-specific implementation`;
-        }
-    }
-    catch (err) {
-        result.success = false;
-        result.error = getErrorMessage(err);
-    }
-    return result;
-}
-/**
- * Run the cascade: try each strategy in order until one works.
- * Returns the simplest working strategy.
- */
-export async function cascadeProbe(page, url, opts = {}) {
-    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];
-        const probe = await probeEndpoint(page, url, strategy, opts);
-        probes.push(probe);
-        if (probe.success) {
-            return {
-                bestStrategy: strategy,
-                probes,
-                confidence: 1.0 - (i * 0.1), // Higher confidence for simpler strategies
-            };
-        }
-    }
-    // None worked — default to COOKIE (most common for logged-in sites)
-    return {
-        bestStrategy: Strategy.COOKIE,
-        probes,
-        confidence: 0.3,
-    };
-}
-/**
- * Render cascade results for display.
- */
-export function renderCascadeResult(result) {
-    const lines = [
-        `Strategy Cascade: ${result.bestStrategy} (${(result.confidence * 100).toFixed(0)}% confidence)`,
-    ];
-    for (const probe of result.probes) {
-        const icon = probe.success ? '✅' : '❌';
-        const status = probe.statusCode ? ` [${probe.statusCode}]` : '';
-        const err = probe.error ? ` — ${probe.error}` : '';
-        lines.push(`  ${icon} ${probe.strategy}${status}${err}`);
-    }
-    return lines.join('\n');
-}

package/dist/src/explore.d.ts

@@ -1,99 +0,0 @@
-/**
- * Deep Explore: intelligent API discovery with response analysis.
- *
- * Navigates to the target URL, auto-scrolls to trigger lazy loading,
- * captures network traffic, analyzes JSON responses, and automatically
- * infers CLI capabilities from discovered API endpoints.
- */
-import type { IBrowserFactory } from './runtime.js';
-export declare function detectSiteName(url: string): string;
-export declare function slugify(value: string): string;
-interface InferredCapability {
-    name: string;
-    description: string;
-    strategy: string;
-    endpoint: string;
-    itemPath: string | null;
-    recommendedColumns: string[];
-    recommendedArgs: Array<{
-        name: string;
-        type: string;
-        required: boolean;
-        default?: unknown;
-    }>;
-    storeHint?: {
-        store: string;
-        action: string;
-    };
-}
-export interface ExploreManifest {
-    site: string;
-    target_url: string;
-    final_url: string;
-    title: string;
-    framework: Record<string, boolean>;
-    stores: Array<{
-        type: DiscoveredStore['type'];
-        id: string;
-        actions: string[];
-    }>;
-    top_strategy: string;
-    explored_at?: string;
-}
-export interface ExploreAuthSummary {
-    top_strategy: string;
-    indicators: string[];
-    framework: Record<string, boolean>;
-}
-export interface ExploreEndpointArtifact {
-    pattern: string;
-    method: string;
-    url: string;
-    status: number | null;
-    contentType: string;
-    queryParams: string[];
-    itemPath: string | null;
-    itemCount: number;
-    detectedFields: Record<string, string>;
-    authIndicators: string[];
-}
-export interface ExploreResult {
-    site: string;
-    target_url: string;
-    final_url: string;
-    title: string;
-    framework: Record<string, boolean>;
-    stores: DiscoveredStore[];
-    top_strategy: string;
-    endpoint_count: number;
-    api_endpoint_count: number;
-    capabilities: InferredCapability[];
-    auth_indicators: string[];
-    out_dir: string;
-}
-export interface ExploreBundle {
-    manifest: ExploreManifest;
-    endpoints: ExploreEndpointArtifact[];
-    capabilities: InferredCapability[];
-    auth: ExploreAuthSummary;
-}
-export interface DiscoveredStore {
-    type: 'pinia' | 'vuex';
-    id: string;
-    actions: string[];
-    stateKeys: string[];
-}
-export declare function exploreUrl(url: string, opts: {
-    BrowserFactory: new () => IBrowserFactory;
-    site?: string;
-    goal?: string;
-    authenticated?: boolean;
-    outDir?: string;
-    waitSeconds?: number;
-    query?: string;
-    clickLabels?: string[];
-    auto?: boolean;
-    workspace?: string;
-}): Promise<ExploreResult>;
-export declare function renderExploreSummary(result: ExploreResult): string;
-export {};