@browserbridge/bbx 1.0.1 → 1.1.0

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

@@ -29,13 +29,20 @@ import {
   SUPPORTED_VERSIONS,
   validateBridgeRequest,
 } from '../../protocol/src/index.js';
-import { getSocketPath } from './config.js';
+import {
+  createSocketBridgeTransport,
+  formatBridgeTransport,
+  getBridgeListenTarget,
+  getBridgeTransport,
+  getSocketPath,
+} from './config.js';
 import { writeJsonLine } from './framing.js';
 
 /** @typedef {import('../../protocol/src/types.js').BridgeRequest} BridgeRequest */
 /** @typedef {import('../../protocol/src/types.js').SetupInstallParams} SetupInstallParams */
 /** @typedef {import('../../protocol/src/types.js').SetupInstallResult} SetupInstallResult */
 /** @typedef {import('../../protocol/src/types.js').SetupStatus} SetupStatus */
+/** @typedef {import('./config.js').BridgeTransport} BridgeTransport */
 /** @typedef {import('node:net').Socket & { __clientId?: string, __extensionId?: string, __browserName?: string, __profileLabel?: string, __accessEnabled?: boolean, __lastActiveAt?: number }} ClientSocket */
 /** @typedef {{ socket: ClientSocket, timeoutId: NodeJS.Timeout, source?: string, method?: string, targets: Set<ClientSocket>, lastErrorResponse?: import('../../protocol/src/types.js').BridgeResponse }} PendingEntry */
 /**
@@ -88,6 +95,14 @@ function getVersionNegotiationPayload(requestedVersion) {
   };
 }
 
+/**
+ * @param {string} socketPath
+ * @returns {boolean}
+ */
+function isWindowsNamedPipePath(socketPath) {
+  return socketPath.startsWith('\\\\.\\pipe\\');
+}
+
 /**
  * @typedef {{
  *   type?: string,
@@ -109,6 +124,7 @@ function getVersionNegotiationPayload(requestedVersion) {
 export class BridgeDaemon {
   /**
    * @param {{
+   *   transport?: BridgeTransport,
    *   socketPath?: string,
    *   listenOptions?: import('node:net').ListenOptions | null,
    *   setupStatusLoader?: () => Promise<SetupStatus>,
@@ -117,14 +133,17 @@ export class BridgeDaemon {
    * }} [options={}]
    */
   constructor({
-    socketPath = getSocketPath(),
+    transport = getBridgeTransport(),
+    socketPath = undefined,
     listenOptions = null,
     setupStatusLoader = collectSetupStatus,
     setupInstaller = installSetupTarget,
     logger = console,
   } = {}) {
-    this.socketPath = socketPath;
-    this.listenOptions = listenOptions;
+    this.transport = socketPath ? createSocketBridgeTransport(socketPath) : transport;
+    this.socketPath =
+      this.transport.type === 'socket' ? this.transport.socketPath : getSocketPath();
+    this.listenOptions = listenOptions ?? getBridgeListenTarget(this.transport);
     this.setupStatusLoader = setupStatusLoader;
     this.setupInstaller = setupInstaller;
     this.logger = logger;
@@ -138,13 +157,120 @@ export class BridgeDaemon {
     this.agentSockets = new Map();
     /** @type {Map<string, PendingEntry>} */
     this.pendingRequests = new Map();
+    /** @type {Map<ClientSocket, Set<string>>} */
+    this.pendingRequestsByOwnerSocket = new Map();
+    /** @type {Map<ClientSocket, Set<string>>} */
+    this.pendingRequestsByTargetSocket = new Map();
     this.pendingTimeoutMs = DEFAULT_DAEMON_PENDING_TIMEOUT_MS;
     /** @type {Record<string, unknown>[]} */
     this.recentLog = [];
+    /** @type {Array<{ extensionId: string, browserName: string | null, profileLabel: string | null, accessEnabled: boolean }> | null} */
+    this.connectedExtensionsCache = null;
     /** @type {Promise<void> | null} */
     this.stopPromise = null;
   }
 
+  /**
+   * @returns {void}
+   */
+  invalidateConnectedExtensionsCache() {
+    this.connectedExtensionsCache = null;
+  }
+
+  /**
+   * @param {Map<ClientSocket, Set<string>>} index
+   * @param {ClientSocket} socket
+   * @param {string} requestId
+   * @returns {void}
+   */
+  addPendingRequestIndex(index, socket, requestId) {
+    const requestIds = index.get(socket);
+    if (requestIds) {
+      requestIds.add(requestId);
+      return;
+    }
+    index.set(socket, new Set([requestId]));
+  }
+
+  /**
+   * @param {Map<ClientSocket, Set<string>>} index
+   * @param {ClientSocket} socket
+   * @param {string} requestId
+   * @returns {void}
+   */
+  removePendingRequestIndex(index, socket, requestId) {
+    const requestIds = index.get(socket);
+    if (!requestIds) {
+      return;
+    }
+    requestIds.delete(requestId);
+    if (requestIds.size === 0) {
+      index.delete(socket);
+    }
+  }
+
+  /**
+   * @param {string} requestId
+   * @param {PendingEntry} pending
+   * @returns {void}
+   */
+  trackPendingRequest(requestId, pending) {
+    this.pendingRequests.set(requestId, pending);
+    this.addPendingRequestIndex(this.pendingRequestsByOwnerSocket, pending.socket, requestId);
+    for (const targetSocket of pending.targets) {
+      this.addPendingRequestIndex(this.pendingRequestsByTargetSocket, targetSocket, requestId);
+    }
+  }
+
+  /**
+   * @param {string} requestId
+   * @param {PendingEntry | undefined} [pending]
+   * @returns {PendingEntry | undefined}
+   */
+  clearPendingRequest(requestId, pending = this.pendingRequests.get(requestId)) {
+    if (!pending) {
+      return undefined;
+    }
+    this.pendingRequests.delete(requestId);
+    this.removePendingRequestIndex(this.pendingRequestsByOwnerSocket, pending.socket, requestId);
+    for (const targetSocket of pending.targets) {
+      this.removePendingRequestIndex(this.pendingRequestsByTargetSocket, targetSocket, requestId);
+    }
+    return pending;
+  }
+
+  /**
+   * @param {string} requestId
+   * @param {PendingEntry} pending
+   * @param {ClientSocket} targetSocket
+   * @returns {void}
+   */
+  removePendingTarget(requestId, pending, targetSocket) {
+    if (!pending.targets.delete(targetSocket)) {
+      return;
+    }
+    this.removePendingRequestIndex(this.pendingRequestsByTargetSocket, targetSocket, requestId);
+  }
+
+  /**
+   * @returns {Array<{ extensionId: string, browserName: string | null, profileLabel: string | null, accessEnabled: boolean }>}
+   */
+  getConnectedExtensionsSnapshot() {
+    if (this.connectedExtensionsCache) {
+      return this.connectedExtensionsCache;
+    }
+
+    this.connectedExtensionsCache = Array.from(this.extensionSockets.entries()).map(
+      ([extensionId, extSocket]) => ({
+        extensionId,
+        browserName: extSocket.__browserName ?? null,
+        profileLabel: extSocket.__profileLabel ?? null,
+        accessEnabled: extSocket.__accessEnabled ?? false,
+      })
+    );
+    return this.connectedExtensionsCache;
+  }
+
   /**
    * @param {ClientSocket} socket
    * @param {DaemonMessage} message
@@ -160,6 +286,7 @@ export class BridgeDaemon {
         typeof message.profileLabel === 'string' ? message.profileLabel : undefined;
       socket.__lastActiveAt = Date.now();
       this.extensionSockets.set(extensionId, socket);
+      this.invalidateConnectedExtensionsCache();
       void writeJsonLine(socket, { type: 'registered', role: 'extension' });
       return;
     }
@@ -180,7 +307,7 @@ export class BridgeDaemon {
    * @returns {Promise<BridgeDaemon>}
    */
   async start() {
-    if (!this.listenOptions) {
+    if (this.transport.type === 'socket' && !isWindowsNamedPipePath(this.socketPath)) {
       const socketDir = path.dirname(this.socketPath);
       await fs.promises.mkdir(socketDir, { recursive: true });
       if (process.platform !== 'win32') {
@@ -188,7 +315,7 @@ export class BridgeDaemon {
       }
       try {
         await fs.promises.access(this.socketPath);
-        if (await pingExistingDaemon(this.socketPath)) {
+        if (await pingExistingDaemon(this.transport)) {
           throw new Error(
             `Another daemon is already running on ${this.socketPath}. Stop it before starting a new one.`
           );
@@ -228,14 +355,10 @@ export class BridgeDaemon {
         this.serverAddress = server.address();
         resolve(undefined);
       };
-      if (this.listenOptions) {
-        server.listen(this.listenOptions, onListen);
-      } else {
-        server.listen(this.socketPath, onListen);
-      }
+      server.listen(this.listenOptions, onListen);
     });
 
-    if (!this.listenOptions && process.platform !== 'win32') {
+    if (this.transport.type === 'socket' && process.platform !== 'win32') {
       await fs.promises.chmod(this.socketPath, 0o600);
     }
 
@@ -266,6 +389,8 @@ export class BridgeDaemon {
       clearTimeout(pending.timeoutId);
     }
     this.pendingRequests.clear();
+    this.pendingRequestsByOwnerSocket.clear();
+    this.pendingRequestsByTargetSocket.clear();
 
     for (const socket of this.agentSockets.values()) {
       socket.destroy();
@@ -276,6 +401,7 @@ export class BridgeDaemon {
       socket.destroy();
     }
     this.extensionSockets.clear();
+    this.invalidateConnectedExtensionsCache();
 
     if (this.server) {
       const server = this.server;
@@ -291,7 +417,7 @@ export class BridgeDaemon {
           });
         });
       } finally {
-        if (!this.listenOptions) {
+        if (this.transport.type === 'socket' && !isWindowsNamedPipePath(this.socketPath)) {
           await fs.promises.rm(this.socketPath, { force: true });
         }
       }
@@ -359,6 +485,7 @@ export class BridgeDaemon {
           daemon: 'ok',
           extensionConnected: false,
           socketPath: this.socketPath,
+          transport: formatBridgeTransport(this.transport),
           connectedExtensions: [],
           ...getVersionNegotiationPayload(request.meta?.protocol_version),
         });
@@ -412,24 +539,38 @@ export class BridgeDaemon {
       typeof request.meta?.target_profile === 'string' ? request.meta.target_profile : null;
     const hasExplicitTarget = Boolean(targetBrowser || targetProfile);
 
-    let targets = Array.from(this.extensionSockets.values());
-    if (targetBrowser || targetProfile) {
-      targets = targets.filter((extSocket) => {
-        if (targetBrowser && extSocket.__browserName !== targetBrowser) return false;
-        if (targetProfile && extSocket.__profileLabel !== targetProfile) return false;
-        return true;
-      });
-    } else {
-      const enabled = targets.filter((extSocket) => extSocket.__accessEnabled);
-      if (enabled.length > 0) {
-        targets = enabled;
-      } else {
-        const mostRecent = selectMostRecentlyActiveExtension(targets);
-        if (mostRecent) {
-          targets = [mostRecent];
+    /** @type {ClientSocket[]} */
+    const targets = [];
+    /** @type {ClientSocket | null} */
+    let mostRecent = null;
+    for (const extSocket of this.extensionSockets.values()) {
+      if (targetBrowser || targetProfile) {
+        if (targetBrowser && extSocket.__browserName !== targetBrowser) {
+          continue;
+        }
+        if (targetProfile && extSocket.__profileLabel !== targetProfile) {
+          continue;
         }
+        targets.push(extSocket);
+        continue;
+      }
+
+      if (extSocket.__accessEnabled) {
+        targets.push(extSocket);
+        continue;
+      }
+
+      if (
+        !mostRecent ||
+        (typeof extSocket.__lastActiveAt === 'number' ? extSocket.__lastActiveAt : 0) >
+          (typeof mostRecent.__lastActiveAt === 'number' ? mostRecent.__lastActiveAt : 0)
+      ) {
+        mostRecent = extSocket;
       }
     }
+    if (!hasExplicitTarget && targets.length === 0 && mostRecent) {
+      targets.push(mostRecent);
+    }
 
     if (targets.length === 0) {
       const response = createFailure(
@@ -443,7 +584,7 @@ export class BridgeDaemon {
       return;
     }
 
-    this.pendingRequests.set(request.id, {
+    this.trackPendingRequest(request.id, {
       socket,
       method: request.method,
       source: typeof request.meta?.source === 'string' ? request.meta.source : '',
@@ -451,7 +592,7 @@ export class BridgeDaemon {
       timeoutId: setTimeout(() => {
         const pending = this.pendingRequests.get(request.id);
         if (!pending) return;
-        this.pendingRequests.delete(request.id);
+        this.clearPendingRequest(request.id, pending);
         const response = createFailure(
           request.id,
           ERROR_CODES.TIMEOUT,
@@ -496,12 +637,18 @@ export class BridgeDaemon {
    * @returns {void}
    */
   handleExtensionIdentity(socket, message) {
+    let changed = false;
     if (typeof message.browserName === 'string') {
+      changed = changed || socket.__browserName !== message.browserName;
       socket.__browserName = message.browserName;
     }
     if (typeof message.profileLabel === 'string') {
+      changed = changed || socket.__profileLabel !== message.profileLabel;
       socket.__profileLabel = message.profileLabel;
     }
+    if (changed) {
+      this.invalidateConnectedExtensionsCache();
+    }
   }
 
   /**
@@ -510,7 +657,13 @@ export class BridgeDaemon {
    * @returns {void}
    */
   handleExtensionAccessUpdate(socket, message) {
-    socket.__accessEnabled = Boolean(message.accessEnabled);
+    const accessEnabled = Boolean(message.accessEnabled);
+    if (socket.__accessEnabled !== accessEnabled) {
+      socket.__accessEnabled = accessEnabled;
+      this.invalidateConnectedExtensionsCache();
+      return;
+    }
+    socket.__accessEnabled = accessEnabled;
   }
 
   /**
@@ -539,11 +692,11 @@ export class BridgeDaemon {
       return;
     }
 
-    pending.targets.delete(socket);
+    this.removePendingTarget(responseMessage.id, pending, socket);
 
     if (responseMessage.ok) {
       clearTimeout(pending.timeoutId);
-      this.pendingRequests.delete(responseMessage.id);
+      this.clearPendingRequest(responseMessage.id, pending);
       this.pushLog({
         at: new Date().toISOString(),
         method: responseMessage.meta?.method ?? null,
@@ -559,14 +712,8 @@ export class BridgeDaemon {
                 daemon: 'ok',
                 extensionConnected: true,
                 socketPath: this.socketPath,
-                connectedExtensions: Array.from(this.extensionSockets.entries()).map(
-                  ([_id, extSocket]) => ({
-                    extensionId: _id,
-                    browserName: extSocket.__browserName ?? null,
-                    profileLabel: extSocket.__profileLabel ?? null,
-                    accessEnabled: extSocket.__accessEnabled ?? false,
-                  })
-                ),
+                transport: formatBridgeTransport(this.transport),
+                connectedExtensions: this.getConnectedExtensionsSnapshot(),
                 .../** @type {Record<string, unknown>} */ (responseMessage.result),
               },
               {
@@ -596,20 +743,33 @@ export class BridgeDaemon {
   handleSocketClose(socket) {
     if (socket.__extensionId) {
       this.extensionSockets.delete(socket.__extensionId);
+      this.invalidateConnectedExtensionsCache();
     }
 
     if (socket.__clientId) {
       this.agentSockets.delete(socket.__clientId);
     }
 
-    for (const [id, pending] of this.pendingRequests.entries()) {
-      if (pending.socket === socket) {
+    const ownedRequestIds = this.pendingRequestsByOwnerSocket.get(socket);
+    if (ownedRequestIds) {
+      for (const id of ownedRequestIds) {
+        const pending = this.pendingRequests.get(id);
+        if (!pending) {
+          continue;
+        }
         clearTimeout(pending.timeoutId);
-        this.pendingRequests.delete(id);
-        continue;
+        this.clearPendingRequest(id, pending);
       }
-      if (pending.targets.has(socket)) {
-        pending.targets.delete(socket);
+    }
+
+    const targetRequestIds = this.pendingRequestsByTargetSocket.get(socket);
+    if (targetRequestIds) {
+      for (const id of targetRequestIds) {
+        const pending = this.pendingRequests.get(id);
+        if (!pending) {
+          continue;
+        }
+        this.removePendingTarget(id, pending, socket);
         void this.finishPendingRequestIfExhausted(id, pending);
       }
     }
@@ -629,7 +789,7 @@ export class BridgeDaemon {
     }
 
     clearTimeout(pending.timeoutId);
-    this.pendingRequests.delete(requestId);
+    this.clearPendingRequest(requestId, pending);
 
     const response =
       pending.lastErrorResponse ??
@@ -668,36 +828,25 @@ export class BridgeDaemon {
 }
 
 /**
- * @param {ClientSocket[]} sockets
- * @returns {ClientSocket | null}
- */
-function selectMostRecentlyActiveExtension(sockets) {
-  if (sockets.length === 0) {
-    return null;
-  }
-
-  return sockets.reduce((best, current) => {
-    const bestAt = typeof best.__lastActiveAt === 'number' ? best.__lastActiveAt : 0;
-    const currentAt = typeof current.__lastActiveAt === 'number' ? current.__lastActiveAt : 0;
-    return currentAt > bestAt ? current : best;
-  });
-}
-
-/**
- * Check whether a daemon is already listening on the given socket path.
+ * Check whether a daemon is already listening on the given transport.
  * Connects, sends a health.ping, and waits up to 500 ms for a response.
  *
- * @param {string} socketPath
+ * @param {BridgeTransport | string} transport
  * @returns {Promise<boolean>}
  */
-async function pingExistingDaemon(socketPath) {
+export async function pingExistingDaemon(transport) {
+  const resolvedTransport =
+    typeof transport === 'string' ? createSocketBridgeTransport(transport) : transport;
   return new Promise((resolve) => {
     const timeout = setTimeout(() => {
       socket.destroy();
       resolve(false);
     }, DAEMON_EXISTING_SOCKET_PING_TIMEOUT_MS);
 
-    const socket = net.createConnection(socketPath);
+    const socket =
+      resolvedTransport.type === 'tcp'
+        ? net.createConnection({ host: resolvedTransport.host, port: resolvedTransport.port })
+        : net.createConnection(resolvedTransport.socketPath);
     socket.once('error', () => {
       clearTimeout(timeout);
       resolve(false);

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

@@ -11,6 +11,9 @@ import { MAX_NATIVE_MESSAGE_BYTES } from '../../protocol/src/index.js';
  */
 export async function writeNativeMessage(stream, message) {
   const payload = Buffer.from(JSON.stringify(message), 'utf8');
+  if (payload.length > MAX_NATIVE_MESSAGE_BYTES) {
+    throw new Error(`Native message exceeds ${MAX_NATIVE_MESSAGE_BYTES} bytes: ${payload.length}`);
+  }
   const header = Buffer.alloc(4);
   header.writeUInt32LE(payload.length, 0);
   if (!stream.write(header)) {
@@ -24,34 +27,151 @@ export async function writeNativeMessage(stream, message) {
 /**
  * @param {NodeJS.ReadableStream} stream
  * @param {(message: unknown) => void} onMessage
+ * @param {(error: Error) => void} [onProtocolError]
  * @returns {void}
  */
-export function createNativeMessageReader(stream, onMessage) {
-  let buffer = Buffer.alloc(0);
+export function createNativeMessageReader(stream, onMessage, onProtocolError) {
+  /** @type {Buffer[]} */
+  const chunks = [];
+  let bufferedBytes = 0;
+  let closed = false;
+
+  /**
+   * @param {number} length
+   * @returns {Buffer | null}
+   */
+  function peekBytes(length) {
+    if (length === 0) {
+      return Buffer.alloc(0);
+    }
+    if (bufferedBytes < length || chunks.length === 0) {
+      return null;
+    }
+
+    const firstChunk = chunks[0];
+    if (firstChunk.length >= length) {
+      return firstChunk.subarray(0, length);
+    }
+
+    const combined = Buffer.allocUnsafe(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      const copyLength = Math.min(chunk.length, length - offset);
+      chunk.copy(combined, offset, 0, copyLength);
+      offset += copyLength;
+      if (offset === length) {
+        return combined;
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * @param {number} length
+   * @returns {Buffer | null}
+   */
+  function consumeBytes(length) {
+    if (length === 0) {
+      return Buffer.alloc(0);
+    }
+    if (bufferedBytes < length || chunks.length === 0) {
+      return null;
+    }
+
+    const firstChunk = chunks[0];
+    if (firstChunk.length === length) {
+      chunks.shift();
+      bufferedBytes -= length;
+      return firstChunk;
+    }
+    if (firstChunk.length > length) {
+      const consumed = firstChunk.subarray(0, length);
+      chunks[0] = firstChunk.subarray(length);
+      bufferedBytes -= length;
+      return consumed;
+    }
+
+    const combined = Buffer.allocUnsafe(length);
+    let offset = 0;
+    let remaining = length;
+    while (remaining > 0 && chunks.length > 0) {
+      const chunk = chunks[0];
+      const copyLength = Math.min(chunk.length, remaining);
+      chunk.copy(combined, offset, 0, copyLength);
+      offset += copyLength;
+      remaining -= copyLength;
+      if (copyLength === chunk.length) {
+        chunks.shift();
+      } else {
+        chunks[0] = chunk.subarray(copyLength);
+      }
+    }
+
+    bufferedBytes -= length;
+    return combined;
+  }
+
+  /**
+   * @param {Error} error
+   * @returns {void}
+   */
+  function closeReader(error) {
+    if (closed) {
+      return;
+    }
+    closed = true;
+    stream.removeListener('data', handleData);
+    onProtocolError?.(error);
+    const destroy = /** @type {{ destroy?: (() => void) | undefined }} */ (stream).destroy;
+    if (typeof destroy === 'function') {
+      destroy.call(stream);
+    }
+  }
 
   /** @param {Buffer} chunk */
-  stream.on('data', (chunk) => {
-    buffer = Buffer.concat([buffer, chunk]);
+  function handleData(chunk) {
+    if (closed || chunk.length === 0) {
+      return;
+    }
+
+    chunks.push(chunk);
+    bufferedBytes += chunk.length;
 
-    while (buffer.length >= 4) {
-      const length = buffer.readUInt32LE(0);
+    while (bufferedBytes >= 4) {
+      const header = peekBytes(4);
+      if (!header) {
+        return;
+      }
+
+      const length = header.readUInt32LE(0);
       if (length > MAX_NATIVE_MESSAGE_BYTES) {
-        buffer = Buffer.alloc(0);
+        closeReader(
+          new Error(`Native message exceeds ${MAX_NATIVE_MESSAGE_BYTES} bytes: ${length}`)
+        );
         return;
       }
-      if (buffer.length < 4 + length) {
+
+      const frameLength = 4 + length;
+      if (bufferedBytes < frameLength) {
         return;
       }
 
-      const payload = buffer.subarray(4, 4 + length);
-      buffer = buffer.subarray(4 + length);
+      const frame = consumeBytes(frameLength);
+      if (!frame) {
+        return;
+      }
+
+      const payload = frame.subarray(4);
       try {
         onMessage(JSON.parse(payload.toString('utf8')));
       } catch {
         // Malformed JSON payload - skip it.
       }
     }
-  });
+  }
+
+  stream.on('data', handleData);
 }
 
 /**