browser-debugger-cli 0.7.2 → 0.9.0

package/dist/commands/peek.js

@@ -1,59 +1,67 @@
 /**
  * Peek command for previewing collected session data.
  */
-import { runCommand } from '../commands/shared/CommandRunner.js';
-import { jsonOption } from '../commands/shared/commonOptions.js';
-import { handleDaemonConnectionError } from '../commands/shared/daemonErrorHandler.js';
-import { fetchPreviewOutput, createErrorResult, } from '../commands/shared/dataFetcher.js';
-import { setupFollowMode } from '../commands/shared/followMode.js';
-import { positiveIntRule, resourceTypeRule } from '../commands/shared/validation.js';
+import { runCommand } from './shared/CommandRunner.js';
+import { jsonOption, showBothSectionsWhenBothRequested } from './shared/commonOptions.js';
+import { noteFollowConnected } from './shared/daemonErrorHandler.js';
+import { fetchPreviewOutput, createErrorResult, } from './shared/dataFetcher.js';
+import { followFetchFailure, setupFollowMode, } from './shared/followMode.js';
+import { handleValidationError } from './shared/handleValidationError.js';
+import { MAX_LAST_ITEMS, positiveIntRule, resourceTypeRule } from './shared/validation.js';
 import { filterByResourceType } from '../telemetry/filters.js';
-import { OutputBuilder } from '../ui/OutputBuilder.js';
-import { CommandError } from '../ui/errors/index.js';
-import { formatPreview } from '../ui/formatters/preview.js';
+import { buildPreviewJsonData, formatPreview, } from '../ui/formatters/preview.js';
 import { followingPreviewMessage, stoppedFollowingPreviewMessage } from '../ui/messages/preview.js';
-import { EXIT_CODES } from '../utils/exitCodes.js';
 function parseOptions(options) {
-    const lastN = positiveIntRule({ min: 1, max: 1000, default: 10 }).validate(options.last);
+    const lastN = positiveIntRule({
+        name: '--last',
+        min: 1,
+        max: MAX_LAST_ITEMS,
+        default: 10,
+        allowZeroForAll: true,
+    }).validate(options.last);
     const resourceTypes = resourceTypeRule().validate(options.type);
     return { lastN, resourceTypes };
 }
-function handleValidationError(error, json) {
-    if (error instanceof CommandError) {
-        if (json) {
-            const errorOptions = {
-                exitCode: error.exitCode,
-            };
-            if (error.metadata.suggestion) {
-                errorOptions.suggestion = error.metadata.suggestion;
-            }
-            console.log(JSON.stringify(OutputBuilder.buildJsonError(error.message, errorOptions)));
-        }
-        else {
-            console.error(error.message);
-            if (error.metadata.suggestion)
-                console.error(error.metadata.suggestion);
-        }
-        process.exit(error.exitCode);
-    }
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(EXIT_CODES.INVALID_ARGUMENTS);
+/**
+ * Data section selected by `--network` / `--console`, if any.
+ *
+ * @param options - Peek options
+ * @returns Section to fetch, or undefined for both
+ */
+function peekSection(options) {
+    if (options.network)
+        return 'network';
+    return options.console ? 'console' : undefined;
 }
-async function fetchAndFilterPreview(lastN, resourceTypes) {
-    const result = await fetchPreviewOutput(lastN);
+/**
+ * Fetch the preview, filtering network requests by resource type first.
+ *
+ * With a type filter all requests are fetched and filtered before the
+ * `--last` window is applied, so older matches are not hidden by newer
+ * requests of other types.
+ *
+ * @param lastN - Items to show (0 = all)
+ * @param resourceTypes - Resource types to keep (empty = all)
+ * @param only - Fetch only network or only console data
+ * @returns Preview with filtered network data and the unfiltered request count
+ */
+async function fetchAndFilterPreview(lastN, resourceTypes, only) {
+    const result = await fetchPreviewOutput({
+        lastN: resourceTypes.length > 0 ? 0 : lastN,
+        ...(only && { only }),
+    });
     if (!result.success)
         return result;
     const output = result.data;
-    const unfilteredNetworkCount = output.data.network?.length ?? 0;
-    if (resourceTypes.length === 0) {
+    const unfilteredNetworkCount = output.totals?.network ?? output.data.network?.length ?? 0;
+    if (resourceTypes.length === 0 || !output.data.network) {
         return { success: true, data: { output, unfilteredNetworkCount } };
     }
-    const filteredNetwork = output.data.network
-        ? filterByResourceType(output.data.network, resourceTypes)
-        : undefined;
+    const network = filterByResourceType(output.data.network, resourceTypes);
     const filteredOutput = {
         ...output,
-        data: { ...output.data, ...(filteredNetwork && { network: filteredNetwork }) },
+        data: { ...output.data, network },
+        ...(output.totals && { totals: { ...output.totals, network: network.length } }),
     };
     return { success: true, data: { output: filteredOutput, unfilteredNetworkCount } };
 }
@@ -69,21 +77,16 @@ function createPreviewOptions(base, resourceTypes, unfilteredCount) {
 }
 async function runFollowMode(options, lastN, resourceTypes, baseOptions) {
     const showPreview = async () => {
-        const result = await fetchAndFilterPreview(lastN, resourceTypes);
+        const result = await fetchAndFilterPreview(lastN, resourceTypes, peekSection(options));
         if (!result.success) {
-            const errorResult = handleDaemonConnectionError(result.error, {
-                json: options.json,
-                follow: true,
-                retryIntervalMs: 1000,
-                exitCode: result.exitCode,
-            });
-            if (errorResult.shouldExit)
-                process.exit(errorResult.exitCode);
-            return;
+            return followFetchFailure(result, { json: options.json, retryIntervalMs: 1000 });
         }
-        console.clear();
+        noteFollowConnected();
+        if (!options.json)
+            console.clear();
         const previewOptions = createPreviewOptions(baseOptions, resourceTypes, result.data.unfilteredNetworkCount);
         console.log(formatPreview(result.data.output, previewOptions));
+        return undefined;
     };
     await setupFollowMode(showPreview, {
         startMessage: followingPreviewMessage,
@@ -99,11 +102,11 @@ export function registerPeekCommand(program) {
         .option('-v, --verbose', 'Use verbose output with full URLs and formatting', false)
         .option('-n, --network', 'Show only network requests', false)
         .option('-c, --console', 'Show only console messages', false)
-        .option('-d, --dom', 'Show DOM/A11y tree data', false)
         .option('-f, --follow', 'Watch for updates (like tail -f)', false)
-        .option('--last <count>', 'Show last N items (default: 10)', '10')
+        .option('--last <count>', 'Show last N items, 0 for all', '10')
         .option('--type <types>', 'Filter network requests by resource type (comma-separated: Document,XHR,Fetch,etc.)')
         .action(async (options) => {
+        showBothSectionsWhenBothRequested(options);
         if (options.network && !options.json) {
             console.error('Note: "bdg peek --network" is deprecated. Use "bdg network list" for enhanced filtering.');
         }
@@ -121,7 +124,6 @@ export function registerPeekCommand(program) {
             json: options.json,
             network: options.network,
             console: options.console,
-            dom: options.dom,
             last: lastN,
             verbose: options.verbose,
             follow: options.follow,
@@ -131,12 +133,17 @@ export function registerPeekCommand(program) {
             return;
         }
         await runCommand(async () => {
-            const result = await fetchAndFilterPreview(lastN, resourceTypes);
+            const result = await fetchAndFilterPreview(lastN, resourceTypes, peekSection(options));
             if (!result.success) {
-                return createErrorResult(result.error, result.exitCode);
+                return createErrorResult(result.error, result.exitCode, result.suggestion);
             }
-            return { success: true, data: result.data.output };
-        }, options, (output) => {
+            const { output } = result.data;
+            return {
+                success: true,
+                data: options.json ? buildPreviewJsonData(output, baseOptions) : output,
+            };
+        }, options, (data) => {
+            const output = data;
             const previewOptions = createPreviewOptions(baseOptions, resourceTypes, output.data.network?.length ?? 0);
             return formatPreview(output, previewOptions);
         });

package/dist/commands/sessions.d.ts

@@ -0,0 +1,8 @@
+import type { Command } from 'commander';
+/**
+ * Register the sessions command (lists running default and named sessions).
+ *
+ * @param program - Commander.js Command instance to register commands on
+ */
+export declare function registerSessionsCommand(program: Command): void;
+//# sourceMappingURL=sessions.d.ts.map

package/dist/commands/sessions.js

@@ -0,0 +1,19 @@
+import { runCommand } from './shared/CommandRunner.js';
+import { jsonOption } from './shared/commonOptions.js';
+import { listRunningSessions } from '../session/sessionList.js';
+import { formatSessionList } from '../ui/formatters/sessions.js';
+/**
+ * Register the sessions command (lists running default and named sessions).
+ *
+ * @param program - Commander.js Command instance to register commands on
+ */
+export function registerSessionsCommand(program) {
+    program
+        .command('sessions')
+        .description('List sessions (default and named) with their state, URL, port and PID, including crashed ones to clean up')
+        .addOption(jsonOption())
+        .action(async (options) => {
+        await runCommand(async () => ({ success: true, data: { sessions: await listRunningSessions() } }), options, formatSessionList);
+    });
+}
+//# sourceMappingURL=sessions.js.map

package/dist/commands/shared/CommandRunner.d.ts

@@ -1,5 +1,13 @@
-import { type BaseOptions } from '../../commands/shared/optionTypes.js';
+import { type BaseOptions } from './optionTypes.js';
+import { CommandError } from '../../errors/index.js';
+import { IPCTimeoutError } from '../../ipc/transport/IPCError.js';
 export type { BaseOptions };
+/**
+ * The error every command gives when there is no session to talk to.
+ *
+ * @returns Command error (exit 83) with how to start one
+ */
+export declare function noActiveSessionError(): CommandError;
 /**
  * Execute an async function and output JSON result with proper error handling.
  *
@@ -49,6 +57,15 @@ export type CommandHandler<TOptions extends BaseOptions, TResult = unknown> = (o
  * @returns Formatted string to be output to console
  */
 export type CommandFormatter<TResult = unknown> = (data: TResult) => string;
+/**
+ * An IPC timeout as a user-facing error (exit 102): a quick request (status,
+ * peek, the handshake before page work) means the session is not responding;
+ * a long one means the command itself did not finish.
+ *
+ * @param error - IPC timeout
+ * @returns Command error with a way out
+ */
+export declare function timeoutError(error: IPCTimeoutError): CommandError;
 /**
  * Run a command with consistent error handling, output formatting, and exit codes.
  * Eliminates boilerplate try-catch and JSON output logic from command handlers.

package/dist/commands/shared/CommandRunner.js

@@ -1,8 +1,20 @@
-import { OutputBuilder } from '../../ui/OutputBuilder.js';
-import { CommandError, isDaemonConnectionError } from '../../ui/errors/index.js';
-import { daemonNotRunningError, unknownError, genericError } from '../../ui/messages/errors.js';
-import { getErrorMessage } from '../../utils/errors.js';
+import { getQuickIPCRequestTimeout } from '../../constants.js';
+import { CommandError, isDaemonConnectionError } from '../../errors/index.js';
+import { daemonNotRunningError, unknownError, genericError, commandTimedOutError, sessionNotRespondingError, sessionEndedDuringCommandError, } from '../../errors/messages.js';
+import { IPCEarlyCloseError, IPCTimeoutError } from '../../ipc/transport/IPCError.js';
+import { OutputBuilder, buildSuccessResponse } from '../../ui/OutputBuilder.js';
+import { escapeControlChars } from '../../ui/formatting.js';
+import { noActiveSessionMessage, startSessionSuggestion } from '../../ui/messages/sessionCommand.js';
+import { getErrorExitCode, getErrorMessage } from '../../utils/errors.js';
 import { EXIT_CODES } from '../../utils/exitCodes.js';
+/**
+ * The error every command gives when there is no session to talk to.
+ *
+ * @returns Command error (exit 83) with how to start one
+ */
+export function noActiveSessionError() {
+    return new CommandError(noActiveSessionMessage(), { suggestion: startSessionSuggestion() }, EXIT_CODES.RESOURCE_NOT_FOUND);
+}
 /**
  * Execute an async function and output JSON result with proper error handling.
  *
@@ -24,15 +36,50 @@ import { EXIT_CODES } from '../../utils/exitCodes.js';
 export async function runJsonCommand(fn) {
     try {
         const data = await fn();
-        console.log(JSON.stringify(data, null, 2));
+        console.log(JSON.stringify(buildSuccessResponse(data), null, 2));
         process.exit(EXIT_CODES.SUCCESS);
     }
-    catch (error) {
-        const exitCode = error instanceof CommandError ? error.exitCode : EXIT_CODES.UNHANDLED_EXCEPTION;
-        console.log(JSON.stringify(OutputBuilder.buildJsonError(getErrorMessage(error)), null, 2));
+    catch (caught) {
+        const error = isDaemonConnectionError(caught)
+            ? noActiveSessionError()
+            : caught instanceof IPCTimeoutError
+                ? timeoutError(caught)
+                : caught;
+        const exitCode = getErrorExitCode(error, EXIT_CODES.UNHANDLED_EXCEPTION);
+        const suggestion = error instanceof CommandError && typeof error.metadata['suggestion'] === 'string'
+            ? error.metadata['suggestion']
+            : undefined;
+        console.log(JSON.stringify(OutputBuilder.buildJsonError(getErrorMessage(error), {
+            exitCode,
+            ...(suggestion && { suggestion }),
+        }), null, 2));
         process.exit(exitCode);
     }
 }
+/**
+ * An IPC timeout as a user-facing error (exit 102): a quick request (status,
+ * peek, the handshake before page work) means the session is not responding;
+ * a long one means the command itself did not finish.
+ *
+ * @param error - IPC timeout
+ * @returns Command error with a way out
+ */
+export function timeoutError(error) {
+    const seconds = error.timeoutMs / 1000;
+    const err = error.timeoutMs <= getQuickIPCRequestTimeout()
+        ? sessionNotRespondingError(seconds)
+        : commandTimedOutError(seconds);
+    return new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.CDP_TIMEOUT);
+}
+/**
+ * The daemon closed the connection before answering: the session ended.
+ *
+ * @returns Command error (83)
+ */
+function sessionEndedError() {
+    const err = sessionEndedDuringCommandError();
+    return new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.RESOURCE_NOT_FOUND);
+}
 /**
  * Run a command with consistent error handling, output formatting, and exit codes.
  * Eliminates boilerplate try-catch and JSON output logic from command handlers.
@@ -63,49 +110,57 @@ export async function runCommand(handler, options, formatter) {
     try {
         const result = await handler(options);
         if (!result.success) {
+            const exitCode = result.exitCode ?? EXIT_CODES.UNHANDLED_EXCEPTION;
             if (options.json) {
-                const errorData = {
-                    ...(result.exitCode !== undefined && { exitCode: result.exitCode }),
+                console.log(JSON.stringify(OutputBuilder.buildJsonError(result.error ?? 'Unknown error', {
                     ...result.errorContext,
-                };
-                console.log(JSON.stringify(OutputBuilder.buildJsonError(result.error ?? 'Unknown error', errorData), null, 2));
+                    exitCode,
+                }), null, 2));
             }
             else {
                 console.error(result.error ? genericError(result.error) : unknownError());
                 if (result.errorContext && typeof result.errorContext === 'object') {
                     for (const value of Object.values(result.errorContext)) {
                         if (value !== undefined && value !== null) {
-                            console.error(typeof value === 'string' ? value : JSON.stringify(value));
+                            console.error(escapeControlChars(typeof value === 'string' ? value : JSON.stringify(value)));
                         }
                     }
                 }
             }
-            process.exit(result.exitCode ?? EXIT_CODES.UNHANDLED_EXCEPTION);
+            process.exit(exitCode);
         }
-        if (result.hint) {
-            console.error(result.hint);
+        if (result.hint && !options.quiet) {
+            console.error(escapeControlChars(result.hint));
         }
         if (options.json) {
-            console.log(JSON.stringify(result.data, null, 2));
+            console.log(JSON.stringify(buildSuccessResponse(result.data), null, 2));
         }
         else if (formatter) {
             const formattedOutput = formatter(result.data);
-            console.log(formattedOutput);
+            console.log(escapeControlChars(formattedOutput));
         }
         else {
-            console.log(JSON.stringify(result.data, null, 2));
+            console.log(JSON.stringify(buildSuccessResponse(result.data), null, 2));
         }
         process.exit(EXIT_CODES.SUCCESS);
     }
-    catch (error) {
+    catch (caught) {
+        const error = caught instanceof IPCTimeoutError
+            ? timeoutError(caught)
+            : caught instanceof IPCEarlyCloseError
+                ? sessionEndedError()
+                : caught;
         if (error instanceof CommandError) {
             if (options.json) {
-                console.log(JSON.stringify(OutputBuilder.buildJsonError(error.message, error.metadata), null, 2));
+                console.log(JSON.stringify(OutputBuilder.buildJsonError(error.message, {
+                    ...error.metadata,
+                    exitCode: error.exitCode,
+                }), null, 2));
             }
             else {
                 console.error(genericError(error.message));
                 for (const value of Object.values(error.metadata)) {
-                    console.error(value);
+                    console.error(escapeControlChars(String(value)));
                 }
             }
             process.exit(error.exitCode);
@@ -113,8 +168,9 @@ export async function runCommand(handler, options, formatter) {
         const errorMessage = getErrorMessage(error);
         if (isDaemonConnectionError(error)) {
             if (options.json) {
-                console.log(JSON.stringify(OutputBuilder.buildJsonError('Daemon not running', {
-                    suggestion: 'Start it with: bdg <url>',
+                console.log(JSON.stringify(OutputBuilder.buildJsonError(noActiveSessionMessage(), {
+                    suggestion: startSessionSuggestion(),
+                    exitCode: EXIT_CODES.RESOURCE_NOT_FOUND,
                 }), null, 2));
             }
             else {
@@ -122,13 +178,14 @@ export async function runCommand(handler, options, formatter) {
             }
             process.exit(EXIT_CODES.RESOURCE_NOT_FOUND);
         }
+        const exitCode = getErrorExitCode(error, EXIT_CODES.UNHANDLED_EXCEPTION);
         if (options.json) {
-            console.log(JSON.stringify(OutputBuilder.buildJsonError(errorMessage), null, 2));
+            console.log(JSON.stringify(OutputBuilder.buildJsonError(errorMessage, { exitCode }), null, 2));
         }
         else {
             console.error(genericError(errorMessage));
         }
-        process.exit(EXIT_CODES.UNHANDLED_EXCEPTION);
+        process.exit(exitCode);
     }
 }
 //# sourceMappingURL=CommandRunner.js.map

package/dist/commands/shared/commonOptions.d.ts

@@ -20,4 +20,14 @@ import { Option } from 'commander';
  * ```
  */
 export declare function jsonOption(): Option;
+/**
+ * `--network` together with `--console` asks for both sections, which is what
+ * neither flag shows; clear both so the output is not empty.
+ *
+ * @param options - Parsed `peek`/`tail` options (changed in place)
+ */
+export declare function showBothSectionsWhenBothRequested(options: {
+    network?: boolean;
+    console?: boolean;
+}): void;
 //# sourceMappingURL=commonOptions.d.ts.map

package/dist/commands/shared/commonOptions.js

@@ -22,4 +22,16 @@ import { Option } from 'commander';
 export function jsonOption() {
     return new Option('-j, --json', 'Output as JSON').default(false);
 }
+/**
+ * `--network` together with `--console` asks for both sections, which is what
+ * neither flag shows; clear both so the output is not empty.
+ *
+ * @param options - Parsed `peek`/`tail` options (changed in place)
+ */
+export function showBothSectionsWhenBothRequested(options) {
+    if (options.network && options.console) {
+        options.network = false;
+        options.console = false;
+    }
+}
 //# sourceMappingURL=commonOptions.js.map

package/dist/commands/shared/daemonErrorHandler.d.ts

@@ -19,9 +19,18 @@ export interface DaemonErrorResult {
     /** Exit code to use if exiting */
     exitCode?: number;
 }
+/**
+ * Record that a follow-mode refresh reached the session, so a later loss is
+ * reported (once) and retried, not treated as "no session to follow".
+ */
+export declare function noteFollowConnected(): void;
 /**
  * Handle daemon connection errors with consistent formatting and behavior.
  *
+ * Outside follow mode the command exits. In follow mode, a session that never
+ * answered exits too (there is nothing to follow, exit 83); a session that
+ * goes away is reported once and retried until a new one starts.
+ *
  * @param error - Error message to display
  * @param options - Error handling options
  * @returns Result indicating whether to exit

package/dist/commands/shared/daemonErrorHandler.js

@@ -1,32 +1,52 @@
 /**
  * Shared utilities for handling daemon connection errors in commands.
  */
+import { sessionUnavailableSuggestion } from '../../errors/messages.js';
+import { genericError } from '../../errors/messages.js';
 import { OutputBuilder } from '../../ui/OutputBuilder.js';
-import { genericError } from '../../ui/messages/errors.js';
 import { connectionLostRetryMessage, connectionLostStopHintMessage, } from '../../ui/messages/preview.js';
 import { EXIT_CODES } from '../../utils/exitCodes.js';
+/** Follow-mode state: whether a session ever answered, and whether its loss was reported */
+const followState = { connected: false, lossReported: false };
+/**
+ * Record that a follow-mode refresh reached the session, so a later loss is
+ * reported (once) and retried, not treated as "no session to follow".
+ */
+export function noteFollowConnected() {
+    followState.connected = true;
+    followState.lossReported = false;
+}
 /**
  * Handle daemon connection errors with consistent formatting and behavior.
  *
+ * Outside follow mode the command exits. In follow mode, a session that never
+ * answered exits too (there is nothing to follow, exit 83); a session that
+ * goes away is reported once and retried until a new one starts.
+ *
  * @param error - Error message to display
  * @param options - Error handling options
  * @returns Result indicating whether to exit
  */
 export function handleDaemonConnectionError(error, options) {
     const { json = false, follow = false, retryIntervalMs = 1000, exitCode = EXIT_CODES.RESOURCE_NOT_FOUND, } = options;
-    const retryMessage = retryIntervalMs >= 1000 ? `${retryIntervalMs / 1000}s` : `${retryIntervalMs}ms`;
-    const timestamp = new Date().toISOString();
-    if (json) {
-        console.log(JSON.stringify(OutputBuilder.buildJsonError(error, { exitCode }), null, 2));
-    }
-    else {
-        console.error(genericError(error));
+    const exits = !follow || !followState.connected;
+    if (exits || !followState.lossReported) {
+        if (json) {
+            const suggestion = exits ? sessionUnavailableSuggestion(exitCode) : undefined;
+            console.log(JSON.stringify(OutputBuilder.buildJsonError(error, { exitCode, ...(suggestion && { suggestion }) }), null, 2));
+        }
+        else {
+            console.error(genericError(error));
+        }
     }
-    if (!follow) {
+    if (exits)
         return { shouldExit: true, exitCode };
+    if (!followState.lossReported) {
+        const retryMessage = retryIntervalMs >= 1000 ? `${retryIntervalMs / 1000}s` : `${retryIntervalMs}ms`;
+        console.error(connectionLostRetryMessage(new Date().toISOString(), retryMessage));
+        console.error(connectionLostStopHintMessage());
+        followState.lossReported = true;
     }
-    console.error(connectionLostRetryMessage(timestamp, retryMessage));
-    console.error(connectionLostStopHintMessage());
     return { shouldExit: false };
 }
 //# sourceMappingURL=daemonErrorHandler.js.map

package/dist/commands/shared/dataFetcher.d.ts

@@ -1,6 +1,7 @@
 /**
  * Shared data fetching utilities for commands that query daemon state.
  */
+import type { PeekSection } from '../../ipc/protocol/commands.js';
 import type { BdgOutput, ConsoleMessage, NetworkRequest } from '../../types.js';
 export type FetchSuccess<T> = {
     success: true;
@@ -10,6 +11,8 @@ export type FetchError = {
     success: false;
     error: string;
     exitCode: number;
+    /** What the user can do about it (default: start a session) */
+    suggestion?: string;
 };
 export type FetchResult<T> = FetchSuccess<T> | FetchError;
 interface PreviewData {
@@ -17,26 +20,46 @@ interface PreviewData {
     network: NetworkRequest[];
     console: ConsoleMessage[];
 }
+/** What to fetch from the daemon's preview. */
+export interface PreviewQuery {
+    /** Most recent items per section (0 = all; default: daemon default) */
+    lastN?: number;
+    /** Only network or only console items */
+    only?: PeekSection;
+    /** Include request/response headers in network items */
+    withHeaders?: boolean;
+}
 /**
  * Fetch raw preview output from daemon.
+ *
+ * @param query - Window, section and header options
+ * @returns Preview output or a fetch error
  */
-export declare function fetchPreviewOutput(lastN?: number): Promise<FetchResult<BdgOutput>>;
+export declare function fetchPreviewOutput(query?: PreviewQuery): Promise<FetchResult<BdgOutput>>;
 /**
  * Fetch preview data with parsed network and console arrays.
+ *
+ * @param query - Window, section and header options
+ * @returns Preview data or a fetch error
  */
-export declare function fetchPreviewData(lastN?: number): Promise<FetchResult<PreviewData>>;
-/**
- * Fetch network requests from daemon.
- */
-export declare function fetchNetworkRequests(): Promise<FetchResult<NetworkRequest[]>>;
+export declare function fetchPreviewData(query?: PreviewQuery): Promise<FetchResult<PreviewData>>;
 /**
- * Fetch console messages from daemon.
+ * Fetch all captured network requests from daemon.
+ *
+ * @param withHeaders - Include request/response headers (needed by header filters)
+ * @returns Requests or a fetch error
  */
-export declare function fetchConsoleMessages(): Promise<FetchResult<ConsoleMessage[]>>;
+export declare function fetchNetworkRequests(withHeaders?: boolean): Promise<FetchResult<NetworkRequest[]>>;
 /**
- * Create error result for daemon not running.
+ * Fetch all console messages from daemon.
+ *
+ * @returns Messages (with their session-wide index) and the navigation id of
+ *   the page currently loaded
  */
-export declare function createDaemonNotRunningError(): FetchError;
+export declare function fetchConsoleMessages(): Promise<FetchResult<{
+    messages: ConsoleMessage[];
+    currentNavigationId: number | undefined;
+}>>;
 interface ErrorResult {
     success: false;
     error: string;