browser-debugger-cli 0.11.0 → 0.13.0

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

@@ -25,4 +25,28 @@ export declare function stoppedFollowingConsoleMessage(): string;
  * @returns e.g. `[n] are positions in the session's message list; not listed in between: 1 message from another page load (-H lists all)`
  */
 export declare function consoleIndexGapNote(skipped: ConsoleSkipped): string;
+/**
+ * Note that the session dropped its oldest console messages at the limit.
+ *
+ * @param dropped - Messages dropped
+ * @returns e.g. `⚠ 2000 older console messages were dropped: bdg keeps the newest 10000`
+ */
+export declare function consoleDroppedNote(dropped: number): string;
+/**
+ * Error for `bdg details console <n>` with the index of a dropped message.
+ *
+ * @param index - Index asked for
+ * @param dropped - Messages dropped (the first kept has this index)
+ * @returns Message
+ */
+export declare function consoleMessageDroppedError(index: number, dropped: number): string;
+/**
+ * Note under the console summary when it lists only the newest distinct
+ * errors or warnings.
+ *
+ * @param more - Distinct messages not listed
+ * @param level - `error` or `warning`
+ * @returns e.g. `(+120 earlier distinct errors; bdg console --level error --last 0 lists every one)`
+ */
+export declare function consoleMoreGroupsNote(more: number, level: 'error' | 'warning'): string;
 //# sourceMappingURL=consoleMessages.d.ts.map

package/dist/ui/messages/consoleMessages.js

@@ -3,7 +3,9 @@
  *
  * User-facing messages for the console command output and formatting.
  */
+import { MAX_CONSOLE_MESSAGES } from '../../constants.js';
 import { pluralize } from '../formatting.js';
+import { sessionCommand } from './sessionCommand.js';
 /**
  * Generate message for following console output.
  *
@@ -36,4 +38,34 @@ export function consoleIndexGapNote(skipped) {
     ].filter(Boolean);
     return `[n] are positions in the session's message list; not listed in between: ${reasons.join(', ')}`;
 }
+/**
+ * Note that the session dropped its oldest console messages at the limit.
+ *
+ * @param dropped - Messages dropped
+ * @returns e.g. `⚠ 2000 older console messages were dropped: bdg keeps the newest 10000`
+ */
+export function consoleDroppedNote(dropped) {
+    return `⚠ ${pluralize(dropped, 'older console message')} ${dropped === 1 ? 'was' : 'were'} dropped: bdg keeps the newest ${MAX_CONSOLE_MESSAGES}`;
+}
+/**
+ * Error for `bdg details console <n>` with the index of a dropped message.
+ *
+ * @param index - Index asked for
+ * @param dropped - Messages dropped (the first kept has this index)
+ * @returns Message
+ */
+export function consoleMessageDroppedError(index, dropped) {
+    return `Console message ${index} was dropped: bdg keeps the newest ${MAX_CONSOLE_MESSAGES} messages (the oldest kept is ${dropped})`;
+}
+/**
+ * Note under the console summary when it lists only the newest distinct
+ * errors or warnings.
+ *
+ * @param more - Distinct messages not listed
+ * @param level - `error` or `warning`
+ * @returns e.g. `(+120 earlier distinct errors; bdg console --level error --last 0 lists every one)`
+ */
+export function consoleMoreGroupsNote(more, level) {
+    return `(+${more} earlier distinct ${more === 1 ? level : `${level}s`}; ${sessionCommand(`bdg console --level ${level} --last 0`)} lists every one)`;
+}
 //# sourceMappingURL=consoleMessages.js.map

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

@@ -55,10 +55,22 @@ export declare function stoppedFollowingPreviewMessage(): string;
  * @param retryLabel - Human-readable retry interval (e.g. "1s", "500ms")
  */
 export declare function connectionLostRetryMessage(timestamp: string, retryLabel: string): string;
+/**
+ * Follow mode stops because the session it followed ended.
+ *
+ * @returns Message
+ */
+export declare function followedSessionEndedMessage(): string;
 /**
  * Generate follow-mode stop hint.
  *
  * @returns Message instructing the user how to stop follow mode
  */
 export declare function connectionLostStopHintMessage(): string;
+/**
+ * Notice that `bdg tail` is deprecated (it still runs).
+ *
+ * @returns Notice for stderr
+ */
+export declare function tailDeprecatedNotice(): string;
 //# sourceMappingURL=preview.d.ts.map

package/dist/ui/messages/preview.js

@@ -19,7 +19,7 @@ export const PREVIEW_HEADERS = {
  * @returns Single-line tip for basic peek usage
  */
 export function compactTipsMessage() {
-    return `Tip: ${sessionCommand('bdg peek --last 50')} | ${sessionCommand('bdg peek --verbose')}`;
+    return `Tip: ${sessionCommand('bdg peek --last 50')} or ${sessionCommand('bdg peek --verbose')}`;
 }
 /**
  * Generate verbose mode commands section.
@@ -30,7 +30,7 @@ export function verboseCommandsMessage() {
     return [
         'Commands:',
         `  Full preview:    ${sessionCommand('bdg peek --last 50')}`,
-        `  Watch live:      ${sessionCommand('bdg tail')}`,
+        `  Watch live:      ${sessionCommand('bdg peek --follow')}`,
         `  End session:     ${sessionCommand('bdg stop')}`,
     ].join('\n');
 }
@@ -71,6 +71,14 @@ export function stoppedFollowingPreviewMessage() {
 export function connectionLostRetryMessage(timestamp, retryLabel) {
     return `\n[${timestamp}] ⚠️  Connection lost, retrying every ${retryLabel}...`;
 }
+/**
+ * Follow mode stops because the session it followed ended.
+ *
+ * @returns Message
+ */
+export function followedSessionEndedMessage() {
+    return 'The session ended; stopped following';
+}
 /**
  * Generate follow-mode stop hint.
  *
@@ -79,4 +87,12 @@ export function connectionLostRetryMessage(timestamp, retryLabel) {
 export function connectionLostStopHintMessage() {
     return 'Press Ctrl+C to stop';
 }
+/**
+ * Notice that `bdg tail` is deprecated (it still runs).
+ *
+ * @returns Notice for stderr
+ */
+export function tailDeprecatedNotice() {
+    return 'Note: "bdg tail" is deprecated and will be removed; use "bdg peek --follow" (same options: --last, --network, --console, --interval, --verbose)';
+}
 //# sourceMappingURL=preview.js.map

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

@@ -78,7 +78,18 @@ export declare function lastSessionEndText(end: {
     endedAt: number;
 }): string;
 /**
- * Note after a failed start whose daemon had not exited when bdg stopped waiting.
+ * A session that ended without `bdg stop`, for `bdg sessions`.
+ *
+ * @param label - Session name as listed
+ * @param end - How and when it ended
+ * @returns One line
+ */
+export declare function endedSessionText(label: string, end: {
+    reason: string;
+    endedAt: number;
+}): string;
+/**
+ * Note after a failed start or a stop whose daemon had not exited when bdg stopped waiting.
  *
  * @param pid - Daemon PID, when known
  * @param waitedMs - How long bdg waited
@@ -86,7 +97,7 @@ export declare function lastSessionEndText(end: {
  */
 export declare function daemonStillExitingHint(pid: number | undefined, waitedMs: number): string;
 /**
- * What to do about a daemon still shutting down after a failed start.
+ * What to do about a daemon still shutting down after a failed start or a stop.
  *
  * @returns Suggestion
  */

package/dist/ui/messages/session.js

@@ -89,16 +89,35 @@ export function stopFailedError(reason) {
  * @returns One line
  */
 export function lastSessionEndText(end) {
+    return `The last session ended ${sessionEndText(end)}`;
+}
+/**
+ * A session that ended without `bdg stop`, for `bdg sessions`.
+ *
+ * @param label - Session name as listed
+ * @param end - How and when it ended
+ * @returns One line
+ */
+export function endedSessionText(label, end) {
+    return `${label} ended ${sessionEndText(end)}`;
+}
+/**
+ * When and why a session ended without `bdg stop`.
+ *
+ * @param end - How and when it ended
+ * @returns `at <time>: <why>`
+ */
+function sessionEndText(end) {
     const why = {
         crash: 'Chrome crashed or was closed',
         closed: 'its page was closed',
         timeout: 'the --timeout was reached',
     };
     const at = new Date(end.endedAt).toLocaleTimeString();
-    return `The last session ended at ${at}: ${why[end.reason] ?? end.reason}`;
+    return `at ${at}: ${why[end.reason] ?? end.reason}`;
 }
 /**
- * Note after a failed start whose daemon had not exited when bdg stopped waiting.
+ * Note after a failed start or a stop whose daemon had not exited when bdg stopped waiting.
  *
  * @param pid - Daemon PID, when known
  * @param waitedMs - How long bdg waited
@@ -109,7 +128,7 @@ export function daemonStillExitingHint(pid, waitedMs) {
     return `${daemon} was still shutting down after ${waitedMs / 1000}s`;
 }
 /**
- * What to do about a daemon still shutting down after a failed start.
+ * What to do about a daemon still shutting down after a failed start or a stop.
  *
  * @returns Suggestion
  */

package/dist/utils/cssValues.js

@@ -44,11 +44,42 @@ export function cssLength(value) {
  * @returns Normalized value
  */
 export function normalizeCssValue(value) {
-    return hexColorsIn(value)
-        .replace(PX_IN_VALUE, (_match, number) => String(round1(Number(number))))
+    return mapOutsideFunctions(hexColorsIn(value), UNIT_KEEPING_FUNCTIONS, (part) => part.replace(PX_IN_VALUE, (_match, number) => String(round1(Number(number)))))
         .replace(/\s+/g, ' ')
         .trim();
 }
+/** Functions whose px stay written: math mixes units, URLs are names */
+const UNIT_KEEPING_FUNCTIONS = new Set(['calc', 'min', 'max', 'clamp', 'url']);
+/**
+ * Change the parts of a value that are not inside the given functions.
+ *
+ * @param value - CSS value
+ * @param functions - Function names whose arguments are kept as written
+ * @param change - Change for the other parts
+ * @returns Value
+ */
+function mapOutsideFunctions(value, functions, change) {
+    let result = '';
+    let start = 0;
+    let depth = 0;
+    for (let i = 0; i < value.length; i++) {
+        if (value[i] === '(') {
+            const name = /([\w-]+)$/.exec(value.slice(start, i))?.[1]?.toLowerCase() ?? '';
+            if (depth === 0 && functions.has(name)) {
+                result += change(value.slice(start, i));
+                start = i;
+                depth = 1;
+            }
+            else if (depth > 0)
+                depth++;
+        }
+        else if (value[i] === ')' && depth > 0 && --depth === 0) {
+            result += value.slice(start, i + 1);
+            start = i + 1;
+        }
+    }
+    return result + (depth > 0 ? value.slice(start) : change(value.slice(start)));
+}
 /**
  * 1-4 values the way CSS shorthands write them (top, right, bottom, left).
  *
@@ -190,9 +221,10 @@ function round3(value) {
 function decomposeMatrix([a = 1, b = 0, c = 0, d = 1, e = 0, f = 0]) {
     if (Math.abs(a * c + b * d) > 1e-6)
         return undefined;
-    const scaleX = Math.hypot(a, b);
+    const mirrored = a * d - b * c < 0 && a < 0;
+    const scaleX = mirrored ? -Math.hypot(a, b) : Math.hypot(a, b);
     const scaleY = scaleX === 0 ? 0 : (a * d - b * c) / scaleX;
-    const angle = round3((Math.atan2(b, a) * 180) / Math.PI);
+    const angle = round3((Math.atan2(mirrored ? -b : b, mirrored ? -a : a) * 180) / Math.PI);
     const parts = [];
     if (e !== 0 || f !== 0)
         parts.push(`translate(${round1(e)},${round1(f)})`);

package/dist/utils/decisionTrees.js

@@ -121,11 +121,6 @@ export const DECISION_TREES = {
                 yesCommand: 'peek --follow',
                 noAction: 'next',
             },
-            {
-                question: 'Need continuous monitoring (like tail -f)?',
-                yesCommand: 'tail',
-                noAction: 'next',
-            },
             {
                 question: 'Need quick preview of recent data?',
                 yesCommand: 'peek',

package/dist/utils/directories.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Checks for a directory bdg is about to create and write (the session
+ * directory, a Chrome profile) before it touches it: `fs.mkdirSync` with
+ * `recursive` spins forever on Linux pseudo-filesystems (`/proc/x` kept a
+ * start at full CPU until SIGKILL), and a profile Chrome cannot use wedges
+ * the session.
+ */
+/** Why a directory cannot be used, and whether it is a permission problem */
+export interface DirectoryProblem {
+    /** e.g. `/proc is a pseudo-filesystem`, `/tmp/x is a file`, `EACCES` */
+    reason: string;
+    /** Permission denied (or a read-only file system) rather than a wrong path */
+    denied: boolean;
+}
+/**
+ * Why `dir` cannot be created or written: it (or the path to it) is on a
+ * pseudo-filesystem, a part of it is a file, or its nearest existing
+ * directory is not writable.
+ *
+ * @param dir - Directory path (resolved against the working directory)
+ * @returns The problem, or null when the directory can be used
+ */
+export declare function directoryProblem(dir: string): DirectoryProblem | null;
+/**
+ * Create a directory (and its parents) after {@link directoryProblem} found
+ * nothing wrong, so a pseudo-filesystem fails at once instead of spinning.
+ *
+ * @param dir - Directory to create
+ * @param mode - Permissions of the directories created
+ * @throws Error with `code` `EPSEUDOFS` (pseudo-filesystem), `ENOTDIR` (a
+ *   file on the path), `EACCES` (not writable), or the `mkdir` error
+ */
+export declare function makeDirectory(dir: string, mode?: number): void;
+//# sourceMappingURL=directories.d.ts.map

package/dist/utils/directories.js

@@ -0,0 +1,88 @@
+/**
+ * Checks for a directory bdg is about to create and write (the session
+ * directory, a Chrome profile) before it touches it: `fs.mkdirSync` with
+ * `recursive` spins forever on Linux pseudo-filesystems (`/proc/x` kept a
+ * start at full CPU until SIGKILL), and a profile Chrome cannot use wedges
+ * the session.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/** Pseudo-filesystems no directory can be created on */
+const PSEUDO_FILESYSTEM = /^\/(proc|sys)(\/|$)/;
+/**
+ * Nearest path at or above `dir` that exists.
+ *
+ * @param dir - Absolute path
+ * @returns The path itself, or its nearest existing ancestor
+ */
+function nearestExisting(dir) {
+    let current = dir;
+    while (!fs.existsSync(current)) {
+        const parent = path.dirname(current);
+        if (parent === current)
+            return current;
+        current = parent;
+    }
+    return current;
+}
+/**
+ * Why `dir` cannot be created or written: it (or the path to it) is on a
+ * pseudo-filesystem, a part of it is a file, or its nearest existing
+ * directory is not writable.
+ *
+ * @param dir - Directory path (resolved against the working directory)
+ * @returns The problem, or null when the directory can be used
+ */
+export function directoryProblem(dir) {
+    const resolved = path.resolve(dir);
+    const existing = nearestExisting(resolved);
+    let real;
+    try {
+        real = fs.realpathSync(existing);
+    }
+    catch (error) {
+        return { reason: error.code ?? String(error), denied: false };
+    }
+    if (PSEUDO_FILESYSTEM.test(resolved) || PSEUDO_FILESYSTEM.test(real)) {
+        const root = (PSEUDO_FILESYSTEM.exec(resolved) ?? PSEUDO_FILESYSTEM.exec(real))?.[0] ?? '';
+        return { reason: `${root.replace(/\/$/, '')} is a pseudo-filesystem`, denied: false };
+    }
+    if (!fs.statSync(real).isDirectory()) {
+        return {
+            reason: existing === resolved ? 'it is a file' : `${existing} is a file`,
+            denied: false,
+        };
+    }
+    try {
+        fs.accessSync(real, fs.constants.W_OK);
+    }
+    catch (error) {
+        const code = error.code ?? String(error);
+        return { reason: `${existing} is not writable (${code})`, denied: true };
+    }
+    return null;
+}
+/**
+ * Create a directory (and its parents) after {@link directoryProblem} found
+ * nothing wrong, so a pseudo-filesystem fails at once instead of spinning.
+ *
+ * @param dir - Directory to create
+ * @param mode - Permissions of the directories created
+ * @throws Error with `code` `EPSEUDOFS` (pseudo-filesystem), `ENOTDIR` (a
+ *   file on the path), `EACCES` (not writable), or the `mkdir` error
+ */
+export function makeDirectory(dir, mode) {
+    if (fs.existsSync(dir))
+        return;
+    const problem = directoryProblem(dir);
+    if (problem) {
+        const code = problem.denied
+            ? 'EACCES'
+            : /pseudo-filesystem/.test(problem.reason)
+                ? 'EPSEUDOFS'
+                : 'ENOTDIR';
+        throw Object.assign(new Error(problem.reason), { code });
+    }
+    fs.mkdirSync(dir, { recursive: true, ...(mode !== undefined && { mode }) });
+}
+//# sourceMappingURL=directories.js.map

package/dist/utils/display.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Whether Chrome can show a window, which decides the default of
+ * `--headless`.
+ */
+/**
+ * Whether a display is available for Chrome's window: on Linux an X11 or
+ * Wayland display (`DISPLAY`, `WAYLAND_DISPLAY`; WSLg sets them too), on
+ * macOS the desktop unless the shell came in over SSH (`SSH_CONNECTION`,
+ * `SSH_TTY`) or runs in CI (`CI`, unless `false` or `0`). Servers, containers and CI stay headless.
+ *
+ * @param env - Environment variables
+ * @param platform - Operating system (`process.platform`)
+ * @returns True when Chrome should show a window by default
+ */
+export declare function hasDisplay(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;
+//# sourceMappingURL=display.d.ts.map

package/dist/utils/display.js

@@ -0,0 +1,42 @@
+/**
+ * Whether Chrome can show a window, which decides the default of
+ * `--headless`.
+ */
+/**
+ * Whether an environment variable is set and not empty.
+ *
+ * @param env - Environment variables
+ * @param name - Variable name
+ * @returns True when set to a non-empty value
+ */
+function isSet(env, name) {
+    const value = env[name];
+    return value !== undefined && value !== '';
+}
+/**
+ * Whether the environment says it is CI: `CI` set to anything but `false`
+ * or `0` (`CI=false` is how a CI flag is turned off).
+ *
+ * @param env - Environment variables
+ * @returns True in CI
+ */
+function isCi(env) {
+    return isSet(env, 'CI') && !['false', '0'].includes(env['CI']?.toLowerCase() ?? '');
+}
+/**
+ * Whether a display is available for Chrome's window: on Linux an X11 or
+ * Wayland display (`DISPLAY`, `WAYLAND_DISPLAY`; WSLg sets them too), on
+ * macOS the desktop unless the shell came in over SSH (`SSH_CONNECTION`,
+ * `SSH_TTY`) or runs in CI (`CI`, unless `false` or `0`). Servers, containers and CI stay headless.
+ *
+ * @param env - Environment variables
+ * @param platform - Operating system (`process.platform`)
+ * @returns True when Chrome should show a window by default
+ */
+export function hasDisplay(env = process.env, platform = process.platform) {
+    if (platform === 'darwin') {
+        return !isSet(env, 'SSH_CONNECTION') && !isSet(env, 'SSH_TTY') && !isCi(env);
+    }
+    return isSet(env, 'DISPLAY') || isSet(env, 'WAYLAND_DISPLAY');
+}
+//# sourceMappingURL=display.js.map

package/dist/utils/exitCodes.d.ts

@@ -53,6 +53,7 @@ export declare const EXIT_CODES: {
     readonly UNHANDLED_EXCEPTION: 104;
     readonly SIGNAL_HANDLER_ERROR: 105;
     readonly SESSION_START_FAILURE: 106;
+    readonly PAGE_CRASHED: 107;
     readonly SOFTWARE_ERROR: 110;
     readonly INTERRUPTED: 130;
     readonly TERMINATED: 143;

package/dist/utils/exitCodes.js

@@ -53,6 +53,7 @@ export const EXIT_CODES = {
     UNHANDLED_EXCEPTION: 104,
     SIGNAL_HANDLER_ERROR: 105,
     SESSION_START_FAILURE: 106,
+    PAGE_CRASHED: 107,
     SOFTWARE_ERROR: 110,
     INTERRUPTED: 130,
     TERMINATED: 143,
@@ -165,6 +166,11 @@ export const EXIT_CODE_REGISTRY = [
         name: 'SESSION_START_FAILURE',
         description: 'Session failed to start (Chrome launch or CDP connection)',
     },
+    {
+        code: EXIT_CODES.PAGE_CRASHED,
+        name: 'PAGE_CRASHED',
+        description: 'The page crashed (its renderer is gone); bdg page reload brings it back',
+    },
     {
         code: EXIT_CODES.SOFTWARE_ERROR,
         name: 'SOFTWARE_ERROR',

package/dist/utils/process.d.ts

@@ -52,4 +52,16 @@ export declare function killChromeProcess(pid: number, signal?: NodeJS.Signals):
  * @returns Command line, or null if unavailable (process gone, or unsupported platform)
  */
 export declare function getProcessCommand(pid: number): string | null;
+/** A running process and its command line */
+export interface ProcessEntry {
+    pid: number;
+    command: string;
+}
+/**
+ * Every running process with its command line: from `/proc` on Linux
+ * (minimal containers' BusyBox `ps` lacks `-o`), else from `ps` (macOS).
+ *
+ * @returns Processes, empty when they cannot be listed (Windows)
+ */
+export declare function listProcesses(): ProcessEntry[];
 //# sourceMappingURL=process.d.ts.map

package/dist/utils/process.js

@@ -120,4 +120,29 @@ export function getProcessCommand(pid) {
     const command = result.stdout.trim();
     return command.length > 0 ? command : null;
 }
+/**
+ * Every running process with its command line: from `/proc` on Linux
+ * (minimal containers' BusyBox `ps` lacks `-o`), else from `ps` (macOS).
+ *
+ * @returns Processes, empty when they cannot be listed (Windows)
+ */
+export function listProcesses() {
+    if (process.platform === 'win32')
+        return [];
+    if (fs.existsSync('/proc/self/cmdline')) {
+        return fs
+            .readdirSync('/proc')
+            .filter((name) => /^\d+$/.test(name))
+            .map((name) => ({ pid: Number(name), command: getProcessCommand(Number(name)) ?? '' }))
+            .filter((entry) => entry.command !== '');
+    }
+    const result = spawnSync('ps', ['-A', '-ww', '-o', 'pid=,command='], { encoding: 'utf-8' });
+    if (result.error || result.status !== 0)
+        return [];
+    return result.stdout
+        .split('\n')
+        .map((line) => /^\s*(\d+)\s+(.*)$/.exec(line))
+        .filter((match) => match !== null)
+        .map(([, pid, command]) => ({ pid: Number(pid), command: command ?? '' }));
+}
 //# sourceMappingURL=process.js.map

package/dist/utils/suggestions.d.ts

@@ -18,8 +18,10 @@ export declare function getSuggestion(input: string, candidates: readonly string
 /**
  * Names (ids or classes) similar to one that matched nothing, best first, at
  * most three: near-typos first (Levenshtein distance up to a fifth of the
- * length, at least 2), then names sharing a long end, then names sharing a
- * long start (at least a third of the name, at least 4 characters). The end
+ * length, at least 2), then names sharing a long end (at least a third of
+ * the name, at least 4 characters), then names sharing a long start (at
+ * least half: `--color-btn-inset-shadow` and `--color-bg-discussions-…` share
+ * only a namespace). The end
  * ranks before the start because ids tend to name an action before the item
  * (`add-to-cart-backpack` becomes `remove-backpack` once clicked).
  *

package/dist/utils/suggestions.js

@@ -65,8 +65,10 @@ function commonSuffixLength(a, b) {
 /**
  * Names (ids or classes) similar to one that matched nothing, best first, at
  * most three: near-typos first (Levenshtein distance up to a fifth of the
- * length, at least 2), then names sharing a long end, then names sharing a
- * long start (at least a third of the name, at least 4 characters). The end
+ * length, at least 2), then names sharing a long end (at least a third of
+ * the name, at least 4 characters), then names sharing a long start (at
+ * least half: `--color-btn-inset-shadow` and `--color-bg-discussions-…` share
+ * only a namespace). The end
  * ranks before the start because ids tend to name an action before the item
  * (`add-to-cart-backpack` becomes `remove-backpack` once clicked).
  *
@@ -79,15 +81,15 @@ export function findSimilarNames(name, candidates) {
     const maxDistance = Math.max(2, Math.floor(name.length / 5));
     const minAffix = Math.max(4, Math.ceil(name.length / 3));
     const typos = findMatches(name, others, maxDistance, false).map((match) => match.value);
-    const byAffix = (length) => others
+    const byAffix = (length, min = minAffix) => others
         .map((candidate) => ({ candidate, length: length(candidate) }))
-        .filter((entry) => entry.length >= minAffix)
+        .filter((entry) => entry.length >= min)
         .sort((a, b) => b.length - a.length)
         .map((entry) => entry.candidate);
     const ranked = [
         ...typos,
         ...byAffix((candidate) => commonSuffixLength(name, candidate)),
-        ...byAffix((candidate) => commonPrefixLength(name, candidate)),
+        ...byAffix((candidate) => commonPrefixLength(name, candidate), Math.max(minAffix, Math.ceil(name.length / 2))),
     ];
     return [...new Set(ranked)].slice(0, MAX_SIMILAR_NAMES);
 }

package/dist/utils/taskMappings.js

@@ -111,7 +111,7 @@ export const TASK_MAPPINGS = {
         cdpAlternative: 'Multiple IPC queries to session state',
     },
     live_monitoring: {
-        commands: ['peek --follow', 'tail'],
+        commands: ['peek --follow'],
         description: 'Monitor data collection in real-time',
         cdpAlternative: 'CDP event subscriptions with custom handler',
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "browser-debugger-cli",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "DevTools telemetry in your terminal. For humans and agents. Direct WebSocket to Chrome's debugging port.",
   "type": "module",
   "bin": {
@@ -128,6 +128,7 @@
   "overrides": {
     "eslint-plugin-tsdoc": {
       "@typescript-eslint/utils": "^8.71.0"
-    }
+    },
+    "shell-quote": "^1.12.0"
   }
 }