@jackwener/opencli 1.6.8 → 1.6.10

package/dist/src/clis/binance/losers.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'losers',
+    description: 'Top losing trading pairs by 24h price change',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 10, help: 'Number of trading pairs' },
+    ],
+    columns: ['rank', 'symbol', 'price', 'change_24h', 'volume'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/24hr' } },
+        { filter: 'item.priceChangePercent' },
+        { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', volume: '${{ item.quoteVolume }}', sort_change: '${{ Number(item.priceChangePercent) }}' } },
+        { sort: { by: 'sort_change' } },
+        { map: { rank: '${{ index + 1 }}', symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', volume: '${{ item.quoteVolume }}' } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/src/clis/binance/pairs.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/clis/binance/pairs.js

@@ -0,0 +1,20 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'pairs',
+    description: 'List active trading pairs on Binance',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of trading pairs' },
+    ],
+    columns: ['symbol', 'base', 'quote', 'status'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/exchangeInfo' } },
+        { select: 'symbols' },
+        { filter: 'item.status === \'TRADING\'' },
+        { map: { symbol: '${{ item.symbol }}', base: '${{ item.baseAsset }}', quote: '${{ item.quoteAsset }}', status: '${{ item.status }}' } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/src/clis/binance/price.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/clis/binance/price.js

@@ -0,0 +1,17 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'price',
+    description: 'Quick price check for a trading pair',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'symbol', type: 'str', required: true, positional: true, help: 'Trading pair symbol (e.g. BTCUSDT, ETHUSDT)' },
+    ],
+    columns: ['symbol', 'price', 'change', 'change_pct', 'high', 'low', 'volume', 'quote_volume', 'trades'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/24hr?symbol=${{ args.symbol }}' } },
+        { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change: '${{ item.priceChange }}', change_pct: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.volume }}', quote_volume: '${{ item.quoteVolume }}', trades: '${{ item.count }}' } },
+    ],
+});

package/dist/src/clis/binance/prices.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/clis/binance/prices.js

@@ -0,0 +1,18 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'prices',
+    description: 'Latest prices for all trading pairs',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of prices' },
+    ],
+    columns: ['rank', 'symbol', 'price'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/price' } },
+        { map: { rank: '${{ index + 1 }}', symbol: '${{ item.symbol }}', price: '${{ item.price }}' } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/src/clis/binance/ticker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/clis/binance/ticker.js

@@ -0,0 +1,20 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'ticker',
+    description: '24h ticker statistics for top trading pairs by volume',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of tickers' },
+    ],
+    columns: ['symbol', 'price', 'change_pct', 'high', 'low', 'volume', 'quote_vol', 'trades'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/24hr' } },
+        { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_pct: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.volume }}', quote_vol: '${{ item.quoteVolume }}', trades: '${{ item.count }}', sort_volume: '${{ Number(item.quoteVolume) }}' } },
+        { sort: { by: 'sort_volume', order: 'desc' } },
+        { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_pct: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.volume }}', quote_vol: '${{ item.quoteVolume }}', trades: '${{ item.count }}' } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/src/clis/binance/top.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/clis/binance/top.js

@@ -0,0 +1,20 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'top',
+    description: 'Top trading pairs by 24h volume on Binance',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of trading pairs' },
+    ],
+    columns: ['rank', 'symbol', 'price', 'change_24h', 'high', 'low', 'volume'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/ticker/24hr' } },
+        { map: { symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.quoteVolume }}', sort_volume: '${{ Number(item.quoteVolume) }}' } },
+        { sort: { by: 'sort_volume', order: 'desc' } },
+        { map: { rank: '${{ index + 1 }}', symbol: '${{ item.symbol }}', price: '${{ item.lastPrice }}', change_24h: '${{ item.priceChangePercent }}', high: '${{ item.highPrice }}', low: '${{ item.lowPrice }}', volume: '${{ item.quoteVolume }}' } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/src/clis/binance/trades.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/clis/binance/trades.js

@@ -0,0 +1,19 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+cli({
+    site: 'binance',
+    name: 'trades',
+    description: 'Recent trades for a trading pair',
+    domain: 'data-api.binance.vision',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'symbol', type: 'str', required: true, positional: true, help: 'Trading pair symbol (e.g. BTCUSDT, ETHUSDT)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of trades (max 1000)' },
+    ],
+    columns: ['id', 'price', 'qty', 'quote_qty', 'buyer_maker'],
+    pipeline: [
+        { fetch: { url: 'https://data-api.binance.vision/api/v3/trades?symbol=${{ args.symbol }}&limit=${{ args.limit }}' } },
+        { map: { id: '${{ item.id }}', price: '${{ item.price }}', qty: '${{ item.qty }}', quote_qty: '${{ item.quoteQty }}', buyer_maker: '${{ item.isBuyerMaker }}' } },
+        { limit: '${{ args.limit }}' },
+    ],
+});

package/dist/src/commanderAdapter.js

@@ -15,7 +15,8 @@ import { formatRegistryHelpText } from './serialization.js';
 import { render as renderOutput } from './output.js';
 import { executeCommand } from './execution.js';
 import { CliError, EXIT_CODES, ERROR_ICONS, getErrorMessage, BrowserConnectError, AuthRequiredError, TimeoutError, SelectorError, EmptyResultError, ArgumentError, AdapterLoadError, CommandExecutionError, } from './errors.js';
-import { checkDaemonStatus } from './browser/discover.js';
+import { getDaemonHealth } from './browser/daemon-client.js';
+import { isDiagnosticEnabled } from './diagnostic.js';
 export function normalizeArgValue(argType, value, name) {
     if (argType !== 'bool' && argType !== 'boolean')
         return value;
@@ -169,18 +170,27 @@ function renderBridgeStatus(running, extensionConnected) {
         console.error(chalk.dim('  Try reloading the extension, or run: opencli doctor'));
     }
 }
+/** Emit AutoFix hint for repairable adapter errors (skipped if already in diagnostic mode). */
+function emitAutoFixHint(cmdName) {
+    if (isDiagnosticEnabled())
+        return; // Already collecting diagnostics, don't repeat
+    console.error();
+    console.error(chalk.cyan('💡 AutoFix: re-run with OPENCLI_DIAGNOSTIC=1 for repair context.'));
+    console.error(chalk.dim(`    OPENCLI_DIAGNOSTIC=1 ${cmdName}`));
+}
 async function renderError(err, cmdName, verbose) {
     // ── BrowserConnectError: real-time diagnosis, kind as fallback ────────
     if (err instanceof BrowserConnectError) {
-        console.error(chalk.red('🔌 Browser Bridge not connected'));
+        console.error(chalk.red(`🔌 ${err.message}`));
+        if (err.hint)
+            console.error(chalk.yellow(`→ ${err.hint}`));
         console.error();
         try {
-            // 300ms matches execution.ts — localhost responds in <50ms when running.
-            const status = await checkDaemonStatus({ timeout: 300 });
-            renderBridgeStatus(status.running, status.extensionConnected);
+            const health = await getDaemonHealth({ timeout: 300 });
+            renderBridgeStatus(health.state !== 'stopped', health.state === 'ready');
         }
         catch (_statusErr) {
-            // checkDaemonStatus itself failed — derive best-guess state from kind.
+            // getDaemonHealth itself failed — derive best-guess state from kind.
             const running = err.kind !== 'daemon-not-running';
             const extensionConnected = err.kind === 'command-failed';
             renderBridgeStatus(running, extensionConnected);
@@ -208,6 +218,7 @@ async function renderError(err, cmdName, verbose) {
         console.error(chalk.yellow(`→ ${err.hint ?? 'The page structure may have changed — this adapter may be outdated.'}`));
         console.error(chalk.dim(`  Debug:  ${cmdName} --verbose`));
         console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
+        emitAutoFixHint(cmdName);
         return;
     }
     // ── ArgumentError ─────────────────────────────────────────────────────
@@ -251,6 +262,8 @@ async function renderError(err, cmdName, verbose) {
         console.error(chalk.yellow(`→ ${classified.hint}`));
         if (classified.kind === 'not-found')
             console.error(chalk.dim(`  Report: ${ISSUES_URL}`));
+        if (classified.kind === 'not-found')
+            emitAutoFixHint(cmdName);
         return;
     }
     // ── Unknown error: show stack in verbose mode ─────────────────────────

package/dist/src/completion-fast.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Lightweight manifest-based completion for the fast path.
+ *
+ * This module MUST NOT import registry, discovery, or any heavy module.
+ * It only reads pre-compiled cli-manifest.json files synchronously.
+ */
+/**
+ * Returns true only if ALL manifest files exist and are readable.
+ * If any source lacks a manifest (e.g. user adapters without a compiled manifest),
+ * the fast path must not be used — otherwise those adapters would silently
+ * disappear from completion results.
+ */
+export declare function hasAllManifests(manifestPaths: string[]): boolean;
+/**
+ * Lightweight completion that reads directly from manifest JSON files,
+ * bypassing full CLI discovery and adapter loading.
+ */
+export declare function getCompletionsFromManifest(words: string[], cursor: number, manifestPaths: string[]): string[];
+export declare function bashCompletionScript(): string;
+export declare function zshCompletionScript(): string;
+export declare function fishCompletionScript(): string;
+/**
+ * Print completion script for the given shell. Returns true if handled, false if unknown shell.
+ */
+export declare function printCompletionScriptFast(shell: string): boolean;

package/dist/src/completion-fast.js

@@ -0,0 +1,140 @@
+/**
+ * Lightweight manifest-based completion for the fast path.
+ *
+ * This module MUST NOT import registry, discovery, or any heavy module.
+ * It only reads pre-compiled cli-manifest.json files synchronously.
+ */
+import * as fs from 'node:fs';
+const BUILTIN_COMMANDS = [
+    'list',
+    'validate',
+    'verify',
+    'explore',
+    'probe',
+    'synthesize',
+    'generate',
+    'cascade',
+    'doctor',
+    'plugin',
+    'install',
+    'register',
+    'completion',
+];
+/**
+ * Returns true only if ALL manifest files exist and are readable.
+ * If any source lacks a manifest (e.g. user adapters without a compiled manifest),
+ * the fast path must not be used — otherwise those adapters would silently
+ * disappear from completion results.
+ */
+export function hasAllManifests(manifestPaths) {
+    for (const p of manifestPaths) {
+        try {
+            fs.accessSync(p);
+        }
+        catch {
+            return false;
+        }
+    }
+    return manifestPaths.length > 0;
+}
+/**
+ * Lightweight completion that reads directly from manifest JSON files,
+ * bypassing full CLI discovery and adapter loading.
+ */
+export function getCompletionsFromManifest(words, cursor, manifestPaths) {
+    const entries = loadManifestEntries(manifestPaths);
+    if (entries === null) {
+        return [];
+    }
+    if (cursor <= 1) {
+        const sites = new Set();
+        for (const entry of entries) {
+            sites.add(entry.site);
+        }
+        return [...BUILTIN_COMMANDS, ...sites].sort();
+    }
+    const site = words[0];
+    if (BUILTIN_COMMANDS.includes(site)) {
+        return [];
+    }
+    if (cursor === 2) {
+        const subcommands = [];
+        for (const entry of entries) {
+            if (entry.site === site) {
+                subcommands.push(entry.name);
+                if (entry.aliases?.length)
+                    subcommands.push(...entry.aliases);
+            }
+        }
+        return [...new Set(subcommands)].sort();
+    }
+    return [];
+}
+// ── Shell script generators (pure strings, no registry dependency) ───────
+export function bashCompletionScript() {
+    return `# Bash completion for opencli
+# Add to ~/.bashrc:  eval "$(opencli completion bash)"
+_opencli_completions() {
+  local cur words cword
+  _get_comp_words_by_ref -n : cur words cword
+
+  local completions
+  completions=$(opencli --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)
+
+  COMPREPLY=( $(compgen -W "$completions" -- "$cur") )
+  __ltrim_colon_completions "$cur"
+}
+complete -F _opencli_completions opencli
+`;
+}
+export function zshCompletionScript() {
+    return `# Zsh completion for opencli
+# Add to ~/.zshrc:  eval "$(opencli completion zsh)"
+_opencli() {
+  local -a completions
+  local cword=$((CURRENT - 1))
+  completions=(\${(f)"$(opencli --get-completions --cursor "$cword" "\${words[@]:1}" 2>/dev/null)"})
+  compadd -a completions
+}
+compdef _opencli opencli
+`;
+}
+export function fishCompletionScript() {
+    return `# Fish completion for opencli
+# Add to ~/.config/fish/config.fish:  opencli completion fish | source
+complete -c opencli -f -a '(
+  set -l tokens (commandline -cop)
+  set -l cursor (count (commandline -cop))
+  opencli --get-completions --cursor $cursor $tokens[2..] 2>/dev/null
+)'
+`;
+}
+const SHELL_SCRIPTS = {
+    bash: bashCompletionScript,
+    zsh: zshCompletionScript,
+    fish: fishCompletionScript,
+};
+/**
+ * Print completion script for the given shell. Returns true if handled, false if unknown shell.
+ */
+export function printCompletionScriptFast(shell) {
+    const gen = SHELL_SCRIPTS[shell];
+    if (!gen)
+        return false;
+    process.stdout.write(gen());
+    return true;
+}
+function loadManifestEntries(manifestPaths) {
+    const entries = [];
+    let found = false;
+    for (const manifestPath of manifestPaths) {
+        try {
+            const raw = fs.readFileSync(manifestPath, 'utf-8');
+            const manifest = JSON.parse(raw);
+            entries.push(...manifest);
+            found = true;
+        }
+        catch { /* skip missing/unreadable */ }
+    }
+    return found ? entries : null;
+}

package/dist/src/completion.d.ts

@@ -7,6 +7,7 @@
  */
 /**
  * Return completion candidates given the current command-line words and cursor index.
+ * Requires full CLI discovery to have been run (uses getRegistry()).
  *
  * @param words  - The argv after 'opencli' (words[0] is the first arg, e.g. site name)
  * @param cursor - 1-based position of the word being completed (1 = first arg)

package/dist/src/completion.js

@@ -28,6 +28,7 @@ const BUILTIN_COMMANDS = [
 ];
 /**
  * Return completion candidates given the current command-line words and cursor index.
+ * Requires full CLI discovery to have been run (uses getRegistry()).
  *
  * @param words  - The argv after 'opencli' (words[0] is the first arg, e.g. site name)
  * @param cursor - 1-based position of the word being completed (1 = first arg)

package/dist/src/diagnostic.d.ts

@@ -32,6 +32,7 @@ export interface RepairContext {
         url: string;
         snapshot: string;
         networkRequests: unknown[];
+        capturedPayloads?: unknown[];
         consoleErrors: unknown[];
     };
     timestamp: string;

package/dist/src/diagnostic.js

@@ -24,10 +24,16 @@ const MAX_SNAPSHOT_CHARS = 100_000;
 const MAX_SOURCE_CHARS = 50_000;
 /** Maximum number of network requests to include. */
 const MAX_NETWORK_REQUESTS = 50;
+/** Maximum number of captured interceptor payloads to include. */
+const MAX_CAPTURED_PAYLOADS = 20;
 /** Maximum characters for a single network request body. */
 const MAX_REQUEST_BODY_CHARS = 4_000;
 /** Maximum characters for error stack trace. */
 const MAX_STACK_CHARS = 5_000;
+/** Maximum nesting depth for arbitrary captured payloads. */
+const MAX_CAPTURED_DEPTH = 4;
+/** Maximum object keys or array items to keep per nesting level. */
+const MAX_CAPTURED_CHILDREN = 20;
 // ── Sensitive data patterns ──────────────────────────────────────────────────
 const SENSITIVE_HEADERS = new Set([
     'authorization',
@@ -82,6 +88,39 @@ function redactHeaders(headers) {
     }
     return result;
 }
+/** Recursively sanitize arbitrary captured response content for diagnostic output. */
+function sanitizeCapturedValue(value, depth = 0) {
+    if (typeof value === 'string') {
+        return redactText(truncate(value, MAX_REQUEST_BODY_CHARS));
+    }
+    if (value === null || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (depth >= MAX_CAPTURED_DEPTH) {
+        return '[truncated: max depth reached]';
+    }
+    if (Array.isArray(value)) {
+        const items = value
+            .slice(0, MAX_CAPTURED_CHILDREN)
+            .map(item => sanitizeCapturedValue(item, depth + 1));
+        if (value.length > MAX_CAPTURED_CHILDREN) {
+            items.push(`[truncated, ${value.length - MAX_CAPTURED_CHILDREN} items omitted]`);
+        }
+        return items;
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const entries = Object.entries(value);
+    const result = {};
+    for (const [key, child] of entries.slice(0, MAX_CAPTURED_CHILDREN)) {
+        result[key] = sanitizeCapturedValue(child, depth + 1);
+    }
+    if (entries.length > MAX_CAPTURED_CHILDREN) {
+        result.__truncated__ = `[${entries.length - MAX_CAPTURED_CHILDREN} fields omitted]`;
+    }
+    return result;
+}
 /** Redact sensitive data from a single network request entry. */
 function redactNetworkRequest(req) {
     if (!req || typeof req !== 'object')
@@ -106,6 +145,12 @@ function redactNetworkRequest(req) {
     if (typeof redacted.body === 'string') {
         redacted.body = truncate(redacted.body, MAX_REQUEST_BODY_CHARS);
     }
+    if ('responseBody' in redacted) {
+        redacted.responseBody = sanitizeCapturedValue(redacted.responseBody);
+    }
+    if ('responsePreview' in redacted) {
+        redacted.responsePreview = sanitizeCapturedValue(redacted.responsePreview);
+    }
     return redacted;
 }
 // ── Timeout helper ───────────────────────────────────────────────────────────
@@ -163,23 +208,32 @@ function mapDistToSource(filePath) {
 export function isDiagnosticEnabled() {
     return process.env.OPENCLI_DIAGNOSTIC === '1';
 }
+function normalizeInterceptedRequests(interceptedRequests) {
+    return interceptedRequests.slice(0, MAX_CAPTURED_PAYLOADS).map(responseBody => ({
+        source: 'interceptor',
+        responseBody: sanitizeCapturedValue(responseBody),
+    }));
+}
 /** Safely collect page diagnostic state with redaction, size caps, and timeout. */
 async function collectPageState(page) {
     const collect = async () => {
         try {
-            const [url, snapshot, networkRequests, consoleErrors] = await Promise.all([
+            const [url, snapshot, networkRequests, interceptedRequests, consoleErrors] = await Promise.all([
                 page.getCurrentUrl?.().catch(() => null) ?? Promise.resolve(null),
                 page.snapshot().catch(() => '(snapshot unavailable)'),
                 page.networkRequests().catch(() => []),
+                page.getInterceptedRequests().catch(() => []),
                 page.consoleMessages('error').catch(() => []),
             ]);
             const rawUrl = url ?? 'unknown';
+            const capturedResponses = normalizeInterceptedRequests(interceptedRequests);
             return {
                 url: redactUrl(rawUrl),
                 snapshot: redactText(truncate(snapshot, MAX_SNAPSHOT_CHARS)),
                 networkRequests: networkRequests
                     .slice(0, MAX_NETWORK_REQUESTS)
                     .map(redactNetworkRequest),
+                capturedPayloads: capturedResponses,
                 consoleErrors: consoleErrors
                     .slice(0, 50)
                     .map(e => typeof e === 'string' ? redactText(e) : e),
@@ -235,7 +289,15 @@ export function emitDiagnostic(ctx) {
     let json = JSON.stringify(ctx);
     // Enforce total output budget — drop page state (largest section) first if over budget
     if (json.length > MAX_DIAGNOSTIC_BYTES && ctx.page) {
-        const trimmed = { ...ctx, page: { ...ctx.page, snapshot: '[omitted: over size budget]', networkRequests: [] } };
+        const trimmed = {
+            ...ctx,
+            page: {
+                ...ctx.page,
+                snapshot: '[omitted: over size budget]',
+                networkRequests: [],
+                capturedPayloads: [],
+            },
+        };
         json = JSON.stringify(trimmed);
     }
     // If still over budget, drop page entirely

package/dist/src/diagnostic.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, afterEach } from 'vitest';
-import { buildRepairContext, isDiagnosticEnabled, emitDiagnostic, truncate, redactUrl, redactText, resolveAdapterSourcePath, MAX_DIAGNOSTIC_BYTES, } from './diagnostic.js';
+import { buildRepairContext, collectDiagnostic, isDiagnosticEnabled, emitDiagnostic, truncate, redactUrl, redactText, resolveAdapterSourcePath, MAX_DIAGNOSTIC_BYTES, } from './diagnostic.js';
 import { SelectorError, CommandExecutionError } from './errors.js';
 function makeCmd(overrides = {}) {
     return {
@@ -83,8 +83,8 @@ describe('redactText', () => {
 });
 describe('resolveAdapterSourcePath', () => {
     it('returns source when it is a real file path (not manifest:)', () => {
-        const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.yaml' });
-        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.opencli/clis/arxiv/search.yaml');
+        const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.ts' });
+        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.opencli/clis/arxiv/search.ts');
     });
     it('skips manifest: pseudo-paths and falls back to _modulePath', () => {
         const cmd = makeCmd({ source: 'manifest:arxiv/search', _modulePath: '/pkg/dist/clis/arxiv/search.js' });
@@ -211,3 +211,93 @@ describe('emitDiagnostic', () => {
         expect(redactUrl('https://api.com/data?token=secret123')).toContain('[REDACTED]');
     });
 });
+function makePage(overrides = {}) {
+    return {
+        goto: vi.fn(),
+        evaluate: vi.fn(),
+        getCookies: vi.fn(),
+        snapshot: vi.fn().mockResolvedValue('<div>...</div>'),
+        click: vi.fn(),
+        typeText: vi.fn(),
+        pressKey: vi.fn(),
+        scrollTo: vi.fn(),
+        getFormState: vi.fn(),
+        wait: vi.fn(),
+        tabs: vi.fn(),
+        selectTab: vi.fn(),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn(),
+        autoScroll: vi.fn(),
+        installInterceptor: vi.fn(),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        waitForCapture: vi.fn(),
+        screenshot: vi.fn(),
+        getCurrentUrl: vi.fn().mockResolvedValue('https://example.com/page'),
+        ...overrides,
+    };
+}
+describe('collectDiagnostic', () => {
+    it('keeps intercepted payloads in a dedicated capturedPayloads field', async () => {
+        const page = makePage({
+            networkRequests: vi.fn().mockResolvedValue([{ url: '/api/data', status: 200 }]),
+            getInterceptedRequests: vi.fn().mockResolvedValue([{ items: [{ id: 1 }] }]),
+        });
+        const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
+        expect(ctx.page?.networkRequests).toEqual([
+            { url: '/api/data', status: 200 },
+        ]);
+        expect(ctx.page?.capturedPayloads).toEqual([
+            { source: 'interceptor', responseBody: { items: [{ id: 1 }] } },
+        ]);
+    });
+    it('preserves the previous network request output when interception is empty', async () => {
+        const page = makePage({
+            networkRequests: vi.fn().mockResolvedValue([{ url: '/api/data', status: 200 }]),
+            getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        });
+        const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
+        expect(ctx.page?.networkRequests).toEqual([{ url: '/api/data', status: 200 }]);
+        expect(ctx.page?.capturedPayloads).toEqual([]);
+    });
+    it('swallows intercepted request failures and still returns page state', async () => {
+        const page = makePage({
+            networkRequests: vi.fn().mockResolvedValue([{ url: '/api/data', status: 200 }]),
+            getInterceptedRequests: vi.fn().mockRejectedValue(new Error('interceptor unavailable')),
+        });
+        const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
+        expect(ctx.page).toEqual({
+            url: 'https://example.com/page',
+            snapshot: '<div>...</div>',
+            networkRequests: [{ url: '/api/data', status: 200 }],
+            capturedPayloads: [],
+            consoleErrors: [],
+        });
+    });
+    it('redacts and truncates intercepted payloads recursively', async () => {
+        const page = makePage({
+            getInterceptedRequests: vi.fn().mockResolvedValue([{
+                    token: 'token=abc123def456ghi789',
+                    nested: {
+                        cookie: 'cookie: session=super-secret-cookie-value',
+                        body: 'x'.repeat(5000),
+                    },
+                }]),
+        });
+        const ctx = await collectDiagnostic(new Error('boom'), makeCmd(), page);
+        const payload = ctx.page?.capturedPayloads?.[0];
+        const body = payload.responseBody.nested.body;
+        expect(payload).toEqual({
+            source: 'interceptor',
+            responseBody: {
+                token: 'token=[REDACTED]',
+                nested: {
+                    cookie: 'cookie: [REDACTED]',
+                    body,
+                },
+            },
+        });
+        expect(body).toContain('[truncated,');
+        expect(body.length).toBeLessThan(5000);
+    });
+});