browser-debugger-cli 0.8.0 → 0.9.0

package/dist/ui/formatters/sessions.js

@@ -0,0 +1,40 @@
+import { OutputFormatter } from '../formatting.js';
+/** Label of the default session in the list */
+const DEFAULT_SESSION_LABEL = '(default)';
+/**
+ * Format the sessions as a table, followed by the cleanup commands of
+ * crashed and stale sessions.
+ *
+ * @param data - Sessions
+ * @returns Human-readable list
+ */
+export function formatSessionList(data) {
+    const fmt = new OutputFormatter();
+    if (data.sessions.length === 0) {
+        return fmt
+            .text('No running sessions')
+            .hints('Suggestions:', ['Start one:  bdg <url> [--session <name>]'])
+            .build();
+    }
+    const rows = data.sessions.map((session) => [
+        session.name ?? DEFAULT_SESSION_LABEL,
+        session.state,
+        session.port?.toString() ?? '-',
+        session.daemonPid?.toString() ?? '-',
+        session.url ?? '-',
+    ]);
+    const header = ['SESSION', 'STATE', 'PORT', 'PID', 'URL'];
+    const widths = header.map((title, column) => Math.max(title.length, ...rows.map((row) => row[column]?.length ?? 0)));
+    for (const row of [header, ...rows]) {
+        fmt.text(row
+            .map((cell, column) => cell.padEnd(widths[column] ?? 0))
+            .join('  ')
+            .trimEnd());
+    }
+    const cleanups = data.sessions.flatMap((session) => (session.cleanup ? [session.cleanup] : []));
+    if (cleanups.length > 0) {
+        fmt.hints('Crashed or stale sessions; clean up with:', cleanups);
+    }
+    return fmt.build();
+}
+//# sourceMappingURL=sessions.js.map

package/dist/ui/formatters/status.d.ts

@@ -2,10 +2,14 @@ import type { SessionActivity, PageState } from '../../ipc/index.js';
 import { type RunningChromeInfo } from '../../session/chrome.js';
 import type { LastSessionEnd } from '../../session/lastSession.js';
 import type { SessionMetadata } from '../../session/metadata.js';
+import type { ColorScheme, ViewportSize } from '../../types.js';
 export interface StatusData {
+    /** Name of the selected session (named sessions only) */
+    session?: string;
     active: boolean;
     bdgPid?: number;
-    chromePid?: number | undefined;
+    /** Chrome launched by bdg; null for an attached Chrome */
+    chromePid?: number | null | undefined;
     chromeAlive?: boolean;
     /** Attached to a Chrome bdg did not launch (`--chrome-ws-url`); it has no known PID */
     externalChrome?: boolean;
@@ -18,6 +22,10 @@ export interface StatusData {
     telemetry?: string[];
     /** When `--timeout` stops the session (ISO time) */
     autoStopAt?: string;
+    /** Viewport given with `--viewport` (`pageState.viewport` is the current one) */
+    viewport?: ViewportSize;
+    /** Color scheme given with `--color-scheme` (`pageState.colorScheme` is the current one) */
+    colorScheme?: ColorScheme;
     stale?: boolean;
     stalePid?: number;
     warning?: string;
@@ -44,8 +52,19 @@ export interface StatusData {
  * @param activity - Live activity metrics from the session
  * @param pageState - Current page state from the session
  * @param verbose - Also show the session's Chrome executable, mode and profile
+ * @param sessionName - Name of a named session
  */
-export declare function formatSessionStatus(metadata: SessionMetadata, pid: number, activity?: SessionActivity, pageState?: PageState, verbose?: boolean): string;
+export declare function formatSessionStatus(metadata: SessionMetadata, pid: number, activity?: SessionActivity, pageState?: PageState, verbose?: boolean, sessionName?: string): string;
+/**
+ * Viewport and color scheme lines of the target: what the page renders with,
+ * and whether `--viewport` / `--color-scheme` set it or it is the system's.
+ * The color scheme is the `prefers-color-scheme` the page sees, not its theme.
+ *
+ * @param metadata - Session metadata (the start options)
+ * @param pageState - Page state (what the page reported)
+ * @returns Key-value pairs (none for what is unknown)
+ */
+export declare function appearanceLines(metadata: Pick<SessionMetadata, 'viewport' | 'colorScheme'>, pageState: PageState): Array<[string, string]>;
 /**
  * Convert status data to JSON format
  */

package/dist/ui/formatters/status.js

@@ -1,7 +1,9 @@
 import { describeRunningChrome } from '../../session/chrome.js';
 import { calculateDuration, formatTimeAgo } from '../../session/statusData.js';
 import { OutputFormatter } from '../formatting.js';
+import { colorSchemeLabel, sessionActiveLine } from '../messages/commands.js';
 import { lastSessionEndText } from '../messages/session.js';
+import { noActiveSessionMessage, sessionCommand } from '../messages/sessionCommand.js';
 import { isProcessAlive } from '../../utils/process.js';
 /**
  * Format session status for human-readable output
@@ -10,13 +12,16 @@ import { isProcessAlive } from '../../utils/process.js';
  * @param activity - Live activity metrics from the session
  * @param pageState - Current page state from the session
  * @param verbose - Also show the session's Chrome executable, mode and profile
+ * @param sessionName - Name of a named session
  */
-export function formatSessionStatus(metadata, pid, activity, pageState, verbose = false) {
+export function formatSessionStatus(metadata, pid, activity, pageState, verbose = false, sessionName) {
     const duration = calculateDuration(metadata.startTime);
     const chromeAlive = metadata.chromePid ? isProcessAlive(metadata.chromePid) : false;
     const fmt = new OutputFormatter();
+    fmt.text(sessionActiveLine(pageState)).blank();
     fmt.text('Session Status').separator('━', 50);
     fmt.keyValueList([
+        ...(sessionName ? [['Session', sessionName]] : []),
         ['Status', 'ACTIVE'],
         ['Duration', duration.formatted],
         ...(metadata.autoStopAt
@@ -38,6 +43,7 @@ export function formatSessionStatus(metadata, pid, activity, pageState, verbose
         if (pageState.title) {
             fmt.keyValue('Title', pageState.title, 18);
         }
+        fmt.keyValueList(appearanceLines(metadata, pageState), 18);
     }
     if (activity) {
         fmt.blank().text('Activity').separator('━', 50);
@@ -69,12 +75,40 @@ export function formatSessionStatus(metadata, pid, activity, pageState, verbose
     fmt
         .blank()
         .section('Commands:', [
-        'Peek data:       bdg peek',
-        'Run JavaScript:  bdg dom eval <script>',
-        'End session:     bdg stop',
+        `Peek data:       ${sessionCommand('bdg peek', sessionName ?? null)}`,
+        `Run JavaScript:  ${sessionCommand('bdg dom eval <script>', sessionName ?? null)}`,
+        `End session:     ${sessionCommand('bdg stop', sessionName ?? null)}`,
     ]);
     return fmt.build();
 }
+/**
+ * Viewport and color scheme lines of the target: what the page renders with,
+ * and whether `--viewport` / `--color-scheme` set it or it is the system's.
+ * The color scheme is the `prefers-color-scheme` the page sees, not its theme.
+ *
+ * @param metadata - Session metadata (the start options)
+ * @param pageState - Page state (what the page reported)
+ * @returns Key-value pairs (none for what is unknown)
+ */
+export function appearanceLines(metadata, pageState) {
+    const viewport = pageState.viewport ?? metadata.viewport;
+    const scheme = pageState.colorScheme ?? metadata.colorScheme;
+    return [
+        ...(viewport
+            ? [
+                [
+                    'Viewport',
+                    `${viewport.width}×${viewport.height}${metadata.viewport ? ` (--viewport ${metadata.viewport.width}x${metadata.viewport.height})` : ''}`,
+                ],
+            ]
+            : []),
+        ...(scheme
+            ? [
+                ['Color scheme', colorSchemeLabel(scheme, metadata.colorScheme !== undefined)],
+            ]
+            : []),
+    ];
+}
 /**
  * Convert status data to JSON format
  */
@@ -98,13 +132,15 @@ export function formatStatusAsJson(metadata, pid) {
     return {
         active: true,
         bdgPid: pid,
-        chromePid: metadata.chromePid,
+        chromePid: metadata.chromePid !== undefined && metadata.chromePid > 0 ? metadata.chromePid : null,
         ...(metadata.chromePid ? { chromeAlive } : { externalChrome: true }),
         startTime: metadata.startTime,
         duration: duration.durationMs,
         durationFormatted: duration.formatted,
         port: metadata.port,
         ...(metadata.autoStopAt && { autoStopAt: new Date(metadata.autoStopAt).toISOString() }),
+        ...(metadata.viewport && { viewport: metadata.viewport }),
+        ...(metadata.colorScheme && { colorScheme: metadata.colorScheme }),
         targetId: metadata.targetId,
         webSocketDebuggerUrl: metadata.webSocketDebuggerUrl,
         telemetry: metadata.activeTelemetry ?? ['network', 'console', 'dom'],
@@ -120,13 +156,14 @@ export function formatNoSessionMessage(data = { active: false }) {
         return fmt
             .text(`Session starting: ${data.starting.url} (${seconds}s so far)`)
             .blank()
-            .text('Commands work once "bdg <url>" returns.')
+            .text(`Commands work once "${sessionCommand('bdg <url>', data.session ?? null)}" returns.`)
             .build();
     }
     if (data.ending) {
         return fmt.text('The session is ending (its Chrome is being closed)').build();
     }
-    fmt.text('No active session found');
+    const session = data.session ?? null;
+    fmt.text(noActiveSessionMessage(session));
     if (data.lastSession)
         fmt.text(lastSessionEndText(data.lastSession));
     if (data.orphanedChromePid) {
@@ -134,10 +171,10 @@ export function formatNoSessionMessage(data = { active: false }) {
     }
     return fmt
         .hints('Suggestions:', [
-        'Start a new session:     bdg <url>',
+        `Start a new session:     ${sessionCommand('bdg <url>', session)}`,
         data.orphanedChromePid
-            ? 'Close that Chrome:       bdg cleanup'
-            : 'Clean up after a crash:  bdg cleanup',
+            ? `Close that Chrome:       ${sessionCommand('bdg cleanup', session)}`
+            : `Clean up after a crash:  ${sessionCommand('bdg cleanup', session)}`,
     ])
         .build();
 }

package/dist/ui/formatters/triggeredRequests.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Human output of the network requests a DOM action triggered.
+ */
+import type { TriggeredRequest } from '../../ipc/protocol/domTypes.js';
+/** Requests listed in human output (JSON lists up to 50) */
+export declare const MAX_TRIGGERED_REQUESTS_SHOWN = 10;
+/**
+ * Title of the list, with how many requests there were in all (the listed
+ * rows, the "... and N more" note and the assets line add up to it).
+ *
+ * @param requests - Triggered requests in the result
+ * @param omitted - Requests the result left out
+ * @returns e.g. "Requests during the action (18):"
+ */
+export declare function formatTriggeredRequestsTitle(requests: TriggeredRequest[], omitted?: number): string;
+/**
+ * One request as a line, e.g. `POST 127.0.0.1:8080/api/save → 200 (85ms)`,
+ * or `GET 127.0.0.1:8080/events → 200 (loading)` while its body still loads.
+ *
+ * @param request - Triggered request
+ * @returns Line text
+ */
+export declare function formatTriggeredRequest(request: TriggeredRequest): string;
+/**
+ * Lines listing the triggered requests: the first
+ * {@link MAX_TRIGGERED_REQUESTS_SHOWN} notable ones (documents, XHR, fetch,
+ * WebSocket, failures; see {@link isNotableRequest}), how many more there
+ * are and where to find them (JSON, or the network list when JSON left some
+ * out too), then one line counting the static assets that loaded.
+ *
+ * @param requests - Triggered requests, in start order
+ * @param omitted - Requests the result already left out
+ * @returns Lines (empty when there are none)
+ */
+export declare function formatTriggeredRequestLines(requests: TriggeredRequest[], omitted?: number): string[];
+//# sourceMappingURL=triggeredRequests.d.ts.map

package/dist/ui/formatters/triggeredRequests.js

@@ -0,0 +1,65 @@
+/**
+ * Human output of the network requests a DOM action triggered.
+ */
+import { assetTypeNames, isNotableRequest } from '../../telemetry/requestKinds.js';
+import { formatRequestStatus } from './requestStatus.js';
+import { formatDuration, truncateUrl } from '../formatting.js';
+import { assetRequestsNote, moreMatchesNote, moreRequestsNote, triggeredRequestsTitle, } from '../messages/commands.js';
+/** Requests listed in human output (JSON lists up to 50) */
+export const MAX_TRIGGERED_REQUESTS_SHOWN = 10;
+/** Longest URL shown before it is shortened */
+const URL_MAX_LENGTH = 60;
+/**
+ * Title of the list, with how many requests there were in all (the listed
+ * rows, the "... and N more" note and the assets line add up to it).
+ *
+ * @param requests - Triggered requests in the result
+ * @param omitted - Requests the result left out
+ * @returns e.g. "Requests during the action (18):"
+ */
+export function formatTriggeredRequestsTitle(requests, omitted = 0) {
+    return triggeredRequestsTitle(requests.length + omitted);
+}
+/**
+ * One request as a line, e.g. `POST 127.0.0.1:8080/api/save → 200 (85ms)`,
+ * or `GET 127.0.0.1:8080/events → 200 (loading)` while its body still loads.
+ *
+ * @param request - Triggered request
+ * @returns Line text
+ */
+export function formatTriggeredRequest(request) {
+    const httpStatus = request.failed ? 0 : request.status;
+    const status = formatRequestStatus({
+        ...(httpStatus !== undefined && { status: httpStatus }),
+        ...(request.errorText !== undefined && { errorText: request.errorText }),
+    });
+    const duration = request.loading
+        ? ' (loading)'
+        : request.durationMs === undefined
+            ? ''
+            : ` (${formatDuration(request.durationMs)})`;
+    return `${request.method} ${truncateUrl(request.url, URL_MAX_LENGTH)} → ${status}${duration}`;
+}
+/**
+ * Lines listing the triggered requests: the first
+ * {@link MAX_TRIGGERED_REQUESTS_SHOWN} notable ones (documents, XHR, fetch,
+ * WebSocket, failures; see {@link isNotableRequest}), how many more there
+ * are and where to find them (JSON, or the network list when JSON left some
+ * out too), then one line counting the static assets that loaded.
+ *
+ * @param requests - Triggered requests, in start order
+ * @param omitted - Requests the result already left out
+ * @returns Lines (empty when there are none)
+ */
+export function formatTriggeredRequestLines(requests, omitted = 0) {
+    const notable = requests.filter(isNotableRequest);
+    const assets = requests.filter((request) => !isNotableRequest(request));
+    const lines = notable.slice(0, MAX_TRIGGERED_REQUESTS_SHOWN).map(formatTriggeredRequest);
+    const hidden = notable.length - lines.length + omitted;
+    if (hidden > 0)
+        lines.push(omitted > 0 ? moreRequestsNote(hidden) : moreMatchesNote(hidden));
+    if (assets.length > 0)
+        lines.push(assetRequestsNote(assets.length, assetTypeNames(assets)));
+    return lines;
+}
+//# sourceMappingURL=triggeredRequests.js.map

package/dist/ui/formatting.d.ts

@@ -61,6 +61,16 @@ export declare function escapeControlChars(text: string): string;
 export declare function joinLines(...lines: Array<string | null | undefined | false>): string;
 export declare function section(title: string, content: string[], indent?: number): string;
 export declare function truncateText(text: string, maxLines?: number): string;
+/**
+ * A URL for one line: host and path without the scheme (`www.example.com`
+ * for the root), cut in the middle when too long, keeping the host, the
+ * start of the path and the end of the path and query, where requests to
+ * one API differ (`api.example.com/v1/users/…/orders?page=2`).
+ *
+ * @param url - URL
+ * @param maxLength - Maximum length
+ * @returns Shortened URL; non-web URLs (data:, blob:) cut at the end
+ */
 export declare function truncateUrl(url: string, maxLength?: number): string;
 export declare function pluralize(count: number, singular: string, plural?: string): string;
 export declare function formatDuration(ms: number): string;

package/dist/ui/formatting.js

@@ -138,36 +138,45 @@ export function truncateText(text, maxLines = 3) {
     const hiddenCount = lines.length - maxLines;
     return `${truncated}\n  ... (${hiddenCount} more lines)`;
 }
+/**
+ * A URL for one line: host and path without the scheme (`www.example.com`
+ * for the root), cut in the middle when too long, keeping the host, the
+ * start of the path and the end of the path and query, where requests to
+ * one API differ (`api.example.com/v1/users/…/orders?page=2`).
+ *
+ * @param url - URL
+ * @param maxLength - Maximum length
+ * @returns Shortened URL; non-web URLs (data:, blob:) cut at the end
+ */
 export function truncateUrl(url, maxLength = 60) {
     const parsed = safeParseUrl(url);
     if (!parsed || !WEB_PROTOCOLS.has(parsed.protocol)) {
         return truncateEnd(url, maxLength);
     }
     const host = parsed.host;
-    const path = parsed.pathname.substring(1);
-    const full = `${host}${path ? `/${path}` : ''}`;
-    if (`${full}${parsed.search}`.length <= maxLength)
-        return `${full}${parsed.search}`;
-    if (!parsed.search)
-        return shortenPath(host, path, maxLength);
-    const room = maxLength - full.length;
-    if (room >= MIN_QUERY_SHOWN)
-        return `${full}${cutQuery(parsed.search, room)}`;
-    const query = cutQuery(parsed.search, MIN_QUERY_SHOWN);
-    return `${shortenPath(host, path, maxLength - query.length)}${query}`;
+    const rest = `${parsed.pathname.substring(1)}${parsed.search}`;
+    const shown = parsed.pathname.length > 1 ? `${host}/${rest}` : `${host}${parsed.search}`;
+    if (shown.length <= maxLength)
+        return shown;
+    const room = maxLength - host.length - 2;
+    if (room < MIN_URL_END_SHOWN)
+        return cutMiddle(shown, maxLength);
+    const start = Math.floor(room / 3);
+    return `${host}/${rest.substring(0, start)}…${rest.substring(rest.length - (room - start))}`;
 }
+/** Characters of path and query a shortened URL keeps at least besides its host */
+const MIN_URL_END_SHOWN = 12;
 /**
- * A query string cut to a length, marked with "…" when cut.
+ * Cut text in the middle, marking the cut with "…".
  *
- * @param search - Query string including "?"
- * @param length - Maximum length
- * @returns The query, or its start followed by "…"
+ * @param text - Text
+ * @param maxLength - Maximum length
+ * @returns Start and end of the text around "…"
  */
-function cutQuery(search, length) {
-    return search.length <= length ? search : `${search.substring(0, length - 1)}…`;
+function cutMiddle(text, maxLength) {
+    const head = Math.ceil((maxLength - 1) / 2);
+    return `${text.substring(0, head)}…${text.substring(text.length - (maxLength - 1 - head))}`;
 }
-/** Characters of a long query string kept, so similar requests stay distinguishable */
-const MIN_QUERY_SHOWN = 12;
 /** Protocols whose URLs are shown as host/path (others, like data: or blob:, verbatim) */
 const WEB_PROTOCOLS = new Set(['http:', 'https:', 'ws:', 'wss:']);
 /**
@@ -180,23 +189,6 @@ const WEB_PROTOCOLS = new Set(['http:', 'https:', 'ws:', 'wss:']);
 function truncateEnd(text, maxLength) {
     return text.length > maxLength ? text.substring(0, maxLength - 3) + '...' : text;
 }
-/**
- * Shorten a long host/path by eliding its middle segments.
- *
- * @param host - Host (with port)
- * @param path - Path without the leading slash
- * @param maxLength - Maximum length
- * @returns e.g. "example.com/docs/.../page"
- */
-function shortenPath(host, path, maxLength) {
-    const parts = path.split('/');
-    const first = parts[0];
-    const last = parts[parts.length - 1];
-    if (parts.length <= 2 || !first || !last)
-        return truncateEnd(`${host}/${path}`, maxLength);
-    const elided = `${host}/${first}/.../${last}`;
-    return elided.length <= maxLength ? elided : `${host}/${first}/.../${last.substring(0, 8)}`;
-}
 export function pluralize(count, singular, plural) {
     const word = count === 1 ? singular : (plural ?? singular + 's');
     return `${count} ${word}`;

package/dist/ui/messages/chrome.d.ts

@@ -161,4 +161,13 @@ export declare function chromeBinaryOverrideIsDirectory(path: string, source: st
  * @returns Multi-line formatted error message with troubleshooting steps
  */
 export declare function portInUseError(port: number): string;
+/**
+ * Warning when bdg's Chrome preferences (password manager and leak check
+ * off, etc.) could not be written into the profile.
+ *
+ * @param file - Preferences file
+ * @param reason - Why
+ * @returns Message
+ */
+export declare function chromePrefsNotAppliedMessage(file: string, reason: string): string;
 //# sourceMappingURL=chrome.d.ts.map

package/dist/ui/messages/chrome.js

@@ -5,6 +5,7 @@
  */
 import { getChromeDiagnostics } from '../../connection/diagnostics.js';
 import { pluralize, joinLines } from '../formatting.js';
+import { sessionCommand } from './sessionCommand.js';
 /**
  * Format a structured Chrome-related notice into a user-facing log line.
  *
@@ -52,7 +53,7 @@ export function formatChromeIssue(issue) {
                     ? chromeLaunchFailedError(reason)
                     : `Chrome failed to launch`;
             const diagnostics = getFormattedDiagnostics();
-            return joinLines(header, '', 'Possible causes:', `  - Port ${port} conflict (check: lsof -ti:${port})`, `  - Chrome binary not found`, `  - Insufficient permissions`, `  - Chrome crashed on startup`, '', ...diagnostics, '', 'Try:', `  - bdg cleanup`, `  - See what uses the port: lsof -i :${port}`, `  - Use different port: bdg <url> --port ${port + 1}`, `  - In a container where Chrome's sandbox fails: BDG_NO_SANDBOX=1 bdg <url>`);
+            return joinLines(header, '', 'Possible causes:', `  - Port ${port} conflict (check: lsof -ti:${port})`, `  - Chrome binary not found`, `  - Insufficient permissions`, `  - Chrome crashed on startup`, '', ...diagnostics, '', 'Try:', `  - ${sessionCommand('bdg cleanup')}`, `  - See what uses the port: lsof -i :${port}`, `  - Use different port: ${sessionCommand(`bdg <url> --port ${port + 1}`)}`, `  - In a container where Chrome's sandbox fails: BDG_NO_SANDBOX=1 ${sessionCommand('bdg <url>')}`);
         }
         case 'CHROME_EXITED_DURING_STARTUP':
             return chromeExitedDuringStartupError(ctx['exitCode'], ctx['output'] ?? [], ctx['userDataDir'], ctx['profileInUse'] === true);
@@ -90,7 +91,7 @@ export function formatChromeIssue(issue) {
  */
 export function chromeExitedDuringStartupError(exitCode, output, userDataDir, profileInUse) {
     if (profileInUse) {
-        return joinLines(`The Chrome profile ${userDataDir} is in use by another Chrome`, 'Close that Chrome, or use another profile directory: bdg <url> -u ./other-profile');
+        return joinLines(`The Chrome profile ${userDataDir} is in use by another Chrome`, `Close that Chrome, or use another profile directory: ${sessionCommand('bdg <url> -u ./other-profile')}`);
     }
     return joinLines(`Chrome exited during startup (exit code ${exitCode ?? 'none'})`, ...(output.length > 0 ? ['Chrome said:', ...output.map((line) => `  ${line}`)] : []), 'Check --chrome-flags and BDG_CHROME_FLAGS (an unknown flag or value can stop Chrome)');
 }
@@ -197,8 +198,8 @@ export function chromeExternalSkipTerminationMessage() {
  * @returns Formatted error message with diagnostics and troubleshooting steps
  */
 export function noPageTargetFoundError(port, availableTargets) {
-    return joinLines(`Chrome started but opened no page to attach to (port ${port})`, 'Retry: bdg <url>. If it keeps failing, another program may use the port (lsof -i :' +
-        `${port}) or a crashed session may be left over: bdg cleanup && bdg <url>`, ...(availableTargets ? ['', `Chrome targets:\n${availableTargets}`] : []));
+    return joinLines(`Chrome started but opened no page to attach to (port ${port})`, `Retry: ${sessionCommand('bdg <url>')}. If it keeps failing, another program may use the port (lsof -i :` +
+        `${port}) or a crashed session may be left over: ${sessionCommand('bdg cleanup')} && ${sessionCommand('bdg <url>')}`, ...(availableTargets ? ['', `Chrome targets:\n${availableTargets}`] : []));
 }
 /**
  * Generate preferences file not found error.
@@ -276,6 +277,17 @@ export function chromeBinaryOverrideIsDirectory(path, source) {
  * @returns Multi-line formatted error message with troubleshooting steps
  */
 export function portInUseError(port) {
-    return joinLines(`Port ${port} is already in use.\n`, 'Another program (or a Chrome left from a previous session) is listening on it.\n', 'Try:', `  - Use a different port: bdg <url> --port ${port + 1}`, `  - If a bdg session is stuck: bdg cleanup --force  (stops bdg's own daemon and Chrome only)`, `  - See what uses the port: lsof -i :${port}`);
+    return joinLines(`Port ${port} is already in use.\n`, 'Another program (or a Chrome left from a previous session) is listening on it.\n', 'Try:', `  - Use a different port: ${sessionCommand(`bdg <url> --port ${port + 1}`)}`, `  - If a bdg session holds it: find it with bdg sessions, then end that one: bdg stop --session <name> (bdg cleanup --force --session <name> if it is stuck)`, `  - See what uses the port: lsof -i :${port}`);
+}
+/**
+ * Warning when bdg's Chrome preferences (password manager and leak check
+ * off, etc.) could not be written into the profile.
+ *
+ * @param file - Preferences file
+ * @param reason - Why
+ * @returns Message
+ */
+export function chromePrefsNotAppliedMessage(file, reason) {
+    return `Warning: Chrome preferences not applied to ${file} (${reason}); password manager bubbles may capture clicks`;
 }
 //# sourceMappingURL=chrome.js.map