@jackwener/opencli 1.6.7 → 1.6.9

package/dist/src/doctor.js

@@ -5,11 +5,11 @@
  */
 import chalk from 'chalk';
 import { DEFAULT_DAEMON_PORT } from './constants.js';
-import { checkDaemonStatus } from './browser/discover.js';
 import { BrowserBridge } from './browser/index.js';
-import { listSessions } from './browser/daemon-client.js';
+import { getDaemonHealth, listSessions } from './browser/daemon-client.js';
 import { getErrorMessage } from './errors.js';
 import { getRuntimeLabel } from './runtime-detect.js';
+const DOCTOR_LIVE_TIMEOUT_SECONDS = 8;
 /**
  * Test connectivity by attempting a real browser command.
  */
@@ -17,7 +17,7 @@ export async function checkConnectivity(opts) {
     const start = Date.now();
     try {
         const bridge = new BrowserBridge();
-        const page = await bridge.connect({ timeout: opts?.timeout ?? 8 });
+        const page = await bridge.connect({ timeout: opts?.timeout ?? DOCTOR_LIVE_TIMEOUT_SECONDS });
         // Try a simple eval to verify end-to-end connectivity
         await page.evaluate('1 + 1');
         await bridge.close();
@@ -28,33 +28,48 @@ export async function checkConnectivity(opts) {
     }
 }
 export async function runBrowserDoctor(opts = {}) {
-    // Try to auto-start daemon if it's not running, so we show accurate status.
-    let initialStatus = await checkDaemonStatus();
-    if (!initialStatus.running) {
-        try {
-            const bridge = new BrowserBridge();
-            await bridge.connect({ timeout: 5 });
-            await bridge.close();
-        }
-        catch {
-            // Auto-start failed; we'll report it below.
-        }
-    }
-    // Run the live connectivity check — it may also auto-start the daemon as a
-    // side-effect, so we read daemon status only *after* all side-effects settle.
+    // Live connectivity check doubles as auto-start (bridge.connect spawns daemon).
     let connectivity;
     if (opts.live) {
         connectivity = await checkConnectivity();
     }
-    const status = await checkDaemonStatus();
-    const sessions = opts.sessions && status.running && status.extensionConnected
+    else {
+        // No live probe — daemon may have idle-exited. Do a minimal auto-start
+        // so we don't misreport a lazy-lifecycle stop as a real failure.
+        const initialHealth = await getDaemonHealth();
+        if (initialHealth.state === 'stopped') {
+            try {
+                const bridge = new BrowserBridge();
+                await bridge.connect({ timeout: 5 });
+                await bridge.close();
+            }
+            catch {
+                // Auto-start failed; we'll report it below.
+            }
+        }
+    }
+    // Single status read *after* all side-effects (live check / auto-start) settle.
+    const health = await getDaemonHealth();
+    const daemonRunning = health.state !== 'stopped';
+    const extensionConnected = health.state === 'ready';
+    const daemonFlaky = !!(connectivity?.ok && !daemonRunning);
+    const extensionFlaky = !!(connectivity?.ok && daemonRunning && !extensionConnected);
+    const sessions = opts.sessions && health.state === 'ready'
         ? await listSessions()
         : undefined;
     const issues = [];
-    if (!status.running) {
+    if (daemonFlaky) {
+        issues.push('Daemon connectivity is unstable. The live browser test succeeded, but the daemon was no longer running immediately afterward.\n' +
+            'This usually means the daemon crashed or exited right after serving the live probe.');
+    }
+    else if (!daemonRunning) {
         issues.push('Daemon is not running. It should start automatically when you run an opencli browser command.');
     }
-    if (status.running && !status.extensionConnected) {
+    if (extensionFlaky) {
+        issues.push('Extension connection is unstable. The live browser test succeeded, but the daemon reported the extension disconnected immediately afterward.\n' +
+            'This usually means the Browser Bridge service worker is reconnecting slowly or Chrome suspended it.');
+    }
+    else if (daemonRunning && !extensionConnected) {
         issues.push('Daemon is running but the Chrome/Chromium extension is not connected.\n' +
             'Please install the opencli Browser Bridge extension:\n' +
             '  1. Download from https://github.com/jackwener/opencli/releases\n' +
@@ -64,19 +79,22 @@ export async function runBrowserDoctor(opts = {}) {
     if (connectivity && !connectivity.ok) {
         issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
     }
-    if (status.extensionVersion && opts.cliVersion) {
-        const extMajor = status.extensionVersion.split('.')[0];
+    const extensionVersion = health.status?.extensionVersion;
+    if (extensionVersion && opts.cliVersion) {
+        const extMajor = extensionVersion.split('.')[0];
         const cliMajor = opts.cliVersion.split('.')[0];
         if (extMajor !== cliMajor) {
-            issues.push(`Extension major version mismatch: extension v${status.extensionVersion} ≠ CLI v${opts.cliVersion}\n` +
+            issues.push(`Extension major version mismatch: extension v${extensionVersion} ≠ CLI v${opts.cliVersion}\n` +
                 '  Download the latest extension from: https://github.com/jackwener/opencli/releases');
         }
     }
     return {
         cliVersion: opts.cliVersion,
-        daemonRunning: status.running,
-        extensionConnected: status.extensionConnected,
-        extensionVersion: status.extensionVersion,
+        daemonRunning,
+        daemonFlaky,
+        extensionConnected,
+        extensionFlaky,
+        extensionVersion,
         connectivity,
         sessions,
         issues,
@@ -85,12 +103,22 @@ export async function runBrowserDoctor(opts = {}) {
 export function renderBrowserDoctorReport(report) {
     const lines = [chalk.bold(`opencli v${report.cliVersion ?? 'unknown'} doctor`) + chalk.dim(` (${getRuntimeLabel()})`), ''];
     // Daemon status
-    const daemonIcon = report.daemonRunning ? chalk.green('[OK]') : chalk.red('[MISSING]');
-    lines.push(`${daemonIcon} Daemon: ${report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` : 'not running'}`);
+    const daemonIcon = report.daemonFlaky
+        ? chalk.yellow('[WARN]')
+        : report.daemonRunning ? chalk.green('[OK]') : chalk.red('[MISSING]');
+    const daemonLabel = report.daemonFlaky
+        ? 'unstable (running during live check, then stopped)'
+        : report.daemonRunning ? `running on port ${DEFAULT_DAEMON_PORT}` : 'not running';
+    lines.push(`${daemonIcon} Daemon: ${daemonLabel}`);
     // Extension status
-    const extIcon = report.extensionConnected ? chalk.green('[OK]') : chalk.yellow('[MISSING]');
+    const extIcon = report.extensionFlaky
+        ? chalk.yellow('[WARN]')
+        : report.extensionConnected ? chalk.green('[OK]') : chalk.yellow('[MISSING]');
     const extVersion = report.extensionVersion ? chalk.dim(` (v${report.extensionVersion})`) : '';
-    lines.push(`${extIcon} Extension: ${report.extensionConnected ? 'connected' : 'not connected'}${extVersion}`);
+    const extLabel = report.extensionFlaky
+        ? 'unstable (connected during live check, then disconnected)'
+        : report.extensionConnected ? 'connected' : 'not connected';
+    lines.push(`${extIcon} Extension: ${extLabel}${extVersion}`);
     // Connectivity
     if (report.connectivity) {
         const connIcon = report.connectivity.ok ? chalk.green('[OK]') : chalk.red('[FAIL]');

package/dist/src/doctor.test.js

@@ -1,14 +1,12 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { mockCheckDaemonStatus, mockListSessions, mockConnect, mockClose } = vi.hoisted(() => ({
-    mockCheckDaemonStatus: vi.fn(),
+const { mockGetDaemonHealth, mockListSessions, mockConnect, mockClose } = vi.hoisted(() => ({
+    mockGetDaemonHealth: vi.fn(),
     mockListSessions: vi.fn(),
     mockConnect: vi.fn(),
     mockClose: vi.fn(),
 }));
-vi.mock('./browser/discover.js', () => ({
-    checkDaemonStatus: mockCheckDaemonStatus,
-}));
 vi.mock('./browser/daemon-client.js', () => ({
+    getDaemonHealth: mockGetDaemonHealth,
     listSessions: mockListSessions,
 }));
 vi.mock('./browser/index.js', () => ({
@@ -69,23 +67,98 @@ describe('doctor report rendering', () => {
         }));
         expect(text).toContain('[SKIP] Connectivity: skipped (--no-live)');
     });
-    it('reports consistent status when live check auto-starts the daemon', async () => {
-        // checkDaemonStatus is called twice: once for auto-start check, once for final status.
-        // First call: daemon not running (triggers auto-start attempt)
-        mockCheckDaemonStatus.mockResolvedValueOnce({ running: false, extensionConnected: false });
-        // Auto-start attempt via BrowserBridge.connect fails
+    it('renders unstable extension state when live connectivity and status disagree', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: true,
+            extensionConnected: true,
+            extensionFlaky: true,
+            connectivity: { ok: true, durationMs: 1234 },
+            issues: ['Extension connection is unstable.'],
+        }));
+        expect(text).toContain('[WARN] Extension: unstable');
+        expect(text).toContain('Extension connection is unstable.');
+    });
+    it('renders unstable daemon state when live connectivity and status disagree', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: false,
+            daemonFlaky: true,
+            extensionConnected: false,
+            connectivity: { ok: true, durationMs: 1234 },
+            issues: ['Daemon connectivity is unstable.'],
+        }));
+        expect(text).toContain('[WARN] Daemon: unstable');
+        expect(text).toContain('Daemon connectivity is unstable.');
+    });
+    it('reports daemon not running when no-live and auto-start fails', async () => {
+        // no-live mode: getDaemonHealth called twice (initial check + final status)
+        // Initial: stopped → triggers auto-start attempt
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
+        // Auto-start fails
         mockConnect.mockRejectedValueOnce(new Error('Could not start daemon'));
-        // Second call: daemon still not running after failed auto-start
-        mockCheckDaemonStatus.mockResolvedValueOnce({ running: false, extensionConnected: false });
+        // Final: still stopped
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
         const report = await runBrowserDoctor({ live: false });
-        // Status reflects daemon not running
         expect(report.daemonRunning).toBe(false);
         expect(report.extensionConnected).toBe(false);
-        // checkDaemonStatus called twice (initial + final)
-        expect(mockCheckDaemonStatus).toHaveBeenCalledTimes(2);
-        // Should report daemon not running
+        expect(mockGetDaemonHealth).toHaveBeenCalledTimes(2);
         expect(report.issues).toEqual(expect.arrayContaining([
             expect.stringContaining('Daemon is not running'),
         ]));
     });
+    it('reports flapping when live check succeeds but final status shows extension disconnected', async () => {
+        // Live check succeeds
+        mockConnect.mockResolvedValueOnce({
+            evaluate: vi.fn().mockResolvedValue(2),
+        });
+        mockClose.mockResolvedValueOnce(undefined);
+        // After live check, getDaemonHealth shows no-extension
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
+        const report = await runBrowserDoctor({ live: true });
+        expect(report.daemonRunning).toBe(true);
+        expect(report.extensionConnected).toBe(false);
+        expect(report.extensionFlaky).toBe(true);
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('Extension connection is unstable'),
+        ]));
+    });
+    it('reports daemon flapping when live check succeeds but daemon disappears afterward', async () => {
+        // Live check succeeds
+        mockConnect.mockResolvedValueOnce({
+            evaluate: vi.fn().mockResolvedValue(2),
+        });
+        mockClose.mockResolvedValueOnce(undefined);
+        // After live check, getDaemonHealth shows stopped
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'stopped', status: null });
+        const report = await runBrowserDoctor({ live: true });
+        expect(report.daemonRunning).toBe(false);
+        expect(report.daemonFlaky).toBe(true);
+        expect(report.extensionConnected).toBe(false);
+        expect(report.issues).toEqual(expect.arrayContaining([
+            expect.stringContaining('Daemon connectivity is unstable'),
+        ]));
+    });
+    it('uses the fast default timeout for live connectivity checks', async () => {
+        let timeoutSeen;
+        mockConnect.mockImplementationOnce(async (opts) => {
+            timeoutSeen = opts?.timeout;
+            return {
+                evaluate: vi.fn().mockResolvedValue(2),
+            };
+        });
+        mockClose.mockResolvedValueOnce(undefined);
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'ready', status: { extensionConnected: true } });
+        await runBrowserDoctor({ live: true });
+        expect(timeoutSeen).toBe(8);
+    });
+    it('skips auto-start in no-live mode when daemon is already running', async () => {
+        // no-live mode but daemon already running (no-extension)
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
+        // Final status: same
+        mockGetDaemonHealth.mockResolvedValueOnce({ state: 'no-extension', status: { extensionConnected: false } });
+        const report = await runBrowserDoctor({ live: false });
+        // Should NOT have tried auto-start since daemon was already running
+        expect(mockConnect).not.toHaveBeenCalled();
+        expect(report.daemonRunning).toBe(true);
+        expect(report.extensionConnected).toBe(false);
+    });
 });

package/dist/src/download/progress.js

@@ -23,8 +23,13 @@ export function formatDuration(ms) {
     if (seconds < 60)
         return `${seconds}s`;
     const minutes = Math.floor(seconds / 60);
-    const remainingSeconds = seconds % 60;
-    return `${minutes}m ${remainingSeconds}s`;
+    if (minutes < 60) {
+        const remainingSeconds = seconds % 60;
+        return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
 }
 /**
  * Create a simple progress bar for terminal display.

package/dist/src/execution.js

@@ -12,12 +12,11 @@
 import { Strategy, getRegistry, fullName } from './registry.js';
 import { pathToFileURL } from 'node:url';
 import { executePipeline } from './pipeline/index.js';
-import { AdapterLoadError, ArgumentError, BrowserConnectError, CommandExecutionError, getErrorMessage } from './errors.js';
+import { AdapterLoadError, ArgumentError, CommandExecutionError, getErrorMessage } from './errors.js';
 import { isDiagnosticEnabled, collectDiagnostic, emitDiagnostic } from './diagnostic.js';
 import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { emitHook } from './hooks.js';
-import { checkDaemonStatus } from './browser/discover.js';
 import { log } from './logger.js';
 import { isElectronApp } from './electron-apps.js';
 import { probeCDP, resolveElectronEndpoint } from './launcher.js';
@@ -149,17 +148,6 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
                     cdpEndpoint = await resolveElectronEndpoint(cmd.site);
                 }
             }
-            else {
-                // Browser Bridge: fail-fast when daemon is up but extension is missing.
-                // 300ms timeout avoids a full 2s wait on cold-start.
-                const status = await checkDaemonStatus({ timeout: 300 });
-                if (status.running && !status.extensionConnected) {
-                    throw new BrowserConnectError('Browser Bridge extension not connected', 'Install the Browser Bridge:\n' +
-                        '  1. Download: https://github.com/jackwener/opencli/releases\n' +
-                        '  2. In Chrome or Chromium, open chrome://extensions → Developer Mode → Load unpacked\n' +
-                        '  Then run: opencli doctor');
-                }
-            }
             ensureRequiredEnv(cmd);
             const BrowserFactory = getBrowserFactory(cmd.site);
             result = await browserSession(BrowserFactory, async (page) => {

package/dist/src/explore.d.ts

@@ -12,7 +12,6 @@ interface InferredCapability {
     name: string;
     description: string;
     strategy: string;
-    confidence: number;
     endpoint: string;
     itemPath: string | null;
     recommendedColumns: string[];
@@ -52,7 +51,6 @@ export interface ExploreEndpointArtifact {
     url: string;
     status: number | null;
     contentType: string;
-    score: number;
     queryParams: string[];
     itemPath: string | null;
     itemCount: number;

package/dist/src/explore.js

@@ -13,7 +13,7 @@ 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, } from './analysis.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',
@@ -66,13 +66,29 @@ function parseNetworkRequests(raw) {
         return entries;
     }
     if (Array.isArray(raw)) {
-        return raw.filter(e => e && typeof e === 'object').map(e => ({
-            method: (e.method ?? 'GET').toUpperCase(),
-            url: String(e.url ?? e.request?.url ?? e.requestUrl ?? ''),
-            status: e.status ?? e.statusCode ?? null,
-            contentType: e.contentType ?? e.response?.contentType ?? '',
-            responseBody: e.responseBody, requestHeaders: e.requestHeaders,
-        }));
+        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 [];
 }
@@ -91,29 +107,32 @@ function isBooleanRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value)
         && Object.values(value).every(v => typeof v === 'boolean');
 }
-function scoreEndpoint(ep) {
-    let s = 0;
-    if (ep.contentType.includes('json'))
-        s += 10;
-    if (ep.responseAnalysis) {
-        s += 5;
-        s += Math.min(ep.responseAnalysis.itemCount, 10);
-        s += Object.keys(ep.responseAnalysis.detectedFields).length * 2;
-    }
+/**
+ * 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/'))
-        s += 3;
-    if (ep.hasSearchParam)
-        s += 3;
-    if (ep.hasPaginationParam)
-        s += 2;
-    if (ep.hasLimitParam)
-        s += 2;
-    if (ep.status === 200)
-        s += 2;
-    // Anti-Bot Empty Value Detection: penalize JSON endpoints returning empty data
-    if (ep.responseAnalysis && ep.responseAnalysis.itemCount === 0 && ep.contentType.includes('json'))
-        s -= 3;
-    return s;
+        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();
@@ -122,7 +141,7 @@ const STORE_DISCOVER_JS = discoverStores.toString();
 // ── Auto-Interaction (Fuzzing) ─────────────────────────────────────────────
 const INTERACT_FUZZ_JS = interactFuzz.toString();
 // ── Analysis helpers (extracted from exploreUrl) ───────────────────────────
-/** Filter, deduplicate, and score network endpoints. */
+/** Filter and deduplicate network endpoints, keeping only useful structured-data APIs. */
 function analyzeEndpoints(networkEntries) {
     const seen = new Map();
     for (const entry of networkEntries) {
@@ -145,12 +164,13 @@ function analyzeEndpoints(networkEntries) {
             hasLimitParam: hasLimit || qp.some(p => LIMIT_PARAMS.has(p)),
             authIndicators: detectAuthFromHeaders(entry.requestHeaders),
             responseAnalysis: entry.responseBody ? analyzeResponseBody(entry.responseBody) : null,
-            score: 0,
         };
-        ep.score = scoreEndpoint(ep);
         seen.set(key, ep);
     }
-    const analyzed = [...seen.values()].filter(ep => ep.score >= 5).sort((a, b) => b.score - a.score);
+    // 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. */
@@ -192,7 +212,7 @@ function inferCapabilitiesFromEndpoints(endpoints, stores, opts) {
         capabilities.push({
             name: capName, description: `${opts.site ?? detectSiteName(opts.url)} ${capName}`,
             strategy: storeHint ? 'store-action' : epStrategy,
-            confidence: Math.min(ep.score / 20, 1.0), endpoint: ep.pattern,
+            endpoint: ep.pattern,
             itemPath: ep.responseAnalysis?.itemPath ?? null,
             recommendedColumns: cols.length ? cols : ['title', 'url'],
             recommendedArgs: args,
@@ -216,7 +236,7 @@ async function writeExploreArtifacts(targetDir, result, analyzedEndpoints, store
         }, 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, score: ep.score, queryParams: ep.queryParams,
+            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)),
@@ -237,6 +257,7 @@ export async function exploreUrl(url, opts) {
     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
@@ -269,7 +290,9 @@ export async function exploreUrl(url, opts) {
             // Step 3: Read page metadata
             const metadata = await readPageMetadata(page);
             // Step 4: Capture network traffic
-            const rawNetwork = await page.networkRequests(false);
+            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);
@@ -348,7 +371,7 @@ export function renderExploreSummary(result) {
     ];
     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}, ${(cap.confidence * 100).toFixed(0)}%)${storeInfo}`);
+        lines.push(`  • ${cap.name} (${cap.strategy})${storeInfo}`);
     }
     const fw = result.framework ?? {};
     const fwNames = Object.entries(fw).filter(([, v]) => v).map(([k]) => k);

package/dist/src/extension-manifest-regression.test.js

@@ -7,7 +7,6 @@ describe('extension manifest regression', () => {
         const raw = await fs.readFile(manifestPath, 'utf8');
         const manifest = JSON.parse(raw);
         expect(manifest.permissions).toContain('cookies');
-        expect(manifest.permissions).toContain('scripting');
         expect(manifest.host_permissions).toContain('<all_urls>');
     });
 });

package/dist/src/generate.d.ts

@@ -1,11 +1,8 @@
 /**
  * Generate: one-shot CLI creation from URL.
  *
- * Orchestrates the full pipeline:
- *   explore (Deep Explore) → synthesize (YAML generation) → register → verify
- *
- * Includes Strategy Cascade: if the initial strategy fails,
- * automatically downgrades and retries.
+ * Orchestrates the pipeline:
+ *   explore (Deep Explore) → synthesize (YAML generation + candidate ranking)
  */
 import type { IBrowserFactory } from './runtime.js';
 import { type SynthesizeCandidateSummary } from './synthesize.js';
@@ -34,7 +31,7 @@ export interface GenerateCliResult {
     };
     synthesize: {
         candidate_count: number;
-        candidates: Array<Pick<SynthesizeCandidateSummary, 'name' | 'strategy' | 'confidence'>>;
+        candidates: Array<Pick<SynthesizeCandidateSummary, 'name' | 'strategy'>>;
     };
 }
 export declare function generateCliFromUrl(opts: GenerateCliOptions): Promise<GenerateCliResult>;

package/dist/src/generate.js

@@ -1,11 +1,8 @@
 /**
  * Generate: one-shot CLI creation from URL.
  *
- * Orchestrates the full pipeline:
- *   explore (Deep Explore) → synthesize (YAML generation) → register → verify
- *
- * Includes Strategy Cascade: if the initial strategy fails,
- * automatically downgrades and retries.
+ * Orchestrates the pipeline:
+ *   explore (Deep Explore) → synthesize (YAML generation + candidate ranking)
  */
 import { exploreUrl } from './explore.js';
 import { synthesizeFromExplore } from './synthesize.js';
@@ -40,7 +37,7 @@ function selectCandidate(candidates, goal) {
     if (!candidates.length)
         return null;
     if (!goal)
-        return candidates[0]; // highest confidence first
+        return candidates[0];
     const normalized = normalizeGoal(goal);
     if (normalized) {
         const exact = candidates.find(c => c.name === normalized);
@@ -90,7 +87,6 @@ export async function generateCliFromUrl(opts) {
             candidates: (synthesizeResult.candidates ?? []).map((c) => ({
                 name: c.name,
                 strategy: c.strategy,
-                confidence: c.confidence,
             })),
         },
     };
@@ -111,7 +107,7 @@ export function renderGenerateSummary(r) {
         `  Candidates: ${r.synthesize?.candidate_count ?? 0}`,
     ];
     for (const c of r.synthesize?.candidates ?? []) {
-        lines.push(`    • ${c.name} (${c.strategy}, ${((c.confidence ?? 0) * 100).toFixed(0)}%)`);
+        lines.push(`    • ${c.name} (${c.strategy})`);
     }
     const fw = r.explore?.framework ?? {};
     const fwNames = Object.entries(fw).filter(([, v]) => v).map(([k]) => k);

package/dist/src/package-paths.d.ts

@@ -0,0 +1,8 @@
+export interface PackageJsonLike {
+    bin?: string | Record<string, string>;
+    main?: string;
+}
+export declare function findPackageRoot(startFile: string, fileExists?: (candidate: string) => boolean): string;
+export declare function getBuiltEntryCandidates(packageRoot: string, readFile?: (filePath: string) => string): string[];
+export declare function getCliManifestPath(clisDir: string): string;
+export declare function getFetchAdaptersScriptPath(packageRoot: string): string;

package/dist/src/package-paths.js

@@ -0,0 +1,41 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export function findPackageRoot(startFile, fileExists = fs.existsSync) {
+    let dir = path.dirname(startFile);
+    while (true) {
+        if (fileExists(path.join(dir, 'package.json')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            throw new Error(`Could not find package.json above ${startFile}`);
+        }
+        dir = parent;
+    }
+}
+export function getBuiltEntryCandidates(packageRoot, readFile = (filePath) => fs.readFileSync(filePath, 'utf-8')) {
+    const candidates = [];
+    try {
+        const pkg = JSON.parse(readFile(path.join(packageRoot, 'package.json')));
+        if (typeof pkg.bin === 'string') {
+            candidates.push(path.join(packageRoot, pkg.bin));
+        }
+        else if (pkg.bin && typeof pkg.bin === 'object' && typeof pkg.bin.opencli === 'string') {
+            candidates.push(path.join(packageRoot, pkg.bin.opencli));
+        }
+        if (typeof pkg.main === 'string') {
+            candidates.push(path.join(packageRoot, pkg.main));
+        }
+    }
+    catch {
+        // Fall through to compatibility candidates below.
+    }
+    // Compatibility fallback for partially-built trees or older layouts.
+    candidates.push(path.join(packageRoot, 'dist', 'src', 'main.js'), path.join(packageRoot, 'dist', 'main.js'));
+    return [...new Set(candidates)];
+}
+export function getCliManifestPath(clisDir) {
+    return path.resolve(clisDir, '..', 'cli-manifest.json');
+}
+export function getFetchAdaptersScriptPath(packageRoot) {
+    return path.join(packageRoot, 'scripts', 'fetch-adapters.js');
+}

package/dist/src/plugin-scaffold.js

@@ -68,9 +68,7 @@ pipeline:
   - fetch:
       url: "https://httpbin.org/get?greeting=hello"
       method: GET
-  - extract:
-      type: json
-      selector: "$.args"
+  - select: "args"
 `;
     writeFile(targetDir, 'hello.yaml', yamlContent);
     files.push('hello.yaml');