browser-debugger-cli 0.7.1 → 0.8.0

package/dist/constants.js

@@ -11,11 +11,6 @@
  * Default Chrome debugging port
  */
 export const DEFAULT_CDP_PORT = 9222;
-/**
- * Default Chrome debugging port (string version for CLI argument parsing)
- * Derived from DEFAULT_CDP_PORT to maintain single source of truth
- */
-export const DEFAULT_DEBUG_PORT = String(DEFAULT_CDP_PORT);
 /**
  * Default Chrome launcher log level for quiet operation
  */
@@ -66,7 +61,6 @@ export const DOCKER_CHROME_FLAGS = [
     '--disable-gpu', // Disable GPU hardware acceleration
     '--disable-dev-shm-usage', // Overcome limited resource problems in Docker
     '--disable-software-rasterizer', // Don't fall back to software rendering
-    '--single-process', // Run Chrome in single-process mode (safer in containers)
 ];
 /**
  * BDG-specific Chrome preferences for automation
@@ -140,16 +134,6 @@ export const CHROME_POST_DATA_LIMIT = 1 * 1024 * 1024; // 1MB
 // ============================================================================
 // TIMEOUTS & INTERVALS
 // ============================================================================
-/**
- * Stale network request timeout (60 seconds)
- * Network requests incomplete after this duration are cleaned up
- */
-export const STALE_REQUEST_TIMEOUT = 60000;
-/**
- * Stale request cleanup interval (30 seconds)
- * How often to check for and remove stale network requests
- */
-export const STALE_REQUEST_CLEANUP_INTERVAL = 30000;
 /**
  * Default page readiness timeout (2 seconds)
  * Maximum time to wait for page to be ready before proceeding
@@ -160,15 +144,12 @@ export const DEFAULT_PAGE_READINESS_TIMEOUT_MS = 2000;
 // IPC CONFIGURATION
 // ============================================================================
 /**
- * Maximum JSONL buffer size in bytes (50MB)
- * Prevents OOM attacks from malicious/buggy processes sending data without newlines
- * If buffer exceeds this size, connection is terminated with protocol error
- *
- * Set to 50MB to accommodate large screenshots (base64-encoded full-page captures
- * of content-heavy pages like Amazon can exceed 10MB).
- * Matches CHROME_NETWORK_BUFFER_TOTAL for consistency.
+ * Maximum size of one JSONL message from the daemon (256 MB, below V8's
+ * maximum string length so joining a message cannot fail).
+ * Guards against a process sending data without newlines; large enough for
+ * HAR exports of long sessions with response bodies (`--all`).
  */
-export const MAX_JSONL_BUFFER_SIZE = 50 * 1024 * 1024; // 50MB
+export const MAX_JSONL_BUFFER_SIZE = 256 * 1024 * 1024;
 /**
  * IPC request timeout in milliseconds (45 seconds in production, 5 seconds in tests)
  * Maximum time to wait for IPC responses from daemon
@@ -184,6 +165,17 @@ export function getIPCRequestTimeout() {
         ? parseInt(process.env['BDG_IPC_TIMEOUT_MS'], 10)
         : 45000;
 }
+/**
+ * Timeout for small requests the daemon answers from memory (status, peek,
+ * details, headers): a daemon that does not answer these within seconds is
+ * not responding, so commands do not wait the full IPC timeout. HAR data is
+ * excluded: a large session's requests and bodies take longer to transfer.
+ *
+ * @returns Timeout in milliseconds (10 s, or the IPC timeout if shorter)
+ */
+export function getQuickIPCRequestTimeout() {
+    return Math.min(10000, getIPCRequestTimeout());
+}
 // ============================================================================
 // CLI OPTION DESCRIPTIONS
 // ============================================================================
@@ -210,12 +202,23 @@ export const RESOURCE_TYPE_ABBREVIATIONS = {
     WebSocket: 'WS',
     Manifest: 'MAN',
     SignedExchange: 'SGX',
-    Ping: 'PNG',
+    Ping: 'PIN',
     CSPViolationReport: 'CSP',
     Preflight: 'FLT',
     FedCM: 'FED',
     Other: 'OTH',
 };
+/**
+ * The CDP resource type a user means: its name or its abbreviation from
+ * `network list` (`WS`, `DOC`, `FET`), in any case.
+ *
+ * @param name - Type as typed
+ * @returns CDP resource type, or undefined if unknown
+ */
+export function resourceTypeFromName(name) {
+    const wanted = name.trim().toLowerCase();
+    return Object.entries(RESOURCE_TYPE_ABBREVIATIONS).find(([type, abbreviation]) => type.toLowerCase() === wanted || abbreviation.toLowerCase() === wanted)?.[0];
+}
 /**
  * Rules for inferring resource types from MIME patterns.
  * Ordered by precedence (first match wins).

package/dist/daemon/SessionController.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Daemon request handling for the single in-process session.
+ *
+ * Maps each client IPC request to a response object. Holds the current
+ * {@link Session} and asks the daemon to shut down when the session ends,
+ * since the daemon's lifetime is the session's lifetime.
+ */
+import { type SessionEndReason } from './session/Session.js';
+import { type ClientRequestUnion, type HandshakeRequest, type HandshakeResponse, type HARDataRequest, type HARDataResponse, type PeekRequest, type PeekResponse, type StartSessionRequest, type StartSessionResponse, type StatusRequest, type StatusResponse, type StopSessionRequest, type StopSessionResponse } from '../ipc/index.js';
+/**
+ * Owns the daemon's session and answers client requests.
+ */
+export declare class SessionController {
+    private readonly daemonStartTime;
+    private readonly socketPath;
+    private readonly onSessionEnded;
+    private session;
+    private launching;
+    private closing;
+    /**
+     * @param daemonStartTime - Daemon start timestamp (ms)
+     * @param socketPath - Daemon socket path, reported in status
+     * @param onSessionEnded - Called once the session has ended or failed to start
+     */
+    constructor(daemonStartTime: number, socketPath: string, onSessionEnded: (reason: SessionEndReason) => void);
+    /**
+     * Whether no session is running or starting.
+     *
+     * @returns True if the daemon hosts nothing
+     */
+    isIdle(): boolean;
+    /**
+     * Reject any further start requests (the daemon is shutting down).
+     */
+    refuseNewSessions(): void;
+    /**
+     * Stop the session if one is running or launching (used on daemon shutdown).
+     *
+     * @returns True if a session was stopped
+     */
+    stopActiveSession(): Promise<boolean>;
+    /**
+     * Error fields for a request that needs the session when there is none:
+     * still starting (85), or none at all.
+     *
+     * @returns Error message, plus exit code and suggestion while starting
+     */
+    private noSessionError;
+    /**
+     * Respond to a handshake.
+     *
+     * @param request - Handshake request
+     * @returns Handshake response
+     */
+    handshake(request: HandshakeRequest): HandshakeResponse;
+    /**
+     * Report daemon status, enriched with live session activity when available.
+     *
+     * @param request - Status request
+     * @returns Status response
+     */
+    status(request: StatusRequest): Promise<StatusResponse>;
+    /**
+     * Return a preview of recent telemetry.
+     *
+     * @param request - Peek request
+     * @returns Peek response
+     */
+    peek(request: PeekRequest): Promise<PeekResponse>;
+    /**
+     * Return all captured network requests for HAR export.
+     *
+     * @param request - HAR data request
+     * @returns HAR data response
+     */
+    harData(request: HARDataRequest): Promise<HARDataResponse>;
+    /**
+     * Execute a session command (dom_*, cdp_call, session_details, ...).
+     *
+     * @param request - Command request
+     * @returns Command response, forwarding exit code and suggestion on failure
+     */
+    command(request: ClientRequestUnion): Promise<unknown>;
+    /**
+     * Start a session, or report the one already running.
+     *
+     * A start whose client disconnects (Ctrl-C) is abandoned: the session is
+     * stopped, whether it is still launching or has just started, since nobody
+     * learns that it exists.
+     *
+     * @param request - Start session request
+     * @param abandoned - Aborted when the requesting client disconnects
+     * @returns Start session response
+     */
+    startSession(request: StartSessionRequest, abandoned?: AbortSignal): Promise<StartSessionResponse>;
+    /**
+     * Create and launch a session, mapping the outcome to response fields.
+     *
+     * @param request - Start session request
+     * @param onCreated - Receives the session before launch, so it can be stopped mid-launch
+     * @returns Status plus data or error fields for the start response
+     */
+    private launchSession;
+    /**
+     * Stop the running session, or abort one that is still launching.
+     *
+     * @param request - Stop session request
+     * @returns Stop session response
+     */
+    stopSession(request: StopSessionRequest): Promise<StopSessionResponse>;
+    /**
+     * React to the session ending (stop, crash, or timeout).
+     *
+     * @param reason - Why the session ended
+     */
+    private handleSessionEnded;
+    /**
+     * Build the error part of a start response when a session already exists.
+     *
+     * @param request - Start session request
+     * @returns Error message, code and existing-session details
+     */
+    private describeExistingSession;
+}
+//# sourceMappingURL=SessionController.d.ts.map

package/dist/daemon/SessionController.js

@@ -0,0 +1,472 @@
+/**
+ * Daemon request handling for the single in-process session.
+ *
+ * Maps each client IPC request to a response object. Holds the current
+ * {@link Session} and asks the daemon to shut down when the session ends,
+ * since the daemon's lifetime is the session's lifetime.
+ */
+import { CDPConnectionError, CDPProtocolError, ChromeLaunchError, ConnectionError, } from '../connection/errors.js';
+import { Session, StartCancelledError } from './session/Session.js';
+import { detectTargetMismatch } from './session/targetMismatch.js';
+import { CommandError } from '../errors/index.js';
+import { LAUNCHED_CHROME_DESCRIPTION, cdpRequestRejectedError, sessionEndedDuringCommandError, } from '../errors/messages.js';
+import { IPCErrorCode, } from '../ipc/index.js';
+import { clearLastSessionEnd, writeLastSessionEnd } from '../session/lastSession.js';
+import { createLogger } from '../ui/logging/index.js';
+import { formatChromeIssue } from '../ui/messages/chrome.js';
+import { getErrorMessage } from '../utils/errors.js';
+import { EXIT_CODES } from '../utils/exitCodes.js';
+import { filterDefined } from '../utils/objects.js';
+const log = createLogger('daemon');
+const NO_SESSION_ERROR = 'No active session';
+/** Error for requests that need the session while `bdg <url>` is still starting it */
+const STARTING_ERROR = 'The session is still starting';
+const COMMAND_TIMEOUT_MS = 30000;
+const QUERY_TIMEOUT_MS = 5000;
+/**
+ * Run a promise with a timeout, clearing the timer either way.
+ *
+ * @param promise - Work to wait for
+ * @param timeoutMs - Timeout in milliseconds
+ * @param label - Operation name for the timeout message
+ * @returns The promise's result
+ * @throws Error when the timeout elapses first
+ */
+async function withTimeout(promise, timeoutMs, label) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timeout (${timeoutMs / 1000}s)`)), timeoutMs);
+    });
+    try {
+        return await Promise.race([promise, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Describe a session start failure for the client.
+ *
+ * @param error - Error thrown while starting
+ * @returns Human-readable message
+ */
+function describeStartError(error) {
+    if (error instanceof ConnectionError && error.issue) {
+        return formatChromeIssue(error.issue);
+    }
+    if (error instanceof CommandError) {
+        const suggestion = error.metadata['suggestion'];
+        return typeof suggestion === 'string' ? `${error.message}\n${suggestion}` : error.message;
+    }
+    return getErrorMessage(error);
+}
+/**
+ * Error fields of a failed launch: cancelled by a stop, a start URL that could
+ * not be loaded, or a launch failure.
+ *
+ * @param error - Error the launch failed with
+ * @returns Message, IPC error code, and the exit code of a user-facing error
+ */
+function describeLaunchFailure(error) {
+    if (error instanceof StartCancelledError) {
+        return { message: error.message, errorCode: IPCErrorCode.SESSION_START_CANCELLED };
+    }
+    const navigationFailed = error instanceof CommandError && error.exitCode === EXIT_CODES.INVALID_URL;
+    return {
+        message: describeStartError(error),
+        errorCode: navigationFailed
+            ? IPCErrorCode.NAVIGATION_FAILED
+            : IPCErrorCode.SESSION_START_FAILED,
+        ...(error instanceof CommandError && !navigationFailed && { exitCode: error.exitCode }),
+        ...(error instanceof ChromeLaunchError && { exitCode: EXIT_CODES.CHROME_LAUNCH_FAILURE }),
+    };
+}
+/**
+ * Owns the daemon's session and answers client requests.
+ */
+export class SessionController {
+    daemonStartTime;
+    socketPath;
+    onSessionEnded;
+    session = null;
+    launching = null;
+    closing = false;
+    /**
+     * @param daemonStartTime - Daemon start timestamp (ms)
+     * @param socketPath - Daemon socket path, reported in status
+     * @param onSessionEnded - Called once the session has ended or failed to start
+     */
+    constructor(daemonStartTime, socketPath, onSessionEnded) {
+        this.daemonStartTime = daemonStartTime;
+        this.socketPath = socketPath;
+        this.onSessionEnded = onSessionEnded;
+    }
+    /**
+     * Whether no session is running or starting.
+     *
+     * @returns True if the daemon hosts nothing
+     */
+    isIdle() {
+        return !this.session && !this.launching;
+    }
+    /**
+     * Reject any further start requests (the daemon is shutting down).
+     */
+    refuseNewSessions() {
+        this.closing = true;
+    }
+    /**
+     * Stop the session if one is running or launching (used on daemon shutdown).
+     *
+     * @returns True if a session was stopped
+     */
+    async stopActiveSession() {
+        this.closing = true;
+        const launching = this.launching;
+        const session = this.session ?? launching?.session;
+        if (!session && !launching)
+            return false;
+        await session?.stop('normal');
+        await launching?.done;
+        await this.session?.stop('normal');
+        return true;
+    }
+    /**
+     * Error fields for a request that needs the session when there is none:
+     * still starting (85), or none at all.
+     *
+     * @returns Error message, plus exit code and suggestion while starting
+     */
+    noSessionError() {
+        if (!this.launching)
+            return { error: NO_SESSION_ERROR };
+        return {
+            error: STARTING_ERROR,
+            exitCode: EXIT_CODES.RESOURCE_BUSY,
+            suggestion: 'Wait until "bdg <url>" returns, then retry',
+        };
+    }
+    /**
+     * Respond to a handshake.
+     *
+     * @param request - Handshake request
+     * @returns Handshake response
+     */
+    handshake(request) {
+        return {
+            type: 'handshake_response',
+            sessionId: request.sessionId,
+            status: 'ok',
+            message: 'Handshake successful',
+        };
+    }
+    /**
+     * Report daemon status, enriched with live session activity when available.
+     *
+     * @param request - Status request
+     * @returns Status response
+     */
+    async status(request) {
+        const data = {
+            daemonPid: process.pid,
+            daemonStartTime: this.daemonStartTime,
+            socketPath: this.socketPath,
+        };
+        const base = { type: 'status_response', sessionId: request.sessionId };
+        if (!this.session || this.session.stopRequested()) {
+            if (this.launching) {
+                data.starting = { url: this.launching.url, since: this.launching.since };
+            }
+            if (this.session || this.closing)
+                data.ending = true;
+            return { ...base, status: 'ok', data };
+        }
+        data.sessionPid = process.pid;
+        data.sessionMetadata = this.session.metadata();
+        try {
+            const live = await withTimeout(this.session.execute('session_status', {}), QUERY_TIMEOUT_MS, 'Status');
+            Object.assign(data, {
+                activity: live.activity,
+                pageState: live.target,
+                navigationId: live.navigationId,
+            });
+            return { ...base, status: 'ok', data };
+        }
+        catch (error) {
+            return { ...base, status: 'error', data, error: getErrorMessage(error) };
+        }
+    }
+    /**
+     * Return a preview of recent telemetry.
+     *
+     * @param request - Peek request
+     * @returns Peek response
+     */
+    async peek(request) {
+        const base = { type: 'peek_response', sessionId: request.sessionId };
+        if (!this.session) {
+            return { ...base, status: 'error', ...this.noSessionError() };
+        }
+        try {
+            const data = await withTimeout(this.session.execute('session_peek', {
+                lastN: request.lastN ?? 10,
+                ...(request.only && { only: request.only }),
+                ...(request.withHeaders && { withHeaders: true }),
+            }), QUERY_TIMEOUT_MS, 'Peek');
+            return {
+                ...base,
+                status: 'ok',
+                data: {
+                    sessionPid: process.pid,
+                    preview: {
+                        version: data.version,
+                        success: true,
+                        timestamp: new Date(data.startTime).toISOString(),
+                        duration: data.duration,
+                        target: data.target,
+                        data: { network: data.network, console: data.console },
+                        totals: { network: data.totalNetwork, console: data.totalConsole },
+                        currentNavigationId: data.currentNavigationId,
+                        partial: true,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            return { ...base, status: 'error', error: getErrorMessage(error) };
+        }
+    }
+    /**
+     * Return all captured network requests for HAR export.
+     *
+     * @param request - HAR data request
+     * @returns HAR data response
+     */
+    async harData(request) {
+        const base = { type: 'har_data_response', sessionId: request.sessionId };
+        if (!this.session) {
+            return { ...base, status: 'error', ...this.noSessionError() };
+        }
+        try {
+            const data = await withTimeout(this.session.execute('session_har_data', {}), QUERY_TIMEOUT_MS, 'HAR data');
+            return { ...base, status: 'ok', data: { sessionPid: process.pid, requests: data.requests } };
+        }
+        catch (error) {
+            return { ...base, status: 'error', error: getErrorMessage(error) };
+        }
+    }
+    /**
+     * Execute a session command (dom_*, cdp_call, session_details, ...).
+     *
+     * @param request - Command request
+     * @returns Command response, forwarding exit code and suggestion on failure
+     */
+    async command(request) {
+        const name = request.type.slice(0, -'_request'.length);
+        const base = { type: `${name}_response`, sessionId: request.sessionId };
+        if (!this.session) {
+            return { ...base, status: 'error', ...this.noSessionError() };
+        }
+        const { sessionId: _sessionId, type: _type, ...params } = request;
+        try {
+            const execute = this.session.execute.bind(this.session);
+            const data = await withTimeout(execute(name, params), COMMAND_TIMEOUT_MS, 'Command');
+            return { ...base, status: 'ok', data };
+        }
+        catch (error) {
+            return { ...base, status: 'error', ...describeCommandError(error) };
+        }
+    }
+    /**
+     * Start a session, or report the one already running.
+     *
+     * A start whose client disconnects (Ctrl-C) is abandoned: the session is
+     * stopped, whether it is still launching or has just started, since nobody
+     * learns that it exists.
+     *
+     * @param request - Start session request
+     * @param abandoned - Aborted when the requesting client disconnects
+     * @returns Start session response
+     */
+    async startSession(request, abandoned) {
+        const base = { type: 'start_session_response', sessionId: request.sessionId };
+        if (this.session || this.launching || this.closing) {
+            return { ...base, status: 'error', ...this.describeExistingSession(request) };
+        }
+        const launching = {
+            session: null,
+            done: Promise.resolve(),
+            url: request.url,
+            since: Date.now(),
+        };
+        clearLastSessionEnd();
+        const run = this.launchSession(request, (session) => {
+            launching.session = session;
+        });
+        launching.done = run;
+        this.launching = launching;
+        const stopAbandoned = () => {
+            log.info('Client disconnected during start; stopping the session');
+            void launching.session?.stop('normal');
+        };
+        abandoned?.addEventListener('abort', stopAbandoned, { once: true });
+        try {
+            const result = await run;
+            if (abandoned?.aborted)
+                await launching.session?.stop('normal');
+            return { ...base, ...result };
+        }
+        finally {
+            abandoned?.removeEventListener('abort', stopAbandoned);
+            this.launching = null;
+        }
+    }
+    /**
+     * Create and launch a session, mapping the outcome to response fields.
+     *
+     * @param request - Start session request
+     * @param onCreated - Receives the session before launch, so it can be stopped mid-launch
+     * @returns Status plus data or error fields for the start response
+     */
+    async launchSession(request, onCreated) {
+        const { type: _type, sessionId: _sessionId, url, ...options } = request;
+        try {
+            const session = Session.create(url, filterDefined(options), (reason) => this.handleSessionEnded(reason));
+            onCreated(session);
+            if (this.closing) {
+                throw new Error('Daemon is shutting down');
+            }
+            await session.launch();
+            this.session = session;
+            const info = session.info();
+            log.info(`Session started (Chrome PID ${info.chromePid}, port ${info.port})`);
+            return {
+                status: 'ok',
+                message: 'Session started successfully',
+                data: { daemonPid: process.pid, ...info },
+            };
+        }
+        catch (error) {
+            log.info(`Session start failed: ${getErrorMessage(error)}`);
+            this.closing = true;
+            setImmediate(() => this.onSessionEnded('crash'));
+            return { status: 'error', ...describeLaunchFailure(error) };
+        }
+    }
+    /**
+     * Stop the running session, or abort one that is still launching.
+     *
+     * @param request - Stop session request
+     * @returns Stop session response
+     */
+    async stopSession(request) {
+        const base = { type: 'stop_session_response', sessionId: request.sessionId };
+        const launching = this.session ? null : this.launching;
+        const session = this.session ?? launching?.session;
+        if (!session) {
+            return {
+                ...base,
+                status: 'error',
+                message: 'No active session found',
+                errorCode: IPCErrorCode.NO_SESSION,
+            };
+        }
+        const { chromePid } = session.info();
+        await session.stop('normal');
+        await launching?.done;
+        return {
+            ...base,
+            status: 'ok',
+            message: 'Session stopped successfully',
+            ...(chromePid > 0 && { chromePid }),
+        };
+    }
+    /**
+     * React to the session ending (stop, crash, or timeout).
+     *
+     * @param reason - Why the session ended
+     */
+    handleSessionEnded(reason) {
+        log.info(`Session ended (reason: ${reason})`);
+        if (reason !== 'normal')
+            writeLastSessionEnd(reason);
+        this.session = null;
+        this.closing = true;
+        this.onSessionEnded(reason);
+    }
+    /**
+     * Build the error part of a start response when a session already exists.
+     *
+     * @param request - Start session request
+     * @returns Error message, code and existing-session details
+     */
+    describeExistingSession(request) {
+        const shuttingDown = this.closing || Boolean(this.session?.stopRequested());
+        if (!this.session || shuttingDown) {
+            return shuttingDown
+                ? {
+                    message: 'The previous session is still shutting down. Try again in a moment.',
+                    errorCode: IPCErrorCode.SESSION_SHUTTING_DOWN,
+                }
+                : {
+                    message: 'Session startup already in progress. Wait a moment and try again.',
+                    errorCode: IPCErrorCode.SESSION_ALREADY_RUNNING,
+                };
+        }
+        const metadata = this.session.metadata();
+        const { targetUrl } = this.session.info();
+        const existingSession = {
+            pid: process.pid,
+            startTime: metadata.startTime,
+            duration: Math.floor((Date.now() - metadata.startTime) / 1000),
+        };
+        const mismatch = detectTargetMismatch(request, metadata);
+        if (mismatch) {
+            const current = mismatch.current === LAUNCHED_CHROME_DESCRIPTION ? undefined : mismatch.current;
+            return {
+                message: `Active session is attached to ${mismatch.current}, not ${mismatch.requested}`,
+                errorCode: IPCErrorCode.SESSION_TARGET_MISMATCH,
+                existingSession: { ...existingSession, ...(current && { targetUrl: current }) },
+            };
+        }
+        return {
+            message: `Session already running (PID ${process.pid}). Stop it first with: bdg stop`,
+            errorCode: IPCErrorCode.SESSION_ALREADY_RUNNING,
+            existingSession: { ...existingSession, targetUrl },
+        };
+    }
+}
+/**
+ * Convert a command failure into response fields.
+ *
+ * @param error - Error thrown by the command handler
+ * @returns Error message plus exit code and suggestion when known
+ */
+function describeCommandError(error) {
+    if (error instanceof CDPProtocolError && error.isRequestError()) {
+        const err = cdpRequestRejectedError(error.message);
+        return {
+            error: err.message,
+            exitCode: EXIT_CODES.INVALID_ARGUMENTS,
+            suggestion: err.suggestion,
+        };
+    }
+    if (error instanceof CDPConnectionError) {
+        const err = sessionEndedDuringCommandError();
+        return {
+            error: err.message,
+            exitCode: EXIT_CODES.RESOURCE_NOT_FOUND,
+            suggestion: err.suggestion,
+        };
+    }
+    if (!(error instanceof CommandError)) {
+        return { error: getErrorMessage(error) };
+    }
+    const suggestion = error.metadata['suggestion'];
+    return {
+        error: error.message,
+        exitCode: error.exitCode,
+        ...(typeof suggestion === 'string' && { suggestion }),
+    };
+}
+//# sourceMappingURL=SessionController.js.map