browser-debugger-cli 0.12.0 → 0.13.0

package/dist/commands/shared/dataFetcher.js

@@ -90,19 +90,25 @@ export async function fetchPreviewData(query = {}) {
  * Fetch all captured network requests from daemon.
  *
  * @param withHeaders - Include request/response headers (needed by header filters)
- * @returns Requests or a fetch error
+ * @returns Requests, and when the page crashed (while it is not loaded
+ *   again), or a fetch error
  */
 export async function fetchNetworkRequests(withHeaders = false) {
     const result = await fetchPreviewData({ lastN: 0, only: 'network', withHeaders });
     if (!result.success)
         return result;
-    return { success: true, data: result.data.network };
+    return {
+        success: true,
+        data: { requests: result.data.network, pageCrashedAt: result.data.output.pageCrashedAt },
+    };
 }
 /**
  * Fetch all console messages from daemon.
  *
- * @returns Messages (with their session-wide index) and the navigation id of
- *   the page currently loaded
+ * @returns Messages (with their session-wide index), the navigation id of
+ *   the page currently loaded, how many of the oldest messages the session
+ *   dropped at its limit and when the page crashed (while it is not loaded
+ *   again)
  */
 export async function fetchConsoleMessages() {
     const result = await fetchPreviewData({ lastN: 0, only: 'console' });
@@ -113,6 +119,8 @@ export async function fetchConsoleMessages() {
         data: {
             messages: result.data.console,
             currentNavigationId: result.data.output.currentNavigationId,
+            dropped: result.data.output.totals?.consoleDropped ?? 0,
+            pageCrashedAt: result.data.output.pageCrashedAt,
         },
     };
 }

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

@@ -23,6 +23,14 @@ export declare function followFetchFailure(failure: {
     json?: boolean | undefined;
     retryIntervalMs: number;
 }): FollowPoll;
+/**
+ * Report each page crash of a stream once: a page loaded again that crashes
+ * again is a new crash.
+ *
+ * @returns Function taking the crash time a refresh fetched, returning it
+ *   when that crash was not reported yet
+ */
+export declare function newPageCrashes(): (crashedAt: number | undefined) => number | undefined;
 /**
  * Options for configuring follow mode behavior.
  */
@@ -42,7 +50,7 @@ export interface FollowModeOptions {
  * - Initial display of start message
  * - First refresh call (awaited)
  * - Periodic interval-based refresh
- * - SIGINT handler for graceful shutdown
+ * - SIGINT/SIGTERM handlers that stop with 130/143, as shells expect
  * - Stopping with the exit code a refresh returns (e.g. the session is gone)
  *
  * @param refreshFn - Async function to call on each refresh cycle

package/dist/commands/shared/followMode.js

@@ -27,6 +27,22 @@ export function followFetchFailure(failure, options) {
         ? { exitCode: result.exitCode ?? EXIT_CODES.RESOURCE_NOT_FOUND }
         : undefined;
 }
+/**
+ * Report each page crash of a stream once: a page loaded again that crashes
+ * again is a new crash.
+ *
+ * @returns Function taking the crash time a refresh fetched, returning it
+ *   when that crash was not reported yet
+ */
+export function newPageCrashes() {
+    let reported;
+    return (crashedAt) => {
+        if (crashedAt === undefined || crashedAt === reported)
+            return undefined;
+        reported = crashedAt;
+        return crashedAt;
+    };
+}
 /**
  * Sets up follow mode with periodic refresh and graceful shutdown.
  *
@@ -35,7 +51,7 @@ export function followFetchFailure(failure, options) {
  * - Initial display of start message
  * - First refresh call (awaited)
  * - Periodic interval-based refresh
- * - SIGINT handler for graceful shutdown
+ * - SIGINT/SIGTERM handlers that stop with 130/143, as shells expect
  * - Stopping with the exit code a refresh returns (e.g. the session is gone)
  *
  * @param refreshFn - Async function to call on each refresh cycle
@@ -71,10 +87,12 @@ export async function setupFollowMode(refreshFn, options) {
             console.error(genericError(getErrorMessage(error)));
         });
     }, intervalMs);
-    process.on('SIGINT', () => {
+    const stop = (exitCode) => {
         clearInterval(intervalId);
         console.error(stopMessage());
-        process.exit(EXIT_CODES.SUCCESS);
-    });
+        process.exit(exitCode);
+    };
+    process.on('SIGINT', () => stop(EXIT_CODES.INTERRUPTED));
+    process.on('SIGTERM', () => stop(EXIT_CODES.TERMINATED));
 }
 //# sourceMappingURL=followMode.js.map

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

@@ -142,7 +142,10 @@ export type DetailsCommandOptions = BaseOptions & {
     id: string;
 };
 /** Options for DOM query command */
-export type DomQueryCommandOptions = BaseOptions;
+export type DomQueryCommandOptions = BaseOptions & {
+    /** Matches listed (0 = all); default 50, or 1000 with --json */
+    limit?: number;
+};
 /** Options for DOM get command */
 export type DomGetCommandOptions = BaseOptions & RawOptions & SelectionOptions & {
     /** All of the element's text instead of its first 500 characters (semantic output) */

package/dist/commands/shared/outputFile.js

@@ -7,6 +7,7 @@ import * as path from 'path';
 import { CommandError } from '../../errors/index.js';
 import { emptyOutputPathError, outputFileError } from '../../errors/messages.js';
 import { AtomicFileWriter } from '../../utils/atomicFile.js';
+import { makeDirectory } from '../../utils/directories.js';
 import { EXIT_CODES } from '../../utils/exitCodes.js';
 /** What went wrong with a path, by error code */
 const PATH_PROBLEMS = {
@@ -19,6 +20,10 @@ const PATH_PROBLEMS = {
     ENAMETOOLONG: { reason: 'the name is too long', exitCode: EXIT_CODES.INVALID_ARGUMENTS },
     ENOENT: { reason: 'the directory cannot be created', exitCode: EXIT_CODES.INVALID_ARGUMENTS },
     ENOSPC: { reason: 'no space left on the device', exitCode: EXIT_CODES.SESSION_FILE_ERROR },
+    EPSEUDOFS: {
+        reason: 'it is on a pseudo-filesystem (/proc, /sys)',
+        exitCode: EXIT_CODES.INVALID_ARGUMENTS,
+    },
 };
 /**
  * A file-system error as a user-facing error about the given path.
@@ -64,7 +69,7 @@ export async function writeOutputFile(filePath, data, extension) {
     assertFilePath(filePath, extension);
     const absolutePath = path.resolve(filePath);
     try {
-        fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+        makeDirectory(path.dirname(absolutePath));
         if (typeof data === 'string')
             await AtomicFileWriter.writeAsync(absolutePath, data);
         else

package/dist/commands/start.d.ts

@@ -84,15 +84,17 @@ export declare function parseViewport(value: string): ViewportSize;
  */
 export declare function parseColorScheme(value: string): ColorScheme;
 /**
- * Reject a subcommand typed without its group (`bdg query x` for
- * `bdg dom query x`) before Commander reads it as a start URL with extra
- * arguments.
+ * Reject a mistyped command before Commander reads it as a start URL with
+ * extra arguments (`too many arguments`): a subcommand typed without its
+ * group (`bdg query x` for `bdg dom query x`), or a word close to a command
+ * followed by more words (`bdg netwrk list`). A single word is left to the
+ * start command, which checks it the same way.
  *
  * @param program - Root command with all commands registered
  * @param argv - Process arguments
- * @throws CommandError (81) naming the full command
+ * @throws CommandError (81) naming the command meant
  */
-export declare function assertNotGroupSubcommand(program: Command, argv: string[]): void;
+export declare function assertNotMistypedCommand(program: Command, argv: string[]): void;
 /**
  * Register the start command
  *

package/dist/commands/start.js

@@ -9,19 +9,12 @@ import { PORT_OPTION_DESCRIPTION } from '../constants.js';
 import { CommandError } from '../errors/index.js';
 import { chromeWsUrlConflictError, externalChromeUnreachableError, invalidChromeFlagError, notDevToolsEndpointError, invalidColorSchemeError, invalidUserDataDirError, invalidViewportError, missingStartUrlError, unknownCommandError, } from '../errors/messages.js';
 import { startCommandHelpMessage } from '../ui/messages/commands.js';
+import { directoryProblem } from '../utils/directories.js';
+import { hasDisplay } from '../utils/display.js';
 import { EXIT_CODES } from '../utils/exitCodes.js';
 import { probeDevToolsEndpoint } from '../utils/http.js';
 import { findSimilar } from '../utils/suggestions.js';
 import { devToolsHttpEndpoint, validateChromeWsUrl, validateUrl } from '../utils/url.js';
-/**
- * Check if a display server (X11 or Wayland) is available.
- * Used to determine default headless mode.
- */
-function hasDisplay() {
-    const display = process.env['DISPLAY'];
-    const wayland = process.env['WAYLAND_DISPLAY'];
-    return (display !== undefined && display !== '') || (wayland !== undefined && wayland !== '');
-}
 /**
  * Expand a leading `~/` in a path to the user's home directory.
  * Chrome itself does not expand `~`, so bdg normalizes it for users.
@@ -74,7 +67,7 @@ export function applyCollectorOptions(command) {
         .option('-a, --all', 'Include all data: no tracking/analytics filtering, and capture every response body (incl. binary)', false)
         .option('-m, --max-body-size <megabytes>', 'Maximum response body size in MB', '5')
         .addOption(new Option('--compact', 'No effect; kept for compatibility').hideHelp())
-        .option('--headless', 'Run Chrome without a window (default unless DISPLAY or WAYLAND_DISPLAY is set)', defaultHeadless)
+        .option('--headless', 'Run Chrome without a window (default without a display: Linux without DISPLAY or WAYLAND_DISPLAY, macOS over SSH or in CI)', defaultHeadless)
         .option('--no-headless', 'Show browser window')
         .option('--chrome-ws-url <url>', 'Connect to an existing Chrome: its DevTools port (9222, host:port, http://host:port), or a WebSocket URL: browser (ws://host:port/devtools/browser/<id>, uses the first tab) or page (.../devtools/page/<id>)')
         .option('-q, --quiet', 'Quiet mode - minimal output for AI agents', false)
@@ -180,6 +173,8 @@ function buildSessionOptions(options) {
 }
 /** Telemetry collected by every session. */
 const SESSION_TELEMETRY = ['dom', 'network', 'console'];
+/** A word that cannot be a URL: no dot, colon or slash */
+const BARE_WORD = /^[a-z][a-z0-9_-]*$/i;
 /** Flags users type as commands (`bdg version`). */
 const FLAG_WORDS = { version: '--version', help: '--help' };
 /**
@@ -194,29 +189,59 @@ const FLAG_WORDS = { version: '--version', help: '--help' };
  * @throws CommandError (81) for a bare word other than `localhost`
  */
 function assertNotCommandTypo(arg, commandNames) {
-    if (!/^[a-z][a-z0-9_-]*$/i.test(arg) || arg.toLowerCase() === 'localhost')
+    if (!BARE_WORD.test(arg) || arg.toLowerCase() === 'localhost')
         return;
     const flag = FLAG_WORDS[arg.toLowerCase()];
     const err = unknownCommandError(arg, flag ? [flag] : findSimilar(arg, commandNames));
     throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
 }
 /**
- * Reject a subcommand typed without its group (`bdg query x` for
- * `bdg dom query x`) before Commander reads it as a start URL with extra
- * arguments.
+ * The words of the command line that are not options or option values of
+ * the root command (`bdg --session a netwrk list` gives `netwrk`, `list`).
+ *
+ * @param program - Root command
+ * @param args - Arguments after the executable and script
+ * @returns Positional words, in order
+ */
+function positionalWords(program, args) {
+    const words = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i] ?? '';
+        if (!arg.startsWith('-')) {
+            words.push(arg);
+            continue;
+        }
+        const option = program.options.find((o) => o.long === arg || o.short === arg);
+        if (option && (option.required || option.optional))
+            i++;
+    }
+    return words;
+}
+/**
+ * Reject a mistyped command before Commander reads it as a start URL with
+ * extra arguments (`too many arguments`): a subcommand typed without its
+ * group (`bdg query x` for `bdg dom query x`), or a word close to a command
+ * followed by more words (`bdg netwrk list`). A single word is left to the
+ * start command, which checks it the same way.
  *
  * @param program - Root command with all commands registered
  * @param argv - Process arguments
- * @throws CommandError (81) naming the full command
+ * @throws CommandError (81) naming the command meant
  */
-export function assertNotGroupSubcommand(program, argv) {
-    const [first] = argv.slice(2).filter((arg) => !arg.startsWith('-'));
-    if (first === undefined || program.commands.some((command) => command.name() === first))
+export function assertNotMistypedCommand(program, argv) {
+    const [first, ...rest] = positionalWords(program, argv.slice(2));
+    const commandNames = program.commands.map((command) => command.name());
+    if (first === undefined || commandNames.includes(first))
         return;
     const group = program.commands.find((command) => command.commands.some((sub) => sub.name() === first));
-    if (!group)
+    const similar = group
+        ? [`${group.name()} ${first}`]
+        : rest.length > 0 && BARE_WORD.test(first)
+            ? findSimilar(first, commandNames)
+            : [];
+    if (similar.length === 0)
         return;
-    const err = unknownCommandError(first, [`${group.name()} ${first}`]);
+    const err = unknownCommandError(first, similar);
     throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
 }
 /**
@@ -247,7 +272,10 @@ function validateStartInput(url, options, program) {
             ...(process.env['BDG_CHROME_FLAGS']?.split(' ') ?? []),
             ...(options.chromeFlags?.split(' ') ?? []),
         ]);
-    return { url, sessionOptions: buildSessionOptions(options) };
+    const sessionOptions = buildSessionOptions(options);
+    if (sessionOptions.userDataDir !== undefined)
+        assertUsableProfile(sessionOptions.userDataDir);
+    return { url, sessionOptions };
 }
 /**
  * Register the start command
@@ -346,6 +374,22 @@ function assertUserDataDir(value) {
     const err = invalidUserDataDirError(value, reason);
     throw new CommandError(err.message, { suggestion: err.suggestion }, EXIT_CODES.INVALID_ARGUMENTS);
 }
+/**
+ * Check that Chrome can create and write its profile directory (given with
+ * `-u` or in `--chrome-flags`), before a daemon is spawned: a profile under
+ * `/proc` spun the daemon at full CPU and wedged the session.
+ *
+ * @param dir - Profile directory, `~/` expanded
+ * @throws CommandError (81) for a path that cannot hold a directory, (82)
+ *   when its nearest existing directory is not writable
+ */
+function assertUsableProfile(dir) {
+    const problem = directoryProblem(dir);
+    if (!problem)
+        return;
+    const err = invalidUserDataDirError(dir, problem.reason);
+    throw new CommandError(err.message, { suggestion: err.suggestion }, problem.denied ? EXIT_CODES.PERMISSION_DENIED : EXIT_CODES.INVALID_ARGUMENTS);
+}
 /**
  * Options given that only apply to a Chrome bdg launches. `--headless` has a
  * default, so it counts only when given on the command line.

package/dist/commands/stop.d.ts

@@ -1,4 +1,15 @@
 import type { Command } from 'commander';
+/**
+ * Wait until the stopped session's daemon has exited: it removes the
+ * session's files on the way out, and a command run right after (`bdg
+ * sessions`, a new start) would otherwise still see the session. The wait is
+ * bounded, as after a failed start.
+ *
+ * @param pid - Daemon PID read before the stop, or null when unknown
+ * @param waitMs - Milliseconds to wait at most
+ * @returns Warning when the daemon still runs after the wait
+ */
+export declare function waitForDaemonExit(pid: number | null, waitMs?: number): Promise<string | undefined>;
 /**
  * Register stop command
  *

package/dist/commands/stop.js

@@ -3,13 +3,33 @@ import { jsonOption } from './shared/commonOptions.js';
 import { stopSession } from '../ipc/client.js';
 import { IPCErrorCode } from '../ipc/index.js';
 import { IPCTimeoutError } from '../ipc/transport/index.js';
+import { readLiveDaemonPid } from '../session/cleanup/staleSession.js';
 import { joinLines } from '../ui/formatting.js';
 import { chromeClosedMessage, orphanedDaemonsCleanedMessage, warningMessage, } from '../ui/messages/commands.js';
-import { sessionStopped, STOP_MESSAGES, stopFailedError } from '../ui/messages/session.js';
+import { daemonStillExitingHint, daemonStillExitingSuggestion, sessionStopped, STOP_MESSAGES, stopFailedError, } from '../ui/messages/session.js';
 import { noActiveSessionMessage, sessionCommand, startSessionSuggestion, } from '../ui/messages/sessionCommand.js';
+import { waitUntil } from '../utils/async.js';
 import { getExitCodeForIPCError, isDaemonNotRunningError } from '../utils/errorMapping.js';
 import { getErrorMessage } from '../utils/errors.js';
 import { EXIT_CODES } from '../utils/exitCodes.js';
+import { isProcessAlive } from '../utils/process.js';
+/** How long `bdg stop` waits for the session's daemon to exit */
+const DAEMON_EXIT_WAIT_MS = 3000;
+/**
+ * Wait until the stopped session's daemon has exited: it removes the
+ * session's files on the way out, and a command run right after (`bdg
+ * sessions`, a new start) would otherwise still see the session. The wait is
+ * bounded, as after a failed start.
+ *
+ * @param pid - Daemon PID read before the stop, or null when unknown
+ * @param waitMs - Milliseconds to wait at most
+ * @returns Warning when the daemon still runs after the wait
+ */
+export async function waitForDaemonExit(pid, waitMs = DAEMON_EXIT_WAIT_MS) {
+    if (pid === null || (await waitUntil(() => !isProcessAlive(pid), waitMs)))
+        return undefined;
+    return `${daemonStillExitingHint(pid, waitMs)}; ${daemonStillExitingSuggestion()}`;
+}
 /**
  * Format stop result for human-readable output.
  *
@@ -36,8 +56,10 @@ export function registerStopCommand(program) {
         .action(async (options) => {
         await runCommand(async () => {
             try {
+                const daemonPid = readLiveDaemonPid();
                 const response = await stopSession();
                 if (response.status === 'ok') {
+                    const warning = await waitForDaemonExit(daemonPid);
                     return {
                         success: true,
                         data: {
@@ -48,6 +70,7 @@ export function registerStopCommand(program) {
                             },
                             orphanedDaemonsCount: 0,
                             message: response.message ?? STOP_MESSAGES.SUCCESS,
+                            ...(warning && { warnings: [warning] }),
                         },
                     };
                 }

package/dist/commands.js

@@ -1,12 +1,12 @@
 import { registerCdpCommand } from './commands/cdp.js';
 import { registerCleanupCommand } from './commands/cleanup.js';
 import { registerConsoleCommand } from './commands/console.js';
+import { registerCssCommands } from './commands/css.js';
 import { registerDetailsCommand } from './commands/details.js';
 import { registerFormInteractionCommands } from './commands/dom/formInteraction.js';
 import { registerDomCommands } from './commands/dom/index.js';
 import { registerInstallSkillCommand } from './commands/installSkill.js';
 import { registerNetworkCommands } from './commands/network/index.js';
-import { registerCssCommands } from './commands/css.js';
 import { registerPageCommands } from './commands/page.js';
 import { registerPeekCommand } from './commands/peek.js';
 import { registerSessionsCommand } from './commands/sessions.js';

package/dist/connection/cdp.d.ts

@@ -181,6 +181,13 @@ export declare class CDPConnection implements CDPEventSource {
      * @returns Calculated delay in milliseconds (base delay * 2^attempt, capped at maxDelay)
      */
     private calculateBackoffDelay;
+    /**
+     * Fail every command still waiting for an answer, e.g. after the page's
+     * renderer crashed: commands it was running are never answered.
+     *
+     * @param error - Error the waiting commands fail with
+     */
+    rejectPending(error: Error): void;
     /**
      * Clear all pending command promises with the given error.
      *

package/dist/connection/cdp.js

@@ -390,6 +390,15 @@ export class CDPConnection {
     calculateBackoffDelay(attempt, maxDelay) {
         return Math.min(this.config.baseRetryDelay * Math.pow(2, attempt), maxDelay);
     }
+    /**
+     * Fail every command still waiting for an answer, e.g. after the page's
+     * renderer crashed: commands it was running are never answered.
+     *
+     * @param error - Error the waiting commands fail with
+     */
+    rejectPending(error) {
+        this.clearPendingMessages(error);
+    }
     /**
      * Clear all pending command promises with the given error.
      *

package/dist/connection/launcher.js

@@ -3,6 +3,7 @@ import * as os from 'os';
 import * as path from 'path';
 import * as chromeLauncher from 'chrome-launcher';
 import { BDG_CHROME_PREFS, DEFAULT_CDP_PORT, CHROME_PROFILE_DIR, DEFAULT_CHROME_LOG_LEVEL, DEFAULT_CHROME_HANDLE_SIGINT, } from '../constants.js';
+import { makeDirectory } from '../utils/directories.js';
 import { getErrorMessage } from '../utils/errors.js';
 import { filterDefined } from '../utils/objects.js';
 import { isProcessAlive } from '../utils/process.js';
@@ -62,7 +63,7 @@ export async function launchChrome(options = {}) {
     const userDataDir = options.userDataDir ?? getPersistentUserDataDir(options.baseDir ?? options.sessionDir);
     if (!fs.existsSync(userDataDir)) {
         try {
-            fs.mkdirSync(userDataDir, { recursive: true });
+            makeDirectory(userDataDir);
         }
         catch (error) {
             throw new ChromeLaunchError(`Failed to create user data directory`, {
@@ -160,7 +161,7 @@ function getPersistentUserDataDir(baseDir) {
     const userDataDir = path.join(dir, CHROME_PROFILE_DIR);
     if (!fs.existsSync(userDataDir)) {
         try {
-            fs.mkdirSync(userDataDir, { recursive: true });
+            makeDirectory(userDataDir);
         }
         catch (error) {
             throw new ChromeLaunchError(`Failed to create user data directory`, {

package/dist/daemon/SessionController.js

@@ -241,8 +241,13 @@ export class SessionController {
                         duration: data.duration,
                         target: data.target,
                         data: { network: data.network, console: data.console },
-                        totals: { network: data.totalNetwork, console: data.totalConsole },
+                        totals: {
+                            network: data.totalNetwork,
+                            console: data.totalConsole,
+                            ...(data.droppedConsole && { consoleDropped: data.droppedConsole }),
+                        },
                         currentNavigationId: data.currentNavigationId,
+                        ...(data.pageCrashedAt !== undefined && { pageCrashedAt: data.pageCrashedAt }),
                         partial: true,
                     },
                 },

package/dist/daemon/launcher.d.ts

@@ -24,8 +24,9 @@ export declare function launchDaemon(): Promise<SpawnedDaemon | undefined>;
  * Check that the session directory can hold the daemon's files before
  * spawning it (otherwise the daemon dies and only its log says why).
  *
- * @throws SessionDirError (103) for a file, (81) for a too-long path like a
- *   named session's, (82) when not writable
+ * @throws SessionDirError (103) for a file or a path that cannot hold a
+ *   directory (a pseudo-filesystem like `/proc`), (81) for a too-long path
+ *   like a named session's, (82) when not writable
  */
 export declare function assertUsableSessionDir(): void;
 //# sourceMappingURL=launcher.d.ts.map

package/dist/daemon/launcher.js

@@ -11,13 +11,16 @@ import fs from 'fs';
 import { join } from 'path';
 import { DaemonStartupError, SessionDirError } from './errors.js';
 import { sessionDirIsFileError, sessionDirNotWritableError, socketPathTooLongError, } from '../errors/messages.js';
-import { isDaemonAlive } from '../session/daemonSocket.js';
+import { killSessionChromes, readLiveDaemonPid } from '../session/cleanup/staleSession.js';
+import { isDaemonAlive, isDaemonSocketGone } from '../session/daemonSocket.js';
 import { MAX_DAEMON_SOCKET_PATH_BYTES, ensureSessionDir, getSessionDir, getSessionFilePath, } from '../session/paths.js';
 import { createLogger } from '../ui/logging/index.js';
 import { delay } from '../utils/async.js';
+import { directoryProblem } from '../utils/directories.js';
 import { getErrorMessage } from '../utils/errors.js';
 import { EXIT_CODES } from '../utils/exitCodes.js';
 import { DAEMON_SCRIPT_PATH } from '../utils/packageRoot.js';
+import { isProcessAlive } from '../utils/process.js';
 const log = createLogger('launcher');
 const DAEMON_READY_TIMEOUT_MS = 5000;
 const DAEMON_READY_POLL_MS = 20;
@@ -37,6 +40,7 @@ export async function launchDaemon() {
         throw new DaemonStartupError(`Daemon script not found at ${DAEMON_SCRIPT_PATH}. Did you run 'npm run build'?`, 'DAEMON_SCRIPT_NOT_FOUND');
     }
     assertUsableSessionDir();
+    await stopUnreachableDaemon();
     const logPath = join(getSessionDir(), 'daemon.log');
     rotateLog(logPath);
     const logFd = fs.openSync(logPath, 'a');
@@ -54,12 +58,48 @@ export async function launchDaemon() {
     await waitForDaemonReady(() => exited);
     return { pid: daemon.pid, hasExited: () => exited };
 }
+/** How long a daemon that lost its socket gets to end its session before it is killed */
+const UNREACHABLE_DAEMON_EXIT_MS = 8000;
+/**
+ * Stop a daemon of this session directory that still runs but can no longer
+ * be reached (its socket was removed, or refuses connections; one that is
+ * only slow to answer is left alone), before a new one starts: two daemons
+ * would launch two Chromes and remove each other's files. It is asked to end
+ * its session (closing its Chrome), and killed with what it launched if it
+ * does not exit in time.
+ */
+async function stopUnreachableDaemon() {
+    const pid = readLiveDaemonPid();
+    if (pid === null || !(await isDaemonSocketGone()))
+        return;
+    log.info(`Stopping daemon ${pid}, which can no longer be reached (its socket is gone)`);
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch (error) {
+        log.debug(`Daemon ${pid} not signalled: ${getErrorMessage(error)}`);
+        return;
+    }
+    const deadline = Date.now() + UNREACHABLE_DAEMON_EXIT_MS;
+    while (isProcessAlive(pid) && Date.now() < deadline)
+        await delay(100);
+    if (!isProcessAlive(pid))
+        return;
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch (error) {
+        log.debug(`Daemon ${pid} not killed: ${getErrorMessage(error)}`);
+    }
+    killSessionChromes();
+}
 /**
  * Check that the session directory can hold the daemon's files before
  * spawning it (otherwise the daemon dies and only its log says why).
  *
- * @throws SessionDirError (103) for a file, (81) for a too-long path like a
- *   named session's, (82) when not writable
+ * @throws SessionDirError (103) for a file or a path that cannot hold a
+ *   directory (a pseudo-filesystem like `/proc`), (81) for a too-long path
+ *   like a named session's, (82) when not writable
  */
 export function assertUsableSessionDir() {
     const dir = getSessionDir();
@@ -72,6 +112,10 @@ export function assertUsableSessionDir() {
     if (Buffer.byteLength(socketPath) > MAX_DAEMON_SOCKET_PATH_BYTES) {
         fail(socketPathTooLongError(socketPath, MAX_DAEMON_SOCKET_PATH_BYTES), EXIT_CODES.INVALID_ARGUMENTS);
     }
+    const problem = directoryProblem(dir);
+    if (problem) {
+        fail(sessionDirNotWritableError(dir, problem.reason), problem.denied ? EXIT_CODES.PERMISSION_DENIED : EXIT_CODES.SESSION_FILE_ERROR);
+    }
     try {
         ensureSessionDir();
         fs.accessSync(dir, fs.constants.W_OK);

package/dist/daemon/session/Session.d.ts

@@ -80,7 +80,10 @@ export declare class Session {
      */
     launch(): Promise<void>;
     /**
-     * Execute a registered command against this session.
+     * Execute a registered command against this session. After a renderer
+     * crash only {@link RUN_ON_CRASHED_PAGE} commands run (`bdg cdp` only for
+     * {@link CRASH_SAFE_CDP} methods); others fail with exit 107 instead of
+     * waiting for a page that cannot answer.
      *
      * @param name - Command name
      * @param params - Command parameters