browser-debugger-cli 0.12.0 → 0.14.0

package/dist/runtime/page/replacedBuiltins.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Which browser built-ins a page replaced (polyfills, old frameworks,
+ * anti-bot scripts). Scripts that must run in the page's own world (actions,
+ * `dom eval` results) depend on them.
+ *
+ * The check does not trust the page: a small page script only collects the
+ * functions (plain property reads and the page's
+ * `Object.getOwnPropertyDescriptor`, itself checked), and whether each is
+ * native comes from the description CDP gives a function, which V8 builds
+ * itself, so a replaced `Function.prototype.toString` or `.call` changes
+ * nothing. A getter or setter counts as the property (a page-defined getter
+ * on `window.getComputedStyle`, a replaced `value` setter); a property that
+ * throws or is gone counts as replaced. An iterator is not checked when the
+ * page replaced `Symbol` (iteration does not use it).
+ */
+import type { CDPSender } from '../../telemetry/objectExpander.js';
+/**
+ * The built-ins of a list that the page replaced.
+ *
+ * @param cdp - CDP connection (or session) of the page
+ * @param names - Dotted paths, e.g. `Element.prototype.matches`,
+ *   `window.getComputedStyle`, `NodeList.prototype[Symbol.iterator]`
+ * @param objectId - An object of the realm to check (e.g. a frame's eval
+ *   result); default: the page's main world
+ * @returns The replaced ones, in list order (empty when the check failed)
+ */
+export declare function findReplacedBuiltins(cdp: CDPSender, names: readonly string[], objectId?: string): Promise<string[]>;
+//# sourceMappingURL=replacedBuiltins.d.ts.map

package/dist/runtime/page/replacedBuiltins.js

@@ -0,0 +1,136 @@
+/**
+ * Which browser built-ins a page replaced (polyfills, old frameworks,
+ * anti-bot scripts). Scripts that must run in the page's own world (actions,
+ * `dom eval` results) depend on them.
+ *
+ * The check does not trust the page: a small page script only collects the
+ * functions (plain property reads and the page's
+ * `Object.getOwnPropertyDescriptor`, itself checked), and whether each is
+ * native comes from the description CDP gives a function, which V8 builds
+ * itself, so a replaced `Function.prototype.toString` or `.call` changes
+ * nothing. A getter or setter counts as the property (a page-defined getter
+ * on `window.getComputedStyle`, a replaced `value` setter); a property that
+ * throws or is gone counts as replaced. An iterator is not checked when the
+ * page replaced `Symbol` (iteration does not use it).
+ */
+import { createLogger } from '../../ui/logging/index.js';
+import { getErrorMessage } from '../../utils/errors.js';
+const log = createLogger('dom');
+/** Description V8 gives a native function, e.g. `function querySelector() { [native code] }` */
+const NATIVE_FUNCTION = /\{\s*\[native code\]\s*\}$/;
+/** Suffix naming a prototype's iterator, e.g. `NodeList.prototype[Symbol.iterator]` */
+const ITERATOR_SUFFIX = '[Symbol.iterator]';
+/** Path segment the collector reads as `Symbol.iterator` */
+const ITERATOR_KEY = '@@iterator';
+/** Object group of the collected functions (released after each check) */
+const OBJECT_GROUP = 'bdg-builtins';
+/**
+ * Page-side collector: for each name, the function(s) behind it, as a flat
+ * list of `index, function` pairs (`undefined` for one that throws or is
+ * gone). Uses no array or object helpers of the page.
+ *
+ * @param names - Dotted paths from the global object (a leading `window.` is
+ *   skipped; a trailing `[Symbol.iterator]` names the iterator)
+ * @returns Function declaration
+ */
+function collectorFunction(names) {
+    const paths = names.map((name) => name
+        .replace(/^window\./, '')
+        .replace(ITERATOR_SUFFIX, `.${ITERATOR_KEY}`)
+        .split('.'));
+    return `function () {
+  const paths = ${JSON.stringify(paths)};
+  const describe = Object.getOwnPropertyDescriptor;
+  const found = [];
+  const add = (i, value) => { found[found.length] = i; found[found.length] = value; };
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    let key = path[path.length - 1];
+    let owner = window;
+    try {
+      for (let j = 0; j < path.length - 1; j++) owner = owner[path[j]];
+    } catch (e) { add(i, undefined); continue; }
+    if (key === '${ITERATOR_KEY}') {
+      try { key = Symbol.iterator; } catch (e) { continue; }
+      if (typeof key !== 'symbol') continue;
+    }
+    let own;
+    try { own = describe(owner, key); } catch (e) { own = undefined; }
+    if (own && (own.get || own.set)) {
+      if (own.get) add(i, own.get);
+      if (own.set) add(i, own.set);
+    } else if (own) {
+      add(i, own.value);
+    } else {
+      try { add(i, owner[key]); } catch (e) { continue; }
+    }
+  }
+  return found;
+}`;
+}
+/**
+ * The built-ins of a list that the page replaced.
+ *
+ * @param cdp - CDP connection (or session) of the page
+ * @param names - Dotted paths, e.g. `Element.prototype.matches`,
+ *   `window.getComputedStyle`, `NodeList.prototype[Symbol.iterator]`
+ * @param objectId - An object of the realm to check (e.g. a frame's eval
+ *   result); default: the page's main world
+ * @returns The replaced ones, in list order (empty when the check failed)
+ */
+export async function findReplacedBuiltins(cdp, names, objectId) {
+    const functionDeclaration = collectorFunction(names);
+    try {
+        const collected = (await (objectId
+            ? cdp.send('Runtime.callFunctionOn', {
+                objectId,
+                functionDeclaration,
+                objectGroup: OBJECT_GROUP,
+            })
+            : cdp.send('Runtime.evaluate', {
+                expression: `(${functionDeclaration})()`,
+                objectGroup: OBJECT_GROUP,
+            })));
+        const listId = collected.result.objectId;
+        if (collected.exceptionDetails || !listId)
+            return [];
+        const { result } = (await cdp.send('Runtime.getProperties', {
+            objectId: listId,
+            ownProperties: true,
+        }));
+        return replacedNames(names, result);
+    }
+    catch (error) {
+        log.debug(`Built-ins not checked: ${getErrorMessage(error)}`);
+        return [];
+    }
+    finally {
+        await cdp
+            .send('Runtime.releaseObjectGroup', { objectGroup: OBJECT_GROUP })
+            .catch((error) => log.debug(`Built-ins not released: ${getErrorMessage(error)}`));
+    }
+}
+/**
+ * Names whose collected function is not native.
+ *
+ * @param names - The names checked
+ * @param properties - Properties of the collected `index, function` list
+ * @returns Replaced names, in list order
+ */
+function replacedNames(names, properties) {
+    const entries = new Map();
+    for (const property of properties) {
+        if (/^\d+$/.test(property.name))
+            entries.set(Number(property.name), property.value);
+    }
+    const replaced = new Set();
+    for (let i = 0; entries.has(i); i += 2) {
+        const index = entries.get(i)?.value;
+        const value = entries.get(i + 1);
+        const native = value?.type === 'function' && NATIVE_FUNCTION.test(value.description ?? '');
+        if (typeof index === 'number' && !native)
+            replaced.add(index);
+    }
+    return names.filter((_name, i) => replaced.has(i));
+}
+//# sourceMappingURL=replacedBuiltins.js.map

package/dist/session/QueryCacheManager.d.ts

@@ -71,8 +71,11 @@ export declare class QueryCacheManager {
      * Store a query result.
      *
      * @param result - Query result whose nodes carry backend node ids
+     * @param document - Identity of the page document queried
+     *   ({@link pageDocumentId}): backend node ids are only meaningful in it, and
+     *   a page in a new renderer process reuses them for other elements
      */
-    set(result: DomQueryResult): Promise<void>;
+    set(result: DomQueryResult, document?: string): Promise<void>;
     /**
      * Read the cache and check that it can be used.
      *

package/dist/session/QueryCacheManager.js

@@ -88,11 +88,14 @@ export class QueryCacheManager {
      * Store a query result.
      *
      * @param result - Query result whose nodes carry backend node ids
+     * @param document - Identity of the page document queried
+     *   ({@link pageDocumentId}): backend node ids are only meaningful in it, and
+     *   a page in a new renderer process reuses them for other elements
      */
-    async set(result) {
+    async set(result, document) {
         try {
             const cachePath = this.getCachePath();
-            await writeFile(cachePath, JSON.stringify({ version: CACHE_VERSION, ...result }), 'utf-8');
+            await writeFile(cachePath, JSON.stringify({ version: CACHE_VERSION, ...result, ...(document && { document }) }), 'utf-8');
             log.debug(`Cached ${result.nodes.length} query results to ${cachePath}`);
         }
         catch (error) {

package/dist/session/chrome.d.ts

@@ -41,8 +41,11 @@ export declare function readChromePid(): number | null;
  * Remove Chrome PID from persistent cache.
  *
  * Safe to call multiple times (idempotent).
+ *
+ * @param expectedPid - Remove it only while it still names this Chrome (a
+ *   daemon clearing its own, which another daemon may have replaced)
  */
-export declare function clearChromePid(): void;
+export declare function clearChromePid(expectedPid?: number): void;
 /** What `status --verbose` shows about the session's Chrome */
 export interface RunningChromeInfo {
     /** Executable the process was started from */

package/dist/session/chrome.js

@@ -10,6 +10,7 @@ import { AtomicFileWriter } from '../utils/atomicFile.js';
 import { getErrorMessage } from '../utils/errors.js';
 import { getProcessCommand, isProcessAlive } from '../utils/process.js';
 import { getSessionFilePath, ensureSessionDir } from './paths.js';
+import { readPidFromFile } from './pid.js';
 const log = createLogger('chrome');
 /**
  * Parse Chrome PID from cache file content.
@@ -100,9 +101,14 @@ export function readChromePid() {
  * Remove Chrome PID from persistent cache.
  *
  * Safe to call multiple times (idempotent).
+ *
+ * @param expectedPid - Remove it only while it still names this Chrome (a
+ *   daemon clearing its own, which another daemon may have replaced)
  */
-export function clearChromePid() {
+export function clearChromePid(expectedPid) {
     const cachePath = getSessionFilePath('CHROME_PID');
+    if (expectedPid !== undefined && readPidFromFile(cachePath) !== expectedPid)
+        return;
     try {
         fs.rmSync(cachePath, { force: true });
     }

package/dist/session/cleanup/staleSession.d.ts

@@ -9,9 +9,13 @@
 /**
  * Remove per-session files (metadata, query cache).
  *
- * Called by the daemon when its session ends, and by `bdg cleanup`.
+ * Called by the daemon when its session ends, and by `bdg cleanup`. A daemon
+ * passes its PID, so it never removes the files of another daemon that
+ * started in the same directory meanwhile.
+ *
+ * @param ownerPid - The daemon whose files these must be; omitted by cleanup
  */
-export declare function removeSessionFiles(): void;
+export declare function removeSessionFiles(ownerPid?: number): void;
 /**
  * Remove daemon and session files if no daemon is listening.
  *
@@ -43,8 +47,21 @@ export declare function isSessionChrome(pid: number, sessionDir: string): boolea
  */
 export declare function killOrphanedChrome(): boolean;
 /**
- * Kill an orphaned Chrome (see {@link killOrphanedChrome}) and wait until it
- * has exited, so its debugging port is free for the next launch.
+ * Kill every Chrome launched for a session directory (its marker flag on the
+ * command line), whatever chrome.pid says: a Chrome whose PID file another
+ * daemon removed, or that a second start left behind, is found too. Only
+ * browser processes are signalled; their helper processes exit with them.
+ *
+ * @param sessionDir - Session directory
+ * @returns PIDs of the processes killed
+ */
+export declare function killSessionChromes(sessionDir?: string): number[];
+/**
+ * Kill the Chromes this session left behind and wait until they have exited,
+ * so their profile and debugging port are free for the next launch. The
+ * Chrome recorded in chrome.pid is killed (see {@link killOrphanedChrome});
+ * without a record (chrome.pid lost with its daemon), every Chrome carrying
+ * the session's marker is, unless another daemon of the session still runs.
  *
  * @returns True if a Chrome process was killed
  */

package/dist/session/cleanup/staleSession.js

@@ -10,13 +10,14 @@ import { chromeSessionMarkerFlag } from '../../connection/launcher/flagsBuilder.
 import { QueryCacheManager } from '../QueryCacheManager.js';
 import { clearChromePid, readChromePid } from '../chrome.js';
 import { probeDaemonSocket } from '../daemonSocket.js';
+import { readSessionMetadata } from '../metadata.js';
 import { getSessionDir, getSessionFilePath, sessionFilePathIn } from '../paths.js';
 import { readPidFromFile } from '../pid.js';
 import { createLogger, logDebugError } from '../../ui/logging/index.js';
 import { delay } from '../../utils/async.js';
 import { safeRemoveFile } from '../../utils/file.js';
 import { DAEMON_SCRIPT_PATH } from '../../utils/packageRoot.js';
-import { getProcessCommand, isProcessAlive, killChromeProcess } from '../../utils/process.js';
+import { getProcessCommand, isProcessAlive, killChromeProcess, listProcesses, } from '../../utils/process.js';
 const log = createLogger('cleanup');
 /**
  * Check whether a process command line contains an exact argument.
@@ -30,12 +31,39 @@ function hasArgument(command, arg) {
         return false;
     return command.includes(`${arg} `) || command.endsWith(arg);
 }
+/**
+ * Check whether a command line contains an exact argument, followed by the
+ * end or by another option: a session directory with a space in it
+ * (`/tmp/a b`) does not match the marker of `/tmp/a`.
+ *
+ * @param command - Full command line
+ * @param arg - Argument to look for
+ * @returns True if `arg` appears as a whole argument
+ */
+function hasWholeArgument(command, arg) {
+    for (let at = command.indexOf(arg); at !== -1; at = command.indexOf(arg, at + 1)) {
+        const before = at === 0 || command[at - 1] === ' ';
+        const rest = command.slice(at + arg.length);
+        if (before && (rest === '' || rest.startsWith(' -')))
+            return true;
+    }
+    return false;
+}
 /**
  * Remove per-session files (metadata, query cache).
  *
- * Called by the daemon when its session ends, and by `bdg cleanup`.
+ * Called by the daemon when its session ends, and by `bdg cleanup`. A daemon
+ * passes its PID, so it never removes the files of another daemon that
+ * started in the same directory meanwhile.
+ *
+ * @param ownerPid - The daemon whose files these must be; omitted by cleanup
  */
-export function removeSessionFiles() {
+export function removeSessionFiles(ownerPid) {
+    if (ownerPid !== undefined) {
+        const owner = readSessionMetadata()?.bdgPid;
+        if (owner !== undefined && owner !== ownerPid)
+            return;
+    }
     safeRemoveFile(getSessionFilePath('METADATA'), 'metadata file', log);
     void QueryCacheManager.getInstance()
         .clear()
@@ -103,22 +131,64 @@ export function killOrphanedChrome() {
     clearChromePid();
     return true;
 }
+/**
+ * Kill every Chrome launched for a session directory (its marker flag on the
+ * command line), whatever chrome.pid says: a Chrome whose PID file another
+ * daemon removed, or that a second start left behind, is found too. Only
+ * browser processes are signalled; their helper processes exit with them.
+ *
+ * @param sessionDir - Session directory
+ * @returns PIDs of the processes killed
+ */
+export function killSessionChromes(sessionDir = getSessionDir()) {
+    const marker = chromeSessionMarkerFlag(sessionDir);
+    const killed = [];
+    for (const { pid, command } of listProcesses()) {
+        if (pid === process.pid || !hasWholeArgument(command, marker) || / --type=/.test(command)) {
+            continue;
+        }
+        try {
+            killChromeProcess(pid, 'SIGKILL');
+            killed.push(pid);
+            log.info(`Killed Chrome of this session (PID ${pid})`);
+        }
+        catch (error) {
+            logDebugError(log, `kill Chrome ${pid}`, error);
+        }
+    }
+    if (killed.length > 0)
+        clearChromePid();
+    return killed;
+}
 /** How long to wait for a killed orphaned Chrome to exit (and free its port) */
 const ORPHAN_EXIT_WAIT_MS = 5000;
 /**
- * Kill an orphaned Chrome (see {@link killOrphanedChrome}) and wait until it
- * has exited, so its debugging port is free for the next launch.
+ * Kill the Chromes this session left behind and wait until they have exited,
+ * so their profile and debugging port are free for the next launch. The
+ * Chrome recorded in chrome.pid is killed (see {@link killOrphanedChrome});
+ * without a record (chrome.pid lost with its daemon), every Chrome carrying
+ * the session's marker is, unless another daemon of the session still runs.
  *
  * @returns True if a Chrome process was killed
  */
 export async function reapOrphanedChrome() {
     const chromePid = findOrphanedChrome();
-    if (!killOrphanedChrome() || chromePid === null)
-        return false;
+    const killed = chromePid !== null ? (killOrphanedChrome() ? [chromePid] : []) : killUnrecordedChromes();
     const deadline = Date.now() + ORPHAN_EXIT_WAIT_MS;
-    while (isProcessAlive(chromePid) && Date.now() < deadline)
+    while (killed.some(isProcessAlive) && Date.now() < deadline)
         await delay(50);
-    return true;
+    return killed.length > 0;
+}
+/**
+ * Kill the session's Chromes found by their marker (see
+ * {@link killSessionChromes}), unless a daemon of the session other than
+ * this process still runs: they could be its Chrome.
+ *
+ * @returns PIDs of the processes killed
+ */
+function killUnrecordedChromes() {
+    const daemonPid = readLiveDaemonPid();
+    return daemonPid === null || daemonPid === process.pid ? killSessionChromes() : [];
 }
 /**
  * Read the PID of a live bdg daemon from daemon.pid.

package/dist/session/cleanup/userCommands.d.ts

@@ -27,7 +27,10 @@ export interface SessionCleanupResult {
  *
  * With `force`, a live daemon is killed first (after verifying its command
  * line). Then stale daemon files are removed and an orphaned bdg Chrome, if
- * any, is killed.
+ * any, is killed, and, once no daemon of the session runs, every other
+ * Chrome launched for this session directory (one chrome.pid lost track of).
+ * The record of a session that ended without `bdg stop` is removed too, and
+ * counts as cleaned session files.
  *
  * @param options - Cleanup options
  * @returns What was cleaned, plus warnings

package/dist/session/cleanup/userCommands.js

@@ -2,7 +2,7 @@
  * Cleanup behind the user-facing `bdg cleanup` command.
  */
 import * as fs from 'fs';
-import { killOrphanedChrome, readLiveDaemonPid, removeStaleDaemonFiles, } from './staleSession.js';
+import { killOrphanedChrome, killSessionChromes, readLiveDaemonPid, removeStaleDaemonFiles, } from './staleSession.js';
 import { isDaemonAlive } from '../daemonSocket.js';
 import { clearLastSessionEnd } from '../lastSession.js';
 import { SESSION_STATE_FILES, getSessionFilePath } from '../paths.js';
@@ -15,7 +15,10 @@ const DAEMON_EXIT_WAIT_MS = 2000;
  *
  * With `force`, a live daemon is killed first (after verifying its command
  * line). Then stale daemon files are removed and an orphaned bdg Chrome, if
- * any, is killed.
+ * any, is killed, and, once no daemon of the session runs, every other
+ * Chrome launched for this session directory (one chrome.pid lost track of).
+ * The record of a session that ended without `bdg stop` is removed too, and
+ * counts as cleaned session files.
  *
  * @param options - Cleanup options
  * @returns What was cleaned, plus warnings
@@ -25,13 +28,15 @@ export async function performSessionCleanup(options) {
     const filesBefore = countSessionFiles();
     const daemonKilled = options.force ? await killLiveDaemon(warnings) : false;
     const session = await removeStaleDaemonFiles();
-    const chrome = killOrphanedChrome();
+    const orphan = killOrphanedChrome();
+    const unrecorded = readLiveDaemonPid() === null ? killSessionChromes() : [];
+    const chrome = orphan || unrecorded.length > 0;
     const output = options.removeOutput ? removeOutputFile(warnings) : false;
     const filesRemoved = countSessionFiles() < filesBefore;
-    clearLastSessionEnd();
+    const endedRecordRemoved = clearLastSessionEnd();
     return {
         cleaned: {
-            session: session || daemonKilled || filesRemoved,
+            session: session || daemonKilled || filesRemoved || endedRecordRemoved,
             chrome,
             daemons: daemonKilled,
             output,

package/dist/session/daemonSocket.d.ts

@@ -22,4 +22,14 @@ export declare function probeDaemonSocket(socketPath?: string, timeoutMs?: numbe
  * @returns True if the daemon socket accepts a connection
  */
 export declare function isDaemonAlive(): Promise<boolean>;
+/**
+ * Whether the daemon socket certainly cannot be reached: there is no socket
+ * file, or connecting is refused. A daemon that is only slow to accept (busy,
+ * a timeout) does not count, so it is never taken for a dead one.
+ *
+ * @param socketPath - Socket path (defaults to the session's daemon socket)
+ * @param timeoutMs - Connection timeout
+ * @returns True when the socket is missing or refuses connections
+ */
+export declare function isDaemonSocketGone(socketPath?: string, timeoutMs?: number): Promise<boolean>;
 //# sourceMappingURL=daemonSocket.d.ts.map

package/dist/session/daemonSocket.js

@@ -37,4 +37,26 @@ export function probeDaemonSocket(socketPath = getSessionFilePath('DAEMON_SOCKET
 export async function isDaemonAlive() {
     return (await probeDaemonSocket()) === 'alive';
 }
+/**
+ * Whether the daemon socket certainly cannot be reached: there is no socket
+ * file, or connecting is refused. A daemon that is only slow to accept (busy,
+ * a timeout) does not count, so it is never taken for a dead one.
+ *
+ * @param socketPath - Socket path (defaults to the session's daemon socket)
+ * @param timeoutMs - Connection timeout
+ * @returns True when the socket is missing or refuses connections
+ */
+export function isDaemonSocketGone(socketPath = getSessionFilePath('DAEMON_SOCKET'), timeoutMs = PROBE_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection(socketPath);
+        const finish = (gone) => {
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(gone);
+        };
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        socket.once('connect', () => finish(false));
+        socket.once('error', (error) => finish(error.code === 'ENOENT' || error.code === 'ECONNREFUSED'));
+    });
+}
 //# sourceMappingURL=daemonSocket.js.map

package/dist/session/lastSession.d.ts

@@ -18,12 +18,15 @@ export interface LastSessionEnd {
 export declare function writeLastSessionEnd(reason: UnexpectedEndReason): void;
 /**
  * Forget the last session's end (a new session is starting, or `cleanup` ran).
+ *
+ * @returns True if there was a record to remove
  */
-export declare function clearLastSessionEnd(): void;
+export declare function clearLastSessionEnd(): boolean;
 /**
- * How the last session ended, if it ended unexpectedly.
+ * How the last session of a directory ended, if it ended unexpectedly.
  *
+ * @param dir - Session directory (default: the selected session's)
  * @returns The record, or null
  */
-export declare function readLastSessionEnd(): LastSessionEnd | null;
+export declare function readLastSessionEnd(dir?: string): LastSessionEnd | null;
 //# sourceMappingURL=lastSession.d.ts.map

package/dist/session/lastSession.js

@@ -3,7 +3,7 @@
  * `bdg status` can explain why there is no session any more.
  */
 import * as fs from 'fs';
-import { getSessionFilePath } from './paths.js';
+import { getSessionDir, getSessionFilePath, sessionFilePathIn } from './paths.js';
 import { createLogger } from '../ui/logging/index.js';
 import { AtomicFileWriter } from '../utils/atomicFile.js';
 import { getErrorMessage } from '../utils/errors.js';
@@ -23,18 +23,24 @@ export function writeLastSessionEnd(reason) {
 }
 /**
  * Forget the last session's end (a new session is starting, or `cleanup` ran).
+ *
+ * @returns True if there was a record to remove
  */
 export function clearLastSessionEnd() {
-    fs.rmSync(getSessionFilePath('LAST_SESSION'), { force: true });
+    const file = getSessionFilePath('LAST_SESSION');
+    const existed = fs.existsSync(file);
+    fs.rmSync(file, { force: true });
+    return existed;
 }
 /**
- * How the last session ended, if it ended unexpectedly.
+ * How the last session of a directory ended, if it ended unexpectedly.
  *
+ * @param dir - Session directory (default: the selected session's)
  * @returns The record, or null
  */
-export function readLastSessionEnd() {
+export function readLastSessionEnd(dir = getSessionDir()) {
     try {
-        const data = JSON.parse(fs.readFileSync(getSessionFilePath('LAST_SESSION'), 'utf8'));
+        const data = JSON.parse(fs.readFileSync(sessionFilePathIn(dir, 'LAST_SESSION'), 'utf8'));
         return typeof data.endedAt === 'number' ? data : null;
     }
     catch (error) {

package/dist/session/paths.d.ts

@@ -124,8 +124,10 @@ export declare function getDaemonSocketPath(): string;
  * Ensure the session directory exists.
  *
  * Creates ~/.bdg/ if it doesn't exist. Safe to call multiple times (idempotent).
+ * A path that cannot hold a directory is refused before `mkdir`, which
+ * would spin on a pseudo-filesystem ({@link makeDirectory}).
  *
- * @throws Error if directory creation fails due to permissions
+ * @throws Error if the directory cannot be created
  */
 export declare function ensureSessionDir(): void;
 export {};

package/dist/session/paths.js

@@ -9,6 +9,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { createLogger, logDebugError } from '../ui/logging/index.js';
+import { makeDirectory } from '../utils/directories.js';
 const log = createLogger('session');
 /**
  * Session file paths relative to ~/.bdg/
@@ -166,13 +167,12 @@ export function getDaemonSocketPath() {
  * Ensure the session directory exists.
  *
  * Creates ~/.bdg/ if it doesn't exist. Safe to call multiple times (idempotent).
+ * A path that cannot hold a directory is refused before `mkdir`, which
+ * would spin on a pseudo-filesystem ({@link makeDirectory}).
  *
- * @throws Error if directory creation fails due to permissions
+ * @throws Error if the directory cannot be created
  */
 export function ensureSessionDir() {
-    const dir = getSessionDir();
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
+    makeDirectory(getSessionDir());
 }
 //# sourceMappingURL=paths.js.map

package/dist/session/portClaims.js

@@ -20,6 +20,7 @@ import * as path from 'path';
 import { getSessionBaseDir, getSessionDir, listSessionDirs, sessionFilePathIn, } from './paths.js';
 import { createLogger, logDebugError } from '../ui/logging/index.js';
 import { delay } from '../utils/async.js';
+import { makeDirectory } from '../utils/directories.js';
 const log = createLogger('session');
 /** Lock file guarding port selection, in the port registry (or base session) directory */
 const PORT_LOCK_FILE = 'port.lock';
@@ -93,8 +94,8 @@ function trustedRegistryDir(create) {
     const dir = getPortRegistryDir();
     try {
         if (create) {
-            fs.mkdirSync(path.dirname(dir), { recursive: true });
-            fs.mkdirSync(path.join(dir, CLAIMS_DIR), { recursive: true, mode: 0o700 });
+            makeDirectory(path.dirname(dir));
+            makeDirectory(path.join(dir, CLAIMS_DIR), 0o700);
         }
         if (!fs.existsSync(dir))
             return null;
@@ -266,7 +267,7 @@ function releaseLock(lockPath, token) {
 export async function withPortLock(select) {
     const registryDir = trustedRegistryDir(true);
     const lockDir = registryDir ?? getSessionBaseDir();
-    fs.mkdirSync(lockDir, { recursive: true });
+    makeDirectory(lockDir);
     const lockPath = path.join(lockDir, PORT_LOCK_FILE);
     const token = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
     const locked = await acquireLock(lockPath, token);