@jackwener/opencli 1.7.4 → 1.7.6

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 {};

package/dist/src/explore.js

@@ -1,402 +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 * as fs from 'node:fs';
-import * as path from 'node:path';
-import { DEFAULT_BROWSER_EXPLORE_TIMEOUT, browserSession, runWithTimeout } from './runtime.js';
-import { LIMIT_PARAMS } from './constants.js';
-import { detectFramework } from './scripts/framework.js';
-import { discoverStores } from './scripts/store.js';
-import { interactFuzz } from './scripts/interact.js';
-import { log } from './logger.js';
-import { urlToPattern, findArrayPath, flattenFields, detectFieldRoles, inferCapabilityName, inferStrategy, detectAuthFromHeaders, classifyQueryParams, isNoiseUrl, } from './analysis.js';
-// ── Site name detection ────────────────────────────────────────────────────
-const KNOWN_SITE_ALIASES = {
-    'x.com': 'twitter', 'twitter.com': 'twitter',
-    'news.ycombinator.com': 'hackernews',
-    'www.zhihu.com': 'zhihu', 'www.bilibili.com': 'bilibili',
-    'search.bilibili.com': 'bilibili',
-    'www.v2ex.com': 'v2ex', 'www.reddit.com': 'reddit',
-    'www.xiaohongshu.com': 'xiaohongshu', 'www.douban.com': 'douban',
-    'www.weibo.com': 'weibo', 'www.bbc.com': 'bbc',
-};
-export function detectSiteName(url) {
-    try {
-        const host = new URL(url).hostname.toLowerCase();
-        if (host in KNOWN_SITE_ALIASES)
-            return KNOWN_SITE_ALIASES[host];
-        const parts = host.split('.').filter(p => p && p !== 'www');
-        if (parts.length >= 2) {
-            if (['uk', 'jp', 'cn', 'com'].includes(parts[parts.length - 1]) && parts.length >= 3) {
-                return slugify(parts[parts.length - 3]);
-            }
-            return slugify(parts[parts.length - 2]);
-        }
-        return parts[0] ? slugify(parts[0]) : 'site';
-    }
-    catch {
-        return 'site';
-    }
-}
-export function slugify(value) {
-    return value.trim().toLowerCase().replace(/[^a-zA-Z0-9]+/g, '-').replace(/^-|-$/g, '') || 'site';
-}
-/**
- * Parse raw network output from browser page.
- * Handles text format: [GET] url => [200]
- */
-function parseNetworkRequests(raw) {
-    if (typeof raw === 'string') {
-        const entries = [];
-        for (const line of raw.split('\n')) {
-            // Format: [GET] URL => [200]
-            const m = line.match(/\[?(GET|POST|PUT|DELETE|PATCH|OPTIONS)\]?\s+(\S+)\s*(?:=>|→)\s*\[?(\d+)\]?/i);
-            if (m) {
-                const [, method, url, status] = m;
-                entries.push({
-                    method: method.toUpperCase(), url, status: status ? parseInt(status) : null,
-                    contentType: (url.includes('/api/') || url.includes('/x/') || url.endsWith('.json')) ? 'application/json' : '',
-                });
-            }
-        }
-        return entries;
-    }
-    if (Array.isArray(raw)) {
-        return raw.filter(e => e && typeof e === 'object').map(e => {
-            // Handle both legacy shape (status/contentType/responseBody) and
-            // extension/CDP capture shape (responseStatus/responseContentType/responsePreview)
-            let body = e.responseBody;
-            if (body === undefined && e.responsePreview !== undefined) {
-                const preview = e.responsePreview;
-                if (typeof preview === 'string') {
-                    try {
-                        body = JSON.parse(preview);
-                    }
-                    catch {
-                        body = preview;
-                    }
-                }
-            }
-            return {
-                method: (e.method ?? 'GET').toUpperCase(),
-                url: String(e.url ?? e.request?.url ?? e.requestUrl ?? ''),
-                status: e.status ?? e.responseStatus ?? e.statusCode ?? null,
-                contentType: e.contentType ?? e.responseContentType ?? e.response?.contentType ?? '',
-                responseBody: body, requestHeaders: e.requestHeaders,
-            };
-        });
-    }
-    return [];
-}
-function analyzeResponseBody(body) {
-    if (!body || typeof body !== 'object')
-        return null;
-    const result = findArrayPath(body);
-    if (!result)
-        return null;
-    const sample = result.items[0];
-    const sampleFields = sample && typeof sample === 'object' ? flattenFields(sample, '', 2) : [];
-    const detectedFields = detectFieldRoles(sampleFields);
-    return { itemPath: result.path || null, itemCount: result.items.length, detectedFields, sampleFields };
-}
-function isBooleanRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value)
-        && Object.values(value).every(v => typeof v === 'boolean');
-}
-/**
- * Deterministic sort key for endpoint ordering — transparent, observable signals only.
- * Used by generate/synthesize to pick a stable default candidate.
- * Not exposed externally; AI agents see the raw metadata and decide for themselves.
- */
-function endpointSortKey(ep) {
-    let k = 0;
-    // Prefer endpoints with array data (list APIs are more useful for automation)
-    const items = ep.responseAnalysis?.itemCount ?? 0;
-    if (items > 0)
-        k += 100 + Math.min(items, 50);
-    // Prefer endpoints with detected semantic fields
-    k += Object.keys(ep.responseAnalysis?.detectedFields ?? {}).length * 10;
-    // Prefer API-style paths
-    if (ep.pattern.includes('/api/') || ep.pattern.includes('/x/'))
-        k += 5;
-    // Prefer endpoints with query params (more likely to be parameterized APIs)
-    if (ep.hasSearchParam || ep.hasPaginationParam || ep.hasLimitParam)
-        k += 5;
-    return k;
-}
-/** Check whether an endpoint carries useful structured data (any JSON response, not noise). */
-function isUsefulEndpoint(ep) {
-    if (isNoiseUrl(ep.url))
-        return false;
-    return ep.contentType.includes('json');
-}
-// ── Framework detection ────────────────────────────────────────────────────
-const FRAMEWORK_DETECT_JS = detectFramework.toString();
-// ── Store discovery ────────────────────────────────────────────────────────
-const STORE_DISCOVER_JS = discoverStores.toString();
-// ── Auto-Interaction (Fuzzing) ─────────────────────────────────────────────
-const INTERACT_FUZZ_JS = interactFuzz.toString();
-// ── Analysis helpers (extracted from exploreUrl) ───────────────────────────
-/** Filter and deduplicate network endpoints, keeping only useful structured-data APIs. */
-function analyzeEndpoints(networkEntries) {
-    const seen = new Map();
-    for (const entry of networkEntries) {
-        if (!entry.url)
-            continue;
-        const ct = entry.contentType.toLowerCase();
-        if (ct.includes('image/') || ct.includes('font/') || ct.includes('css') || ct.includes('javascript') || ct.includes('wasm'))
-            continue;
-        if (entry.status && entry.status >= 400)
-            continue;
-        const pattern = urlToPattern(entry.url);
-        const key = `${entry.method}:${pattern}`;
-        if (seen.has(key))
-            continue;
-        const { params: qp, hasSearch, hasPagination, hasLimit } = classifyQueryParams(entry.url);
-        const ep = {
-            pattern, method: entry.method, url: entry.url, status: entry.status, contentType: ct,
-            queryParams: qp, hasSearchParam: hasSearch,
-            hasPaginationParam: hasPagination,
-            hasLimitParam: hasLimit || qp.some(p => LIMIT_PARAMS.has(p)),
-            authIndicators: detectAuthFromHeaders(entry.requestHeaders),
-            responseAnalysis: entry.responseBody ? analyzeResponseBody(entry.responseBody) : null,
-        };
-        seen.set(key, ep);
-    }
-    // Filter to useful endpoints; deterministic ordering by observable metadata signals
-    const analyzed = [...seen.values()]
-        .filter(isUsefulEndpoint)
-        .sort((a, b) => endpointSortKey(b) - endpointSortKey(a));
-    return { analyzed, totalCount: seen.size };
-}
-/** Infer CLI capabilities from analyzed endpoints. */
-function inferCapabilitiesFromEndpoints(endpoints, stores, opts) {
-    const capabilities = [];
-    const usedNames = new Set();
-    for (const ep of endpoints.slice(0, 8)) {
-        let capName = inferCapabilityName(ep.url, opts.goal);
-        if (usedNames.has(capName)) {
-            const suffix = ep.pattern.split('/').filter(s => s && !s.startsWith('{') && !s.includes('.')).pop();
-            capName = suffix ? `${capName}_${suffix}` : `${capName}_${usedNames.size}`;
-        }
-        usedNames.add(capName);
-        const cols = [];
-        if (ep.responseAnalysis) {
-            for (const role of ['title', 'url', 'author', 'score', 'time']) {
-                if (ep.responseAnalysis.detectedFields[role])
-                    cols.push(role);
-            }
-        }
-        const args = [];
-        if (ep.hasSearchParam)
-            args.push({ name: 'keyword', type: 'str', required: true });
-        args.push({ name: 'limit', type: 'int', required: false, default: 20 });
-        if (ep.hasPaginationParam)
-            args.push({ name: 'page', type: 'int', required: false, default: 1 });
-        const epStrategy = inferStrategy(ep.authIndicators);
-        let storeHint;
-        if ((epStrategy === 'intercept' || ep.authIndicators.includes('signature')) && stores.length > 0) {
-            for (const s of stores) {
-                const matchingAction = s.actions.find(a => capName.split('_').some(part => a.toLowerCase().includes(part)) ||
-                    a.toLowerCase().includes('fetch') || a.toLowerCase().includes('get'));
-                if (matchingAction) {
-                    storeHint = { store: s.id, action: matchingAction };
-                    break;
-                }
-            }
-        }
-        capabilities.push({
-            name: capName, description: `${opts.site ?? detectSiteName(opts.url)} ${capName}`,
-            strategy: storeHint ? 'store-action' : epStrategy,
-            endpoint: ep.pattern,
-            itemPath: ep.responseAnalysis?.itemPath ?? null,
-            recommendedColumns: cols.length ? cols : ['title', 'url'],
-            recommendedArgs: args,
-            ...(storeHint ? { storeHint } : {}),
-        });
-    }
-    const allAuth = new Set(endpoints.flatMap(ep => ep.authIndicators));
-    const topStrategy = allAuth.has('signature') ? 'intercept'
-        : allAuth.has('bearer') || allAuth.has('csrf') ? 'header'
-            : allAuth.size === 0 ? 'public' : 'cookie';
-    return { capabilities, topStrategy, authIndicators: [...allAuth] };
-}
-/** Write explore artifacts (manifest, endpoints, capabilities, auth, stores) to disk. */
-async function writeExploreArtifacts(targetDir, result, analyzedEndpoints, stores) {
-    await fs.promises.mkdir(targetDir, { recursive: true });
-    const tasks = [
-        fs.promises.writeFile(path.join(targetDir, 'manifest.json'), JSON.stringify({
-            site: result.site, target_url: result.target_url, final_url: result.final_url, title: result.title,
-            framework: result.framework, stores: stores.map(s => ({ type: s.type, id: s.id, actions: s.actions })),
-            top_strategy: result.top_strategy, explored_at: new Date().toISOString(),
-        }, null, 2)),
-        fs.promises.writeFile(path.join(targetDir, 'endpoints.json'), JSON.stringify(analyzedEndpoints.map(ep => ({
-            pattern: ep.pattern, method: ep.method, url: ep.url, status: ep.status,
-            contentType: ep.contentType, queryParams: ep.queryParams,
-            itemPath: ep.responseAnalysis?.itemPath ?? null, itemCount: ep.responseAnalysis?.itemCount ?? 0,
-            detectedFields: ep.responseAnalysis?.detectedFields ?? {}, authIndicators: ep.authIndicators,
-        })), null, 2)),
-        fs.promises.writeFile(path.join(targetDir, 'capabilities.json'), JSON.stringify(result.capabilities, null, 2)),
-        fs.promises.writeFile(path.join(targetDir, 'auth.json'), JSON.stringify({
-            top_strategy: result.top_strategy, indicators: result.auth_indicators, framework: result.framework,
-        }, null, 2)),
-    ];
-    if (stores.length > 0) {
-        tasks.push(fs.promises.writeFile(path.join(targetDir, 'stores.json'), JSON.stringify(stores, null, 2)));
-    }
-    await Promise.all(tasks);
-}
-// ── Main explore function ──────────────────────────────────────────────────
-export async function exploreUrl(url, opts) {
-    const waitSeconds = opts.waitSeconds ?? 3.0;
-    const exploreTimeout = Math.max(DEFAULT_BROWSER_EXPLORE_TIMEOUT, 45.0 + waitSeconds * 8.0);
-    return browserSession(opts.BrowserFactory, async (page) => {
-        return runWithTimeout((async () => {
-            // Step 1: Navigate
-            await page.startNetworkCapture?.().catch(() => { });
-            await page.goto(url);
-            await page.wait(waitSeconds);
-            // Step 2: Auto-scroll to trigger lazy loading intelligently
-            await page.autoScroll({ times: 3, delayMs: 1500 }).catch(() => { });
-            // Step 2.5: Interactive Fuzzing (if requested)
-            if (opts.auto) {
-                try {
-                    // First: targeted clicks by label (e.g. "字幕", "CC", "评论")
-                    if (opts.clickLabels?.length) {
-                        for (const label of opts.clickLabels) {
-                            const safeLabel = JSON.stringify(label);
-                            await page.evaluate(`
-                 (() => {
-                   const el = [...document.querySelectorAll('button, [role="button"], [role="tab"], a, span')]
-                     .find(e => e.textContent && e.textContent.trim().includes(${safeLabel}));
-                   if (el) el.click();
-                 })()
-               `);
-                            await page.wait(1);
-                        }
-                    }
-                    // Then: blind fuzzing on generic interactive elements
-                    const clicks = await page.evaluate(INTERACT_FUZZ_JS);
-                    await page.wait(2); // wait for XHRs to settle
-                }
-                catch (e) {
-                    log.verbose(`Interactive fuzzing skipped: ${e instanceof Error ? e.message : String(e)}`);
-                }
-            }
-            // Step 3: Read page metadata
-            const metadata = await readPageMetadata(page);
-            // Step 4: Capture network traffic
-            const rawNetwork = page.readNetworkCapture
-                ? await page.readNetworkCapture()
-                : await page.networkRequests(false);
-            const networkEntries = parseNetworkRequests(rawNetwork);
-            // Step 5: For JSON endpoints missing a body, carefully re-fetch in-browser via a pristine iframe
-            const jsonEndpoints = networkEntries.filter(e => e.contentType.includes('json') && e.method === 'GET' && e.status === 200 && !e.responseBody);
-            await Promise.allSettled(jsonEndpoints.slice(0, 5).map(async (ep) => {
-                try {
-                    const body = await page.evaluate(`async () => {
-            let iframe = null;
-            try {
-              iframe = document.createElement('iframe');
-              iframe.style.display = 'none';
-              document.body.appendChild(iframe);
-              const cleanFetch = iframe.contentWindow.fetch || window.fetch;
-              const r = await cleanFetch(${JSON.stringify(ep.url)}, { credentials: 'include' });
-              if (!r.ok) return null;
-              const d = await r.json();
-              return JSON.stringify(d).slice(0, 10000);
-            } catch {
-              return null;
-            } finally {
-              if (iframe && iframe.parentNode) iframe.parentNode.removeChild(iframe);
-            }
-          }`);
-                    if (body && typeof body === 'string') {
-                        try {
-                            ep.responseBody = JSON.parse(body);
-                        }
-                        catch { }
-                    }
-                    else if (body && typeof body === 'object')
-                        ep.responseBody = body;
-                }
-                catch { }
-            }));
-            // Step 6: Detect framework
-            let framework = {};
-            try {
-                const fw = await page.evaluate(FRAMEWORK_DETECT_JS);
-                if (isBooleanRecord(fw))
-                    framework = fw;
-            }
-            catch { }
-            // Step 6.5: Discover stores (Pinia / Vuex)
-            let stores = [];
-            if (framework.pinia || framework.vuex) {
-                try {
-                    const raw = await page.evaluate(STORE_DISCOVER_JS);
-                    if (Array.isArray(raw))
-                        stores = raw;
-                }
-                catch { }
-            }
-            // Step 7+8: Analyze endpoints and infer capabilities
-            const { analyzed: analyzedEndpoints, totalCount } = analyzeEndpoints(networkEntries);
-            const { capabilities, topStrategy, authIndicators } = inferCapabilitiesFromEndpoints(analyzedEndpoints, stores, { site: opts.site, goal: opts.goal, url });
-            // Step 9: Assemble result and write artifacts
-            const siteName = opts.site ?? detectSiteName(metadata.url || url);
-            const targetDir = opts.outDir ?? path.join('.opencli', 'explore', siteName);
-            const result = {
-                site: siteName, target_url: url, final_url: metadata.url, title: metadata.title,
-                framework, stores, top_strategy: topStrategy,
-                endpoint_count: totalCount,
-                api_endpoint_count: analyzedEndpoints.length,
-                capabilities, auth_indicators: authIndicators,
-            };
-            await writeExploreArtifacts(targetDir, result, analyzedEndpoints, stores);
-            return { ...result, out_dir: targetDir };
-        })(), { timeout: exploreTimeout, label: `Explore ${url}` });
-    }, { workspace: opts.workspace });
-}
-export function renderExploreSummary(result) {
-    const lines = [
-        'opencli probe: OK', `Site: ${result.site}`, `URL: ${result.target_url}`,
-        `Title: ${result.title || '(none)'}`, `Strategy: ${result.top_strategy}`,
-        `Endpoints: ${result.endpoint_count} total, ${result.api_endpoint_count} API`,
-        `Capabilities: ${result.capabilities?.length ?? 0}`,
-    ];
-    for (const cap of (result.capabilities ?? []).slice(0, 5)) {
-        const storeInfo = cap.storeHint ? ` → ${cap.storeHint.store}.${cap.storeHint.action}()` : '';
-        lines.push(`  • ${cap.name} (${cap.strategy})${storeInfo}`);
-    }
-    const fw = result.framework ?? {};
-    const fwNames = Object.entries(fw).filter(([, v]) => v).map(([k]) => k);
-    if (fwNames.length)
-        lines.push(`Framework: ${fwNames.join(', ')}`);
-    const stores = result.stores ?? [];
-    if (stores.length) {
-        lines.push(`Stores: ${stores.length}`);
-        for (const s of stores.slice(0, 5)) {
-            lines.push(`  • ${s.type}/${s.id}: ${s.actions.slice(0, 5).join(', ')}${s.actions.length > 5 ? '...' : ''}`);
-        }
-    }
-    lines.push(`Output: ${result.out_dir}`);
-    return lines.join('\n');
-}
-async function readPageMetadata(page) {
-    try {
-        const result = await page.evaluate(`() => ({ url: window.location.href, title: document.title || '' })`);
-        if (result && typeof result === 'object' && !Array.isArray(result)) {
-            return {
-                url: String(result.url ?? ''),
-                title: String(result.title ?? ''),
-            };
-        }
-    }
-    catch { }
-    return { url: '', title: '' };
-}