@jackwener/opencli 1.7.8 → 1.7.10

package/dist/src/diagnostic.js

@@ -1,292 +0,0 @@
-/**
- * Structured diagnostic output for AI-driven adapter repair.
- *
- * When OPENCLI_DIAGNOSTIC=1, failed commands emit a JSON RepairContext to stderr
- * containing the error, adapter source, and browser state (DOM snapshot, network
- * requests, console errors). AI Agents consume this to diagnose and fix adapters.
- *
- * Safety boundaries:
- * - Sensitive headers/cookies are redacted before emission
- * - Individual fields are capped to prevent unbounded output
- * - Network response bodies from authenticated requests are stripped
- * - Total output is capped to MAX_DIAGNOSTIC_BYTES
- */
-import * as fs from 'node:fs';
-import { CliError, getErrorMessage } from './errors.js';
-import { fullName } from './registry.js';
-// ── Size budgets ─────────────────────────────────────────────────────────────
-/** Maximum bytes for the entire diagnostic JSON output. */
-export const MAX_DIAGNOSTIC_BYTES = 256 * 1024; // 256 KB
-/** Maximum characters for DOM snapshot. */
-const MAX_SNAPSHOT_CHARS = 100_000;
-/** Maximum characters for adapter source. */
-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',
-    'cookie',
-    'set-cookie',
-    'x-csrf-token',
-    'x-xsrf-token',
-    'proxy-authorization',
-    'x-api-key',
-    'x-auth-token',
-]);
-const SENSITIVE_URL_PARAMS = /([?&])(token|key|secret|password|auth|access_token|api_key|session_id|csrf)=[^&]*/gi;
-/** Patterns that match inline secrets in free-text strings (error messages, stack traces, console output, DOM). */
-const SENSITIVE_TEXT_PATTERNS = [
-    // Bearer tokens
-    { pattern: /Bearer\s+[A-Za-z0-9\-._~+/]+=*/gi, replacement: 'Bearer [REDACTED]' },
-    // Generic "token=...", "key=...", etc. in non-URL text
-    { pattern: /(token|secret|password|api_key|apikey|access_token|session_id)[=:]\s*['"]?[A-Za-z0-9\-._~+/]{8,}['"]?/gi, replacement: '$1=[REDACTED]' },
-    // Cookie header values (key=value pairs)
-    { pattern: /(cookie[=:]\s*)[^\n;]{10,}/gi, replacement: '$1[REDACTED]' },
-    // JWT-like tokens (three base64 segments separated by dots)
-    { pattern: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, replacement: '[REDACTED_JWT]' },
-];
-// ── Redaction helpers ────────────────────────────────────────────────────────
-/** Truncate a string to maxLen, appending a truncation marker. */
-export function truncate(str, maxLen) {
-    if (str.length <= maxLen)
-        return str;
-    return str.slice(0, maxLen) + `\n...[truncated, ${str.length - maxLen} chars omitted]`;
-}
-/** Redact sensitive query parameters from a URL. */
-export function redactUrl(url) {
-    return url.replace(SENSITIVE_URL_PARAMS, '$1$2=[REDACTED]');
-}
-/** Redact inline secrets from free-text strings (error messages, stack traces, console output, DOM). */
-export function redactText(text) {
-    let result = text;
-    for (const { pattern, replacement } of SENSITIVE_TEXT_PATTERNS) {
-        // Reset lastIndex for global regexps
-        pattern.lastIndex = 0;
-        result = result.replace(pattern, replacement);
-    }
-    return result;
-}
-/** Redact sensitive headers from a headers object. */
-function redactHeaders(headers) {
-    if (!headers || typeof headers !== 'object')
-        return headers;
-    const result = {};
-    for (const [key, value] of Object.entries(headers)) {
-        result[key] = SENSITIVE_HEADERS.has(key.toLowerCase()) ? '[REDACTED]' : value;
-    }
-    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')
-        return req;
-    const r = req;
-    const redacted = { ...r };
-    // Redact URL
-    if (typeof redacted.url === 'string') {
-        redacted.url = redactUrl(redacted.url);
-    }
-    // Redact headers
-    if (redacted.headers && typeof redacted.headers === 'object') {
-        redacted.headers = redactHeaders(redacted.headers);
-    }
-    if (redacted.requestHeaders && typeof redacted.requestHeaders === 'object') {
-        redacted.requestHeaders = redactHeaders(redacted.requestHeaders);
-    }
-    if (redacted.responseHeaders && typeof redacted.responseHeaders === 'object') {
-        redacted.responseHeaders = redactHeaders(redacted.responseHeaders);
-    }
-    // Redact and truncate response body
-    if (typeof redacted.body === 'string') {
-        redacted.body = redactText(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 ───────────────────────────────────────────────────────────
-/** Timeout for page state collection (prevents hang when CDP connection is stuck). */
-const PAGE_STATE_TIMEOUT_MS = 5_000;
-function withTimeout(promise, ms, fallback) {
-    return Promise.race([
-        promise,
-        new Promise(resolve => setTimeout(() => resolve(fallback), ms)),
-    ]);
-}
-// ── Source path resolution ───────────────────────────────────────────────────
-/**
- * Resolve the editable source file path for an adapter.
- *
- * Priority:
- * 1. cmd.source (set for FS-scanned JS and manifest lazy-loaded JS)
- * 2. cmd._modulePath (set for manifest lazy-loaded JS)
- *
- * Skip manifest: prefixed pseudo-paths (YAML commands inlined in manifest).
- */
-export function resolveAdapterSourcePath(cmd) {
-    const candidates = [];
-    // cmd.source may be a real file path or 'manifest:site/name'
-    if (cmd.source && !cmd.source.startsWith('manifest:')) {
-        candidates.push(cmd.source);
-    }
-    if (cmd._modulePath) {
-        candidates.push(cmd._modulePath);
-    }
-    for (const candidate of candidates) {
-        if (fs.existsSync(candidate))
-            return candidate;
-    }
-    return candidates[0]; // Return best guess even if file doesn't exist
-}
-// ── Diagnostic collection ────────────────────────────────────────────────────
-/** Whether diagnostic mode is enabled. */
-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, 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),
-            };
-        }
-        catch {
-            return undefined;
-        }
-    };
-    return withTimeout(collect(), PAGE_STATE_TIMEOUT_MS, undefined);
-}
-/** Read adapter source file content with size cap. */
-function readAdapterSource(sourcePath) {
-    if (!sourcePath)
-        return undefined;
-    try {
-        const content = fs.readFileSync(sourcePath, 'utf-8');
-        return truncate(content, MAX_SOURCE_CHARS);
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Build a RepairContext from an error, command metadata, and optional page state. */
-export function buildRepairContext(err, cmd, pageState) {
-    const isCliError = err instanceof CliError;
-    const sourcePath = resolveAdapterSourcePath(cmd);
-    return {
-        error: {
-            code: isCliError ? err.code : 'UNKNOWN',
-            message: redactText(getErrorMessage(err)),
-            hint: isCliError && err.hint ? redactText(err.hint) : undefined,
-            stack: err instanceof Error ? redactText(truncate(err.stack ?? '', MAX_STACK_CHARS)) : undefined,
-        },
-        adapter: {
-            site: cmd.site,
-            command: fullName(cmd),
-            sourcePath,
-            source: readAdapterSource(sourcePath),
-        },
-        page: pageState,
-        timestamp: new Date().toISOString(),
-    };
-}
-/** Collect full diagnostic context including page state (with timeout). */
-export async function collectDiagnostic(err, cmd, page) {
-    const pageState = page ? await collectPageState(page) : undefined;
-    return buildRepairContext(err, cmd, pageState);
-}
-/** Emit diagnostic JSON to stderr, enforcing total size cap. */
-export function emitDiagnostic(ctx) {
-    const marker = '___OPENCLI_DIAGNOSTIC___';
-    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: [],
-                capturedPayloads: [],
-            },
-        };
-        json = JSON.stringify(trimmed);
-    }
-    // If still over budget, drop page entirely
-    if (json.length > MAX_DIAGNOSTIC_BYTES) {
-        const minimal = { ...ctx, page: undefined };
-        json = JSON.stringify(minimal);
-    }
-    process.stderr.write(`\n${marker}\n${json}\n${marker}\n`);
-}

package/dist/src/diagnostic.test.js

@@ -1,302 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
-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 {
-        site: 'test-site',
-        name: 'test-cmd',
-        description: 'test',
-        args: [],
-        ...overrides,
-    };
-}
-describe('isDiagnosticEnabled', () => {
-    const origEnv = process.env.OPENCLI_DIAGNOSTIC;
-    afterEach(() => {
-        if (origEnv === undefined)
-            delete process.env.OPENCLI_DIAGNOSTIC;
-        else
-            process.env.OPENCLI_DIAGNOSTIC = origEnv;
-    });
-    it('returns false when env not set', () => {
-        delete process.env.OPENCLI_DIAGNOSTIC;
-        expect(isDiagnosticEnabled()).toBe(false);
-    });
-    it('returns true when env is "1"', () => {
-        process.env.OPENCLI_DIAGNOSTIC = '1';
-        expect(isDiagnosticEnabled()).toBe(true);
-    });
-    it('returns false for other values', () => {
-        process.env.OPENCLI_DIAGNOSTIC = 'true';
-        expect(isDiagnosticEnabled()).toBe(false);
-    });
-});
-describe('truncate', () => {
-    it('returns short strings unchanged', () => {
-        expect(truncate('hello', 100)).toBe('hello');
-    });
-    it('truncates long strings with marker', () => {
-        const long = 'a'.repeat(200);
-        const result = truncate(long, 50);
-        expect(result.length).toBeLessThan(200);
-        expect(result).toContain('...[truncated,');
-        expect(result).toContain('150 chars omitted]');
-    });
-});
-describe('redactUrl', () => {
-    it('redacts sensitive query parameters', () => {
-        expect(redactUrl('https://api.com/v1?token=abc123&q=test'))
-            .toBe('https://api.com/v1?token=[REDACTED]&q=test');
-    });
-    it('redacts multiple sensitive params', () => {
-        const url = 'https://api.com?api_key=xxx&secret=yyy&page=1';
-        const result = redactUrl(url);
-        expect(result).toContain('api_key=[REDACTED]');
-        expect(result).toContain('secret=[REDACTED]');
-        expect(result).toContain('page=1');
-    });
-    it('leaves clean URLs unchanged', () => {
-        expect(redactUrl('https://example.com/page?q=test')).toBe('https://example.com/page?q=test');
-    });
-});
-describe('redactText', () => {
-    it('redacts Bearer tokens', () => {
-        expect(redactText('Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.test'))
-            .toContain('Bearer [REDACTED]');
-    });
-    it('redacts JWT tokens', () => {
-        const jwt = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.dozjgNryP4J3jVmNHl0w5N_XgL0n3I9PlFUP0THsR8U';
-        expect(redactText(`token is ${jwt}`)).toContain('[REDACTED_JWT]');
-        expect(redactText(`token is ${jwt}`)).not.toContain('eyJhbGci');
-    });
-    it('redacts inline token=value patterns', () => {
-        expect(redactText('failed with token=abc123def456')).toContain('token=[REDACTED]');
-    });
-    it('redacts cookie values', () => {
-        const result = redactText('cookie: session=abc123; user=xyz789; path=/');
-        expect(result).toContain('[REDACTED]');
-        expect(result).not.toContain('session=abc123');
-    });
-    it('leaves normal text unchanged', () => {
-        expect(redactText('Error: element not found')).toBe('Error: element not found');
-    });
-});
-describe('resolveAdapterSourcePath', () => {
-    it('returns source when it is a real file path (not manifest:)', () => {
-        const cmd = makeCmd({ source: '/home/user/.opencli/clis/arxiv/search.js' });
-        expect(resolveAdapterSourcePath(cmd)).toBe('/home/user/.opencli/clis/arxiv/search.js');
-    });
-    it('skips manifest: pseudo-paths and falls back to _modulePath', () => {
-        const cmd = makeCmd({ source: 'manifest:arxiv/search', _modulePath: '/pkg/clis/arxiv/search.js' });
-        // Should try to map to source, but since files don't exist on disk, returns _modulePath
-        const result = resolveAdapterSourcePath(cmd);
-        expect(result).toBeDefined();
-        expect(result).not.toContain('manifest:');
-    });
-    it('returns undefined when only manifest: pseudo-path and no _modulePath', () => {
-        const cmd = makeCmd({ source: 'manifest:test/cmd' });
-        expect(resolveAdapterSourcePath(cmd)).toBeUndefined();
-    });
-    it('returns _modulePath when it is the only path available', () => {
-        const cmd = makeCmd({ _modulePath: '/project/clis/site/cmd.js' });
-        const result = resolveAdapterSourcePath(cmd);
-        // Since file doesn't exist, returns _modulePath as best guess
-        expect(result).toBe('/project/clis/site/cmd.js');
-    });
-});
-describe('buildRepairContext', () => {
-    it('captures CliError fields', () => {
-        const err = new SelectorError('.missing-element', 'Element removed');
-        const ctx = buildRepairContext(err, makeCmd());
-        expect(ctx.error.code).toBe('SELECTOR');
-        expect(ctx.error.message).toContain('.missing-element');
-        expect(ctx.error.hint).toBe('Element removed');
-        expect(ctx.error.stack).toBeDefined();
-        expect(ctx.adapter.site).toBe('test-site');
-        expect(ctx.adapter.command).toBe('test-site/test-cmd');
-        expect(ctx.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/);
-    });
-    it('handles non-CliError errors', () => {
-        const err = new TypeError('Cannot read property "x" of undefined');
-        const ctx = buildRepairContext(err, makeCmd());
-        expect(ctx.error.code).toBe('UNKNOWN');
-        expect(ctx.error.message).toContain('Cannot read property');
-        expect(ctx.error.hint).toBeUndefined();
-    });
-    it('includes page state when provided', () => {
-        const pageState = {
-            url: 'https://example.com/page',
-            snapshot: '<div>...</div>',
-            networkRequests: [{ url: '/api/data', status: 200 }],
-            consoleErrors: ['Uncaught TypeError'],
-        };
-        const ctx = buildRepairContext(new CommandExecutionError('boom'), makeCmd(), pageState);
-        expect(ctx.page).toEqual(pageState);
-    });
-    it('omits page when not provided', () => {
-        const ctx = buildRepairContext(new Error('boom'), makeCmd());
-        expect(ctx.page).toBeUndefined();
-    });
-    it('truncates long stack traces', () => {
-        const err = new Error('boom');
-        err.stack = 'x'.repeat(10_000);
-        const ctx = buildRepairContext(err, makeCmd());
-        expect(ctx.error.stack.length).toBeLessThan(10_000);
-        expect(ctx.error.stack).toContain('truncated');
-    });
-    it('redacts sensitive data in error message and stack', () => {
-        const err = new Error('Request failed with Bearer eyJhbGciOiJIUzI1NiJ9.test.sig');
-        const ctx = buildRepairContext(err, makeCmd());
-        expect(ctx.error.message).toContain('Bearer [REDACTED]');
-        expect(ctx.error.message).not.toContain('eyJhbGci');
-        // Stack also gets redacted
-        expect(ctx.error.stack).toContain('Bearer [REDACTED]');
-    });
-});
-describe('emitDiagnostic', () => {
-    it('writes delimited JSON to stderr', () => {
-        const writeSpy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
-        const ctx = buildRepairContext(new CommandExecutionError('test error'), makeCmd());
-        emitDiagnostic(ctx);
-        const output = writeSpy.mock.calls.map(c => c[0]).join('');
-        expect(output).toContain('___OPENCLI_DIAGNOSTIC___');
-        expect(output).toContain('"code":"COMMAND_EXEC"');
-        expect(output).toContain('"message":"test error"');
-        // Verify JSON is parseable between markers
-        const match = output.match(/___OPENCLI_DIAGNOSTIC___\n(.*)\n___OPENCLI_DIAGNOSTIC___/);
-        expect(match).toBeTruthy();
-        const parsed = JSON.parse(match[1]);
-        expect(parsed.error.code).toBe('COMMAND_EXEC');
-        writeSpy.mockRestore();
-    });
-    it('drops page snapshot when over size budget', () => {
-        const writeSpy = vi.spyOn(process.stderr, 'write').mockReturnValue(true);
-        const ctx = {
-            error: { code: 'COMMAND_EXEC', message: 'boom' },
-            adapter: { site: 'test', command: 'test/cmd' },
-            page: {
-                url: 'https://example.com',
-                snapshot: 'x'.repeat(MAX_DIAGNOSTIC_BYTES + 1000),
-                networkRequests: [],
-                consoleErrors: [],
-            },
-            timestamp: new Date().toISOString(),
-        };
-        emitDiagnostic(ctx);
-        const output = writeSpy.mock.calls.map(c => c[0]).join('');
-        const match = output.match(/___OPENCLI_DIAGNOSTIC___\n(.*)\n___OPENCLI_DIAGNOSTIC___/);
-        expect(match).toBeTruthy();
-        const parsed = JSON.parse(match[1]);
-        // Page snapshot should be replaced or page dropped entirely
-        expect(parsed.page?.snapshot !== ctx.page.snapshot || parsed.page === undefined).toBe(true);
-        expect(match[1].length).toBeLessThanOrEqual(MAX_DIAGNOSTIC_BYTES);
-        writeSpy.mockRestore();
-    });
-    it('redacts sensitive headers in network requests', () => {
-        const pageState = {
-            url: 'https://example.com',
-            snapshot: '<div/>',
-            networkRequests: [{
-                    url: 'https://api.com/data?token=secret123',
-                    headers: { authorization: 'Bearer xyz', 'content-type': 'application/json' },
-                    body: '{"data": "ok"}',
-                }],
-            consoleErrors: [],
-        };
-        // Build context manually to test redaction via collectPageState
-        // Since collectPageState is private, test the output of buildRepairContext
-        // with already-collected page state — redaction happens in collectPageState.
-        // For unit test, verify redactUrl directly (tested above) and trust integration.
-        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);
-    });
-});