browser-debugger-cli 0.12.0 → 0.13.0

package/dist/runtime/dom/wait.js

@@ -15,6 +15,7 @@ import { invalidSelectorError, waitTimeoutError } from '../../errors/messages.js
 import { isContextLostError } from './evalHelpers.js';
 import { DEEP_QUERY_JS, FILTER_MATCHING_JS, selectorArgsJS } from './targetNode.js';
 import { isWaitConditionMet, needsGoneConfirmation, normalizeWaitText, } from './waitCondition.js';
+import { evaluateInBdgWorld } from '../page/bdgWorld.js';
 import { createLogger } from '../../ui/logging/index.js';
 import { delay, raceTimeout } from '../../utils/async.js';
 import { getErrorMessage } from '../../utils/errors.js';
@@ -157,7 +158,7 @@ async function nextSnapshot(cdp, condition, previous, deadline) {
     const selectorArgs = condition.selector === undefined ? 'null, null' : selectorArgsJS(condition.selector);
     const text = condition.text === undefined ? null : normalizeWaitText(condition.text);
     const args = `${selectorArgs}, ${JSON.stringify(text)}, ${JSON.stringify(previous)}, ${Math.min(remaining, WAIT_SLICE_MS)}`;
-    const evaluated = cdp.send('Runtime.evaluate', {
+    const evaluated = evaluateInBdgWorld(cdp, {
         expression: `(${WAIT_SNAPSHOT_JS})(${args})`,
         awaitPromise: true,
         returnByValue: true,

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

@@ -0,0 +1,57 @@
+/**
+ * bdg's own JavaScript world in the page (a CDP isolated world): it shares
+ * the DOM with the page but has its own built-ins, so a page that replaces
+ * `Element.prototype.querySelectorAll`, `JSON.stringify` or
+ * `Array.prototype.map` (polyfills, old frameworks, anti-bot scripts) cannot
+ * change what bdg's page scripts find or return.
+ *
+ * Only the entry points need the world: `Runtime.evaluate` runs in it with
+ * its `contextId`, and `DOM.resolveNode` hands out objects of it with its
+ * `executionContextId`; `Runtime.callFunctionOn` on such an object runs in
+ * the same world. The world belongs to the top frame (same-origin iframes are
+ * reached through it); a node of another frame, a connection without the
+ * Page domain (a frame-scoped one) or a failure to create it fall back to the
+ * main world, as before.
+ */
+import type { CDPConnection } from '../../connection/cdp.js';
+import type { Protocol } from '../../connection/typed-cdp.js';
+/**
+ * What the world needs of a connection: commands, and events to forget the
+ * world when the page navigates (a sender without events, such as a test
+ * double, runs scripts in the main world)
+ */
+type PageConnection = Pick<CDPConnection, 'send'> & Partial<Pick<CDPConnection, 'on'>>;
+/** Name of bdg's isolated world (shown in DevTools' context selector) */
+export declare const BDG_WORLD_NAME = "bdg";
+/**
+ * `Runtime.evaluate` in bdg's world of the top frame. A call that names its
+ * own context is sent as it is.
+ *
+ * @param cdp - Connection to the page
+ * @param params - Evaluate parameters
+ * @returns Evaluate response
+ */
+export declare function evaluateInBdgWorld(cdp: PageConnection, params: Protocol.Runtime.EvaluateRequest): Promise<Protocol.Runtime.EvaluateResponse>;
+/**
+ * `DOM.resolveNode` into bdg's world of the top frame, so functions called on
+ * the node run there. A node the world cannot use (one of a cross-origin
+ * frame, or one no longer in the page) is resolved in its own frame's main
+ * world, as before.
+ *
+ * @param cdp - Connection to the page
+ * @param params - Resolve parameters
+ * @returns Resolve response
+ */
+export declare function resolveNodeInBdgWorld(cdp: PageConnection, params: Protocol.DOM.ResolveNodeRequest): Promise<Protocol.DOM.ResolveNodeResponse>;
+/**
+ * Send a CDP command for bdg's own scripts: `Runtime.evaluate` and
+ * `DOM.resolveNode` go to bdg's world, other methods as they are.
+ *
+ * @param cdp - Connection to the page
+ * @param method - CDP method
+ * @param params - Its parameters
+ * @returns The command's result
+ */
+export declare function sendForBdgScript(cdp: PageConnection, method: string, params: Record<string, unknown>): Promise<unknown>;
+export {};
+//# sourceMappingURL=bdgWorld.d.ts.map

package/dist/runtime/page/bdgWorld.js

@@ -0,0 +1,180 @@
+/**
+ * bdg's own JavaScript world in the page (a CDP isolated world): it shares
+ * the DOM with the page but has its own built-ins, so a page that replaces
+ * `Element.prototype.querySelectorAll`, `JSON.stringify` or
+ * `Array.prototype.map` (polyfills, old frameworks, anti-bot scripts) cannot
+ * change what bdg's page scripts find or return.
+ *
+ * Only the entry points need the world: `Runtime.evaluate` runs in it with
+ * its `contextId`, and `DOM.resolveNode` hands out objects of it with its
+ * `executionContextId`; `Runtime.callFunctionOn` on such an object runs in
+ * the same world. The world belongs to the top frame (same-origin iframes are
+ * reached through it); a node of another frame, a connection without the
+ * Page domain (a frame-scoped one) or a failure to create it fall back to the
+ * main world, as before.
+ */
+import { createLogger } from '../../ui/logging/index.js';
+import { getErrorMessage } from '../../utils/errors.js';
+const log = createLogger('cdp');
+/** Name of bdg's isolated world (shown in DevTools' context selector) */
+export const BDG_WORLD_NAME = 'bdg';
+/** Errors of a context that is gone (navigation, reload) */
+const CONTEXT_GONE = /Cannot find context with specified id|Execution context was destroyed/;
+/** The world's context id per connection, until the page navigates */
+const worlds = new WeakMap();
+/**
+ * The execution context id of bdg's world in the top frame, created on first
+ * use and forgotten when the top frame navigates or its contexts are cleared.
+ *
+ * @param cdp - Connection to the page
+ * @returns Context id, or null when no world can be made on this connection
+ */
+function worldContext(cdp) {
+    const known = worlds.get(cdp);
+    if (known)
+        return known;
+    const created = createWorld(cdp);
+    worlds.set(cdp, created);
+    return created;
+}
+/**
+ * Create the world in the top frame and forget it when the page changes.
+ *
+ * @param cdp - Connection to the page
+ * @returns Context id, or null when it cannot be created
+ */
+async function createWorld(cdp) {
+    const { on } = cdp;
+    if (!on)
+        return null;
+    try {
+        const { frameTree } = (await cdp.send('Page.getFrameTree'));
+        const { executionContextId } = (await cdp.send('Page.createIsolatedWorld', {
+            frameId: frameTree.frame.id,
+            worldName: BDG_WORLD_NAME,
+            grantUniveralAccess: false,
+        }));
+        const forget = () => {
+            if (worlds.get(cdp) === created)
+                worlds.delete(cdp);
+            stopNavigated();
+            stopCleared();
+        };
+        const created = worlds.get(cdp);
+        const stopNavigated = on.call(cdp, 'Page.frameNavigated', (params) => {
+            if (params.frame.parentId === undefined)
+                forget();
+        });
+        const stopCleared = on.call(cdp, 'Runtime.executionContextsCleared', forget);
+        return executionContextId;
+    }
+    catch (error) {
+        log.debug(`bdg's isolated world not available: ${getErrorMessage(error)}`);
+        worlds.delete(cdp);
+        return null;
+    }
+}
+/**
+ * Send a command with the world's context, once more with a new world when
+ * the context is gone, and in the main world when there is none.
+ *
+ * @param cdp - Connection to the page
+ * @param method - CDP method
+ * @param params - Its parameters
+ * @param withContext - The parameters with the world's context id
+ * @returns The command's result
+ */
+async function sendInWorld(cdp, method, params, withContext) {
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const contextId = await worldContext(cdp);
+        if (contextId === null)
+            break;
+        try {
+            return await cdp.send(method, withContext(contextId));
+        }
+        catch (error) {
+            if (!CONTEXT_GONE.test(getErrorMessage(error)))
+                throw error;
+            worlds.delete(cdp);
+        }
+    }
+    return cdp.send(method, params);
+}
+/**
+ * `Runtime.evaluate` in bdg's world of the top frame. A call that names its
+ * own context is sent as it is.
+ *
+ * @param cdp - Connection to the page
+ * @param params - Evaluate parameters
+ * @returns Evaluate response
+ */
+export async function evaluateInBdgWorld(cdp, params) {
+    if (params.contextId !== undefined || params.uniqueContextId !== undefined) {
+        return (await cdp.send('Runtime.evaluate', { ...params }));
+    }
+    return (await sendInWorld(cdp, 'Runtime.evaluate', { ...params }, (contextId) => ({
+        ...params,
+        contextId,
+    })));
+}
+/**
+ * `DOM.resolveNode` into bdg's world of the top frame, so functions called on
+ * the node run there. A node the world cannot use (one of a cross-origin
+ * frame, or one no longer in the page) is resolved in its own frame's main
+ * world, as before.
+ *
+ * @param cdp - Connection to the page
+ * @param params - Resolve parameters
+ * @returns Resolve response
+ */
+export async function resolveNodeInBdgWorld(cdp, params) {
+    if (params.executionContextId !== undefined) {
+        return (await cdp.send('DOM.resolveNode', { ...params }));
+    }
+    try {
+        const resolved = (await sendInWorld(cdp, 'DOM.resolveNode', { ...params }, (executionContextId) => ({ ...params, executionContextId })));
+        if (await usableInWorld(cdp, resolved.object.objectId))
+            return resolved;
+    }
+    catch (error) {
+        log.debug(`Node resolved in the page's world: ${getErrorMessage(error)}`);
+    }
+    return (await cdp.send('DOM.resolveNode', { ...params }));
+}
+/**
+ * Whether a node resolved into bdg's world can be used there: a node of a
+ * cross-origin frame resolves, but every access to it throws.
+ *
+ * @param cdp - Connection to the page
+ * @param objectId - The node in bdg's world
+ * @returns True when it can be read
+ */
+async function usableInWorld(cdp, objectId) {
+    if (!objectId)
+        return false;
+    const probe = (await cdp.send('Runtime.callFunctionOn', {
+        objectId,
+        functionDeclaration: 'function () { try { return this.isConnected === true; } catch (e) { return false; } }',
+        returnByValue: true,
+    }));
+    return probe.result.value === true;
+}
+/**
+ * Send a CDP command for bdg's own scripts: `Runtime.evaluate` and
+ * `DOM.resolveNode` go to bdg's world, other methods as they are.
+ *
+ * @param cdp - Connection to the page
+ * @param method - CDP method
+ * @param params - Its parameters
+ * @returns The command's result
+ */
+export function sendForBdgScript(cdp, method, params) {
+    if (method === 'Runtime.evaluate') {
+        return evaluateInBdgWorld(cdp, params);
+    }
+    if (method === 'DOM.resolveNode') {
+        return resolveNodeInBdgWorld(cdp, params);
+    }
+    return cdp.send(method, params);
+}
+//# sourceMappingURL=bdgWorld.js.map

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