@browserbridge/bbx 1.9.0 → 1.10.0

package/packages/native-host/src/daemon.js

@@ -24,12 +24,10 @@ import {
   DAEMON_RECENT_LOG_LIMIT,
   DEFAULT_DAEMON_PENDING_TIMEOUT_MS,
   DEFAULT_LOG_TAIL_LIMIT,
-  DOM_BASELINE_TTL_MS,
   ERROR_CODES,
   getProtocolVersion,
   getSupportedProtocolVersions,
   MAX_DAEMON_PENDING_TIMEOUT_MS,
-  MAX_DOM_BASELINES_GLOBAL,
   parseJsonLines,
   RecoveryTelemetryCollector,
   normalizeRecoveryTelemetrySummary,
@@ -48,6 +46,7 @@ import {
 import { ArtifactStore } from './artifact-store.js';
 import { bridgeAuthTokensEqual, ensureBridgeAuthToken, readBridgeAuthToken } from './auth-token.js';
 import { normalizeDaemonLogger } from './daemon-logger.js';
+import { DomBaselineOwnerRegistry, isValidBaselineId } from './dom-baseline-owners.js';
 import { writeJsonLine } from './framing.js';
 
 const DAEMON_VERSION = loadDaemonVersion();
@@ -440,10 +439,10 @@ export class BridgeDaemon {
     this.authToken = authToken;
     this.artifactStore = artifactStore;
     this.artifactStoreInitialized = false;
-    /** @type {Map<string, { socket: ClientSocket, expiresAt: number }>} */
-    this.domBaselineOwners = new Map();
-    /** @type {Map<string, { socket: ClientSocket, expiresAt: number }>} */
-    this.abandonedDomBaselineCreates = new Map();
+    this.domBaselines = new DomBaselineOwnerRegistry({
+      isCurrentExtensionSocket: (socket) =>
+        this.extensionSockets.get(socket.__extensionId ?? '') === socket,
+    });
     this.recoveryTelemetry = new RecoveryTelemetryCollector();
   }
 
@@ -765,8 +764,7 @@ export class BridgeDaemon {
     }
     this.extensionSockets.clear();
     this.invalidateConnectedExtensionsCache();
-    this.domBaselineOwners.clear();
-    this.abandonedDomBaselineCreates.clear();
+    this.domBaselines.clear();
     if (this.artifactStoreInitialized) {
       this.artifactStore.reset();
       this.artifactStoreInitialized = false;
@@ -998,7 +996,7 @@ export class BridgeDaemon {
     }
 
     if (request.method === 'daemon.metrics') {
-      this.pruneDomBaselineOwners();
+      this.domBaselines.prune();
       const now = Date.now();
       const uptimeMs = this.startedAt > 0 ? now - this.startedAt : 0;
       const avgResponseTimeMs =
@@ -1013,7 +1011,7 @@ export class BridgeDaemon {
         requestsProcessed: this.requestsProcessed,
         requestsFailed: this.requestsFailed,
         avgResponseTimeMs,
-        domBaselineOwners: this.domBaselineOwners.size,
+        domBaselineOwners: this.domBaselines.size,
         recovery: this.recoveryTelemetry.snapshot('daemon'),
       });
       await writeJsonLine(socket, { type: 'agent.response', response });
@@ -1123,7 +1121,7 @@ export class BridgeDaemon {
       request.method === 'dom.baseline.compare' ||
       request.method === 'dom.baseline.describe' ||
       request.method === 'dom.baseline.release';
-    const baselineOwner = usesBaselineOwner ? this.getDomBaselineOwner(baselineId ?? '') : null;
+    const baselineOwner = usesBaselineOwner ? this.domBaselines.get(baselineId ?? '') : null;
     const target = usesBaselineOwner
       ? baselineOwner &&
         (!targetBrowser || baselineOwner.__browserName === targetBrowser) &&
@@ -1173,7 +1171,7 @@ export class BridgeDaemon {
       timeoutId: setTimeout(() => {
         const pending = this.pendingRequests.get(request.id);
         if (!pending) return;
-        this.markAbandonedDomBaselineCreate(request.id, pending);
+        this.domBaselines.markAbandonedCreate(request.id, pending);
         this.clearPendingRequest(request.id, pending);
         this.recordRequestCompletion(request.id, false, pending);
         const response = createFailure(
@@ -1272,85 +1270,6 @@ export class BridgeDaemon {
     return candidates[0]?.[1] ?? null;
   }
 
-  /** @param {string} baselineId */
-  getDomBaselineOwner(baselineId) {
-    this.pruneDomBaselineOwners();
-    const owner = this.domBaselineOwners.get(baselineId);
-    if (!owner || !owner.socket.__extensionId || !owner.socket.__accessEnabled) return null;
-    if (this.extensionSockets.get(owner.socket.__extensionId) !== owner.socket) {
-      this.domBaselineOwners.delete(baselineId);
-      return null;
-    }
-    return owner.socket;
-  }
-
-  /** @param {string} baselineId @param {ClientSocket} socket @param {unknown} expiresAt */
-  registerDomBaselineOwner(baselineId, socket, expiresAt) {
-    this.pruneDomBaselineOwners();
-    const parsedExpiry = typeof expiresAt === 'string' ? Date.parse(expiresAt) : Number.NaN;
-    const now = Date.now();
-    if (
-      !/^baseline_[A-Za-z0-9_-]{32,64}$/u.test(baselineId) ||
-      !socket.__extensionId ||
-      !Number.isFinite(parsedExpiry) ||
-      parsedExpiry <= now ||
-      parsedExpiry > now + DOM_BASELINE_TTL_MS + 10_000
-    ) {
-      return false;
-    }
-    const existing = this.domBaselineOwners.get(baselineId);
-    if (existing && existing.socket !== socket) return false;
-    const maxOwnerMappings = MAX_DOM_BASELINES_GLOBAL * 4;
-    while (
-      !existing &&
-      [...this.domBaselineOwners.values()].filter((owner) => owner.socket === socket).length >=
-        maxOwnerMappings
-    ) {
-      const oldest = [...this.domBaselineOwners].find(([, owner]) => owner.socket === socket);
-      if (!oldest) break;
-      this.domBaselineOwners.delete(oldest[0]);
-    }
-    this.domBaselineOwners.set(baselineId, { socket, expiresAt: parsedExpiry });
-    return true;
-  }
-
-  pruneDomBaselineOwners() {
-    const now = Date.now();
-    for (const [baselineId, owner] of this.domBaselineOwners) {
-      if (owner.expiresAt <= now) this.domBaselineOwners.delete(baselineId);
-    }
-  }
-
-  /** @param {ClientSocket} socket */
-  clearDomBaselineOwnersForSocket(socket) {
-    for (const [baselineId, owner] of this.domBaselineOwners) {
-      if (owner.socket === socket) this.domBaselineOwners.delete(baselineId);
-    }
-    for (const [requestId, abandoned] of this.abandonedDomBaselineCreates) {
-      if (abandoned.socket === socket) this.abandonedDomBaselineCreates.delete(requestId);
-    }
-  }
-
-  /** @param {string} requestId @param {PendingEntry} pending */
-  markAbandonedDomBaselineCreate(requestId, pending) {
-    if (pending.method !== 'dom.baseline.create') return;
-    const target = pending.targets.values().next().value;
-    if (!target) return;
-    const now = Date.now();
-    for (const [id, entry] of this.abandonedDomBaselineCreates) {
-      if (entry.expiresAt <= now) this.abandonedDomBaselineCreates.delete(id);
-    }
-    this.abandonedDomBaselineCreates.set(requestId, {
-      socket: target,
-      expiresAt: now + DOM_BASELINE_TTL_MS,
-    });
-    while (this.abandonedDomBaselineCreates.size > MAX_DOM_BASELINES_GLOBAL * 4) {
-      const oldestId = this.abandonedDomBaselineCreates.keys().next().value;
-      if (typeof oldestId !== 'string') break;
-      this.abandonedDomBaselineCreates.delete(oldestId);
-    }
-  }
-
   /**
    * @param {ClientSocket} socket
    * @param {import('../../protocol/src/types.js').BridgeResponse} response
@@ -1361,7 +1280,7 @@ export class BridgeDaemon {
         ? /** @type {Record<string, unknown>} */ (response.result)
         : {};
     const baselineId = typeof result.baselineId === 'string' ? result.baselineId : '';
-    if (!/^baseline_[A-Za-z0-9_-]{32,64}$/u.test(baselineId)) return;
+    if (!isValidBaselineId(baselineId)) return;
     const scope =
       result.scope && typeof result.scope === 'object'
         ? /** @type {Record<string, unknown>} */ (result.scope)
@@ -1455,7 +1374,7 @@ export class BridgeDaemon {
     const accessEnabled = Boolean(message.accessEnabled);
     if (!accessEnabled && socket.__extensionId) {
       this.artifactStore.deleteByExtension(socket.__extensionId);
-      this.clearDomBaselineOwnersForSocket(socket);
+      this.domBaselines.clearForSocket(socket);
     }
     if (socket.__accessEnabled !== accessEnabled) {
       socket.__accessEnabled = accessEnabled;
@@ -1558,9 +1477,7 @@ export class BridgeDaemon {
 
     const pending = this.pendingRequests.get(responseMessage.id);
     if (!pending) {
-      const abandoned = this.abandonedDomBaselineCreates.get(responseMessage.id);
-      if (abandoned?.socket === socket) {
-        this.abandonedDomBaselineCreates.delete(responseMessage.id);
+      if (this.domBaselines.takeAbandonedCreate(responseMessage.id, socket)) {
         if (responseMessage.ok) {
           await this.releaseOrphanDomBaseline(socket, responseMessage).catch((error) => {
             this.logger.error('orphan DOM baseline release failed', {
@@ -1618,13 +1535,10 @@ export class BridgeDaemon {
         const evicted = Array.isArray(result.evicted) ? result.evicted : [];
         for (const item of evicted) {
           if (item && typeof item === 'object' && 'baselineId' in item) {
-            const evictedId = String(item.baselineId);
-            if (this.domBaselineOwners.get(evictedId)?.socket === socket) {
-              this.domBaselineOwners.delete(evictedId);
-            }
+            this.domBaselines.deleteIfOwnedBy(String(item.baselineId), socket);
           }
         }
-        if (!this.registerDomBaselineOwner(baselineId, socket, result.expiresAt)) {
+        if (!this.domBaselines.register(baselineId, socket, result.expiresAt)) {
           await this.releaseOrphanDomBaseline(socket, responseMessage);
           pending.lastErrorResponse = createFailure(
             responseMessage.id,
@@ -1637,7 +1551,7 @@ export class BridgeDaemon {
           return;
         }
       } else if (pending.method === 'dom.baseline.release' && pending.baselineId) {
-        this.domBaselineOwners.delete(pending.baselineId);
+        this.domBaselines.delete(pending.baselineId);
       }
       const response =
         pending.method === 'health.ping'
@@ -1674,7 +1588,7 @@ export class BridgeDaemon {
         if (pending.method === 'dom.baseline.create') {
           const baselineId =
             result && typeof result.baselineId === 'string' ? result.baselineId : null;
-          if (baselineId) this.domBaselineOwners.delete(baselineId);
+          if (baselineId) this.domBaselines.delete(baselineId);
           await this.releaseOrphanDomBaseline(socket, responseMessage).catch(() => {});
         }
         this.clearPendingRequest(responseMessage.id, pending);
@@ -1695,7 +1609,7 @@ export class BridgeDaemon {
 
     // A routed request has one target, so its error is final.
     if (pending.baselineId && responseMessage.error?.code === ERROR_CODES.DOM_BASELINE_NOT_FOUND) {
-      this.domBaselineOwners.delete(pending.baselineId);
+      this.domBaselines.delete(pending.baselineId);
     }
     pending.lastErrorResponse = responseMessage;
 
@@ -1709,7 +1623,7 @@ export class BridgeDaemon {
   handleSocketClose(socket) {
     if (socket.__extensionId) {
       this.artifactStore.deleteByExtension(socket.__extensionId);
-      this.clearDomBaselineOwnersForSocket(socket);
+      this.domBaselines.clearForSocket(socket);
       this.logger.info('extension disconnected', { extensionId: socket.__extensionId });
       if (this.extensionSockets.get(socket.__extensionId) === socket) {
         this.extensionSockets.delete(socket.__extensionId);
@@ -1731,7 +1645,7 @@ export class BridgeDaemon {
         if (!pending) {
           continue;
         }
-        this.markAbandonedDomBaselineCreate(id, pending);
+        this.domBaselines.markAbandonedCreate(id, pending);
         this.clearPendingRequest(id, pending);
         this.recordRequestCompletion(id, false, pending);
       }

package/packages/native-host/src/dom-baseline-owners.js

@@ -0,0 +1,210 @@
+// @ts-check
+
+import { DOM_BASELINE_TTL_MS, MAX_DOM_BASELINES_GLOBAL } from '../../protocol/src/index.js';
+
+/**
+ * Ownership bookkeeping for retained semantic DOM baselines.
+ *
+ * A baseline lives in the extension's memory, but the daemon has to know which
+ * extension socket owns it so a later `compare`/`describe`/`release` is routed
+ * back to the same document, and so the state is dropped when that socket goes
+ * away. This module owns only that mapping and its expiry rules; sending the
+ * release request over the wire stays with the daemon, which owns transport.
+ *
+ * @typedef {import('./daemon.js').ClientSocket} ClientSocket
+ * @typedef {{ socket: ClientSocket, expiresAt: number }} BaselineOwner
+ */
+
+/**
+ * Baseline IDs are minted by the extension. The daemon re-validates the shape
+ * before trusting one as a map key so a malformed response cannot grow state.
+ */
+const BASELINE_ID_PATTERN = /^baseline_[A-Za-z0-9_-]{32,64}$/u;
+
+/**
+ * Expiry timestamps are allowed a small skew over the nominal TTL to absorb
+ * clock jitter between the extension and the daemon.
+ */
+const EXPIRY_SKEW_MS = 10_000;
+
+/** Cap on tracked mappings per socket, and on abandoned-create entries. */
+const MAX_OWNER_MAPPINGS = MAX_DOM_BASELINES_GLOBAL * 4;
+
+/**
+ * @param {unknown} baselineId
+ * @returns {boolean}
+ */
+export function isValidBaselineId(baselineId) {
+  return typeof baselineId === 'string' && BASELINE_ID_PATTERN.test(baselineId);
+}
+
+export class DomBaselineOwnerRegistry {
+  /**
+   * @param {{ isCurrentExtensionSocket: (socket: ClientSocket) => boolean }} options
+   */
+  constructor({ isCurrentExtensionSocket }) {
+    /** @type {Map<string, BaselineOwner>} */
+    this.owners = new Map();
+    /**
+     * Creates whose agent went away before the extension replied. The response
+     * still arrives later, and the baseline it reports has to be released.
+     * @type {Map<string, BaselineOwner>}
+     */
+    this.abandonedCreates = new Map();
+    this.isCurrentExtensionSocket = isCurrentExtensionSocket;
+  }
+
+  /** @returns {number} */
+  get size() {
+    return this.owners.size;
+  }
+
+  /** Drop every mapping whose TTL has passed. */
+  prune() {
+    const now = Date.now();
+    for (const [baselineId, owner] of this.owners) {
+      if (owner.expiresAt <= now) this.owners.delete(baselineId);
+    }
+  }
+
+  /**
+   * Resolve the socket that owns a baseline, or null when the owner is gone,
+   * has lost access, or has been replaced by a newer socket for the same
+   * extension.
+   *
+   * @param {string} baselineId
+   * @returns {ClientSocket | null}
+   */
+  get(baselineId) {
+    this.prune();
+    const owner = this.owners.get(baselineId);
+    if (!owner || !owner.socket.__extensionId || !owner.socket.__accessEnabled) return null;
+    if (!this.isCurrentExtensionSocket(owner.socket)) {
+      this.owners.delete(baselineId);
+      return null;
+    }
+    return owner.socket;
+  }
+
+  /**
+   * Record ownership for a freshly created baseline.
+   *
+   * Returns false when the reported ID or expiry is unusable, or when another
+   * socket already claims the ID; the caller releases the orphan in that case.
+   *
+   * @param {string} baselineId
+   * @param {ClientSocket} socket
+   * @param {unknown} expiresAt
+   * @returns {boolean}
+   */
+  register(baselineId, socket, expiresAt) {
+    this.prune();
+    const parsedExpiry = typeof expiresAt === 'string' ? Date.parse(expiresAt) : Number.NaN;
+    const now = Date.now();
+    if (
+      !isValidBaselineId(baselineId) ||
+      !socket.__extensionId ||
+      !Number.isFinite(parsedExpiry) ||
+      parsedExpiry <= now ||
+      parsedExpiry > now + DOM_BASELINE_TTL_MS + EXPIRY_SKEW_MS
+    ) {
+      return false;
+    }
+    const existing = this.owners.get(baselineId);
+    if (existing && existing.socket !== socket) return false;
+    while (
+      !existing &&
+      [...this.owners.values()].filter((owner) => owner.socket === socket).length >=
+        MAX_OWNER_MAPPINGS
+    ) {
+      const oldest = [...this.owners].find(([, owner]) => owner.socket === socket);
+      if (!oldest) break;
+      this.owners.delete(oldest[0]);
+    }
+    this.owners.set(baselineId, { socket, expiresAt: parsedExpiry });
+    return true;
+  }
+
+  /**
+   * @param {string} baselineId
+   * @returns {boolean}
+   */
+  delete(baselineId) {
+    return this.owners.delete(baselineId);
+  }
+
+  /**
+   * Drop a mapping only when the given socket still owns it, so one extension
+   * cannot evict another's baseline by reporting its ID.
+   *
+   * @param {string} baselineId
+   * @param {ClientSocket} socket
+   * @returns {boolean}
+   */
+  deleteIfOwnedBy(baselineId, socket) {
+    if (this.owners.get(baselineId)?.socket !== socket) return false;
+    return this.owners.delete(baselineId);
+  }
+
+  /**
+   * Forget every baseline and abandoned create belonging to a socket.
+   *
+   * @param {ClientSocket} socket
+   */
+  clearForSocket(socket) {
+    for (const [baselineId, owner] of this.owners) {
+      if (owner.socket === socket) this.owners.delete(baselineId);
+    }
+    for (const [requestId, abandoned] of this.abandonedCreates) {
+      if (abandoned.socket === socket) this.abandonedCreates.delete(requestId);
+    }
+  }
+
+  /**
+   * Remember a `dom.baseline.create` whose agent disconnected before the
+   * extension replied, so the eventual response can be released rather than
+   * leaking a retained snapshot in the page.
+   *
+   * @param {string} requestId
+   * @param {{ method?: string, targets: Set<ClientSocket> }} pending
+   */
+  markAbandonedCreate(requestId, pending) {
+    if (pending.method !== 'dom.baseline.create') return;
+    const target = pending.targets.values().next().value;
+    if (!target) return;
+    const now = Date.now();
+    for (const [id, entry] of this.abandonedCreates) {
+      if (entry.expiresAt <= now) this.abandonedCreates.delete(id);
+    }
+    this.abandonedCreates.set(requestId, {
+      socket: target,
+      expiresAt: now + DOM_BASELINE_TTL_MS,
+    });
+    while (this.abandonedCreates.size > MAX_OWNER_MAPPINGS) {
+      const oldestId = this.abandonedCreates.keys().next().value;
+      if (typeof oldestId !== 'string') break;
+      this.abandonedCreates.delete(oldestId);
+    }
+  }
+
+  /**
+   * Claim an abandoned create for the socket that is answering it. Returns
+   * false when the request was not abandoned or belongs to another socket.
+   *
+   * @param {string} requestId
+   * @param {ClientSocket} socket
+   * @returns {boolean}
+   */
+  takeAbandonedCreate(requestId, socket) {
+    const abandoned = this.abandonedCreates.get(requestId);
+    if (abandoned?.socket !== socket) return false;
+    this.abandonedCreates.delete(requestId);
+    return true;
+  }
+
+  /** Drop all tracked state, used on daemon shutdown. */
+  clear() {
+    this.owners.clear();
+    this.abandonedCreates.clear();
+  }
+}

package/packages/native-host/src/native-host.js

@@ -5,7 +5,7 @@ import net from 'node:net';
 import {
   createFailure,
   ERROR_CODES,
-  MAX_JSON_LINE_BYTES,
+  parseJsonLines,
   sanitizeIncidentalText,
 } from '../../protocol/src/index.js';
 import { readBridgeAuthToken } from './auth-token.js';
@@ -170,32 +170,10 @@ export async function runNativeHost({
     ...(authToken ? { authToken } : {}),
   });
 
-  let lineBuffer = '';
-  socket.on('data', (chunk) => {
-    lineBuffer += chunk;
-    if (!lineBuffer.includes('\n') && Buffer.byteLength(lineBuffer, 'utf8') > MAX_JSON_LINE_BYTES) {
-      console.error(`native-host: daemon JSON line exceeded ${MAX_JSON_LINE_BYTES} bytes`);
-      socket.destroy();
-      return;
-    }
-    while (lineBuffer.includes('\n')) {
-      const index = lineBuffer.indexOf('\n');
-      const line = lineBuffer.slice(0, index).trim();
-      lineBuffer = lineBuffer.slice(index + 1);
-      if (!line) {
-        continue;
-      }
-      if (Buffer.byteLength(line, 'utf8') > MAX_JSON_LINE_BYTES) {
-        console.error(`native-host: daemon JSON line exceeded ${MAX_JSON_LINE_BYTES} bytes`);
-        socket.destroy();
-        return;
-      }
-      let message;
-      try {
-        message = JSON.parse(line);
-      } catch {
-        continue;
-      }
+  parseJsonLines(
+    socket,
+    (raw) => {
+      const message = /** @type {Record<string, unknown>} */ (raw);
       void (async () => {
         if (message.type === 'extension.request') {
           await writeNativeMessageQueued(message.request);
@@ -228,8 +206,16 @@ export async function runNativeHost({
           err instanceof Error ? err.message : err
         );
       });
+    },
+    {
+      onProtocolError: (error) => {
+        console.error(`native-host: ${error.message}`);
+      },
+      onInvalidLine: (error) => {
+        console.error(`native-host: ignoring malformed daemon JSON line: ${error.message}`);
+      },
     }
-  });
+  );
 
   createNativeMessageReader(
     process.stdin,