@browserbridge/bbx 1.0.1 → 1.2.0

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

@@ -29,13 +29,24 @@ import {
   SUPPORTED_VERSIONS,
   validateBridgeRequest,
 } from '../../protocol/src/index.js';
-import { getSocketPath } from './config.js';
+import {
+  createSocketBridgeTransport,
+  formatBridgeTransport,
+  getBridgeListenTarget,
+  getBridgeTransport,
+  getSocketPath,
+} from './config.js';
+import { normalizeDaemonLogger } from './daemon-logger.js';
 import { writeJsonLine } from './framing.js';
 
+const DAEMON_VERSION = loadDaemonVersion();
+
 /** @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('./daemon-logger.js').DaemonLoggerLike} DaemonLoggerLike */
 /** @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 +99,27 @@ function getVersionNegotiationPayload(requestedVersion) {
   };
 }
 
+/**
+ * @returns {string | null}
+ */
+function loadDaemonVersion() {
+  try {
+    const raw = fs.readFileSync(new URL('../../../package.json', import.meta.url), 'utf8');
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed.version === 'string' ? parsed.version : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} socketPath
+ * @returns {boolean}
+ */
+export function isWindowsNamedPipePath(socketPath) {
+  return socketPath.startsWith('\\\\.\\pipe\\');
+}
+
 /**
  * @typedef {{
  *   type?: string,
@@ -109,25 +141,30 @@ function getVersionNegotiationPayload(requestedVersion) {
 export class BridgeDaemon {
   /**
    * @param {{
+   *   transport?: BridgeTransport,
    *   socketPath?: string,
    *   listenOptions?: import('node:net').ListenOptions | null,
    *   setupStatusLoader?: () => Promise<SetupStatus>,
    *   setupInstaller?: (params: Record<string, unknown>) => Promise<SetupInstallResult>,
-   *   logger?: Pick<Console, 'log' | 'error'>
+   *   logger?: DaemonLoggerLike | Pick<Console, 'log' | 'error'>
    * }} [options={}]
    */
   constructor({
-    socketPath = getSocketPath(),
+    transport = getBridgeTransport(),
+    socketPath = undefined,
     listenOptions = null,
     setupStatusLoader = collectSetupStatus,
     setupInstaller = installSetupTarget,
-    logger = console,
+    logger = undefined,
   } = {}) {
-    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;
+    /** @type {DaemonLoggerLike} */
+    this.logger = normalizeDaemonLogger(logger);
     /** @type {net.Server | null} */
     this.server = null;
     /** @type {net.AddressInfo | string | null} */
@@ -138,11 +175,130 @@ 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;
+    /** @type {number} */
+    this.startedAt = 0;
+    /** @type {number} */
+    this.requestsProcessed = 0;
+    /** @type {number} */
+    this.requestsFailed = 0;
+    /** @type {number} */
+    this.totalResponseTimeMs = 0;
+    /** @type {Map<string, number>} */
+    this.requestStartTimes = new Map();
+  }
+
+  /**
+   * @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.requestStartTimes.set(requestId, Date.now());
+    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.requestStartTimes.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;
   }
 
   /**
@@ -160,6 +316,12 @@ export class BridgeDaemon {
         typeof message.profileLabel === 'string' ? message.profileLabel : undefined;
       socket.__lastActiveAt = Date.now();
       this.extensionSockets.set(extensionId, socket);
+      this.invalidateConnectedExtensionsCache();
+      this.logger.info('extension registered', {
+        extensionId,
+        browserName: socket.__browserName ?? null,
+        profileLabel: socket.__profileLabel ?? null,
+      });
       void writeJsonLine(socket, { type: 'registered', role: 'extension' });
       return;
     }
@@ -168,6 +330,7 @@ export class BridgeDaemon {
       const clientId = message.clientId || randomUUID();
       this.agentSockets.set(clientId, socket);
       socket.__clientId = clientId;
+      this.logger.info('agent registered', { clientId });
       void writeJsonLine(socket, {
         type: 'registered',
         role: 'agent',
@@ -180,7 +343,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,12 +351,14 @@ 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.`
           );
         }
-        this.logger.log('[daemon] Removing stale socket from previous run:', this.socketPath);
+        this.logger.info('Removing stale socket from previous run', {
+          socketPath: this.socketPath,
+        });
       } catch (error) {
         if (error instanceof Error && error.message.startsWith('Another daemon')) {
           throw error;
@@ -206,15 +371,14 @@ export class BridgeDaemon {
     this.server = net.createServer((socket) => {
       const typedSocket = /** @type {ClientSocket} */ (socket);
       typedSocket.on('error', (err) => {
-        this.logger.error?.('[daemon] socket error:', err.message);
+        this.logger.error('socket error', { message: err.message });
       });
       parseJsonLines(typedSocket, (raw) => {
         const message = /** @type {DaemonMessage} */ (raw);
         void this.handleClientMessage(typedSocket, message).catch((err) => {
-          this.logger.error?.(
-            '[daemon] handler error:',
-            err instanceof Error ? err.message : String(err)
-          );
+          this.logger.error('handler error', {
+            message: err instanceof Error ? err.message : String(err),
+          });
         });
       });
       typedSocket.on('close', () => this.handleSocketClose(typedSocket));
@@ -228,17 +392,20 @@ 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);
     }
 
+    this.logger.info('Daemon listening', {
+      transport: formatBridgeTransport(this.transport),
+      socketPath: this.socketPath ?? null,
+    });
+
+    this.startedAt = Date.now();
+
     return this;
   }
 
@@ -266,6 +433,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 +445,7 @@ export class BridgeDaemon {
       socket.destroy();
     }
     this.extensionSockets.clear();
+    this.invalidateConnectedExtensionsCache();
 
     if (this.server) {
       const server = this.server;
@@ -291,7 +461,7 @@ export class BridgeDaemon {
           });
         });
       } finally {
-        if (!this.listenOptions) {
+        if (this.transport.type === 'socket' && !isWindowsNamedPipePath(this.socketPath)) {
           await fs.promises.rm(this.socketPath, { force: true });
         }
       }
@@ -357,9 +527,12 @@ export class BridgeDaemon {
       if (this.extensionSockets.size === 0) {
         const response = createSuccess(request.id, {
           daemon: 'ok',
+          daemonVersion: DAEMON_VERSION,
           extensionConnected: false,
           socketPath: this.socketPath,
+          transport: formatBridgeTransport(this.transport),
           connectedExtensions: [],
+          daemon_supported_versions: SUPPORTED_VERSIONS,
           ...getVersionNegotiationPayload(request.meta?.protocol_version),
         });
         await writeJsonLine(socket, { type: 'agent.response', response });
@@ -375,6 +548,26 @@ export class BridgeDaemon {
       return;
     }
 
+    if (request.method === 'daemon.metrics') {
+      const now = Date.now();
+      const uptimeMs = this.startedAt > 0 ? now - this.startedAt : 0;
+      const avgResponseTimeMs =
+        this.requestsProcessed > 0
+          ? Math.round(this.totalResponseTimeMs / this.requestsProcessed)
+          : 0;
+      const response = createSuccess(request.id, {
+        uptimeMs,
+        activeAgents: this.agentSockets.size,
+        activeExtensions: this.extensionSockets.size,
+        pendingRequests: this.pendingRequests.size,
+        requestsProcessed: this.requestsProcessed,
+        requestsFailed: this.requestsFailed,
+        avgResponseTimeMs,
+      });
+      await writeJsonLine(socket, { type: 'agent.response', response });
+      return;
+    }
+
     if (request.method === 'setup.get_status') {
       const response = createSuccess(request.id, await this.setupStatusLoader(), {
         method: request.method,
@@ -412,24 +605,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 +650,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 +658,8 @@ 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);
+        this.recordRequestCompletion(request.id, false);
         const response = createFailure(
           request.id,
           ERROR_CODES.TIMEOUT,
@@ -463,6 +671,12 @@ export class BridgeDaemon {
         });
       }, this.pendingTimeoutMs),
     });
+    this.logger.info('request routed', {
+      requestId: request.id,
+      method: request.method,
+      clientId: socket.__clientId ?? null,
+      targetCount: targets.length,
+    });
     const broadcastPayload = { type: 'extension.request', request };
     await Promise.all(targets.map((extSocket) => writeJsonLine(extSocket, broadcastPayload)));
   }
@@ -496,12 +710,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 +730,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 +765,12 @@ 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.recordRequestCompletion(responseMessage.id, true);
       this.pushLog({
         at: new Date().toISOString(),
         method: responseMessage.meta?.method ?? null,
@@ -559,15 +786,11 @@ 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),
+                daemonVersion: DAEMON_VERSION,
+                daemon_supported_versions: SUPPORTED_VERSIONS,
               },
               {
                 ...responseMessage.meta,
@@ -595,21 +818,37 @@ export class BridgeDaemon {
    */
   handleSocketClose(socket) {
     if (socket.__extensionId) {
+      this.logger.info('extension disconnected', { extensionId: socket.__extensionId });
       this.extensionSockets.delete(socket.__extensionId);
+      this.invalidateConnectedExtensionsCache();
     }
 
     if (socket.__clientId) {
+      this.logger.info('agent disconnected', { clientId: 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);
+        this.recordRequestCompletion(id, false);
       }
-      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 +868,8 @@ export class BridgeDaemon {
     }
 
     clearTimeout(pending.timeoutId);
-    this.pendingRequests.delete(requestId);
+    this.clearPendingRequest(requestId, pending);
+    this.recordRequestCompletion(requestId, false);
 
     const response =
       pending.lastErrorResponse ??
@@ -655,6 +895,22 @@ export class BridgeDaemon {
     });
   }
 
+  /**
+   * @param {string} requestId
+   * @param {boolean} ok
+   * @returns {void}
+   */
+  recordRequestCompletion(requestId, ok) {
+    const startedAt = this.requestStartTimes.get(requestId);
+    this.requestsProcessed += 1;
+    if (!ok) {
+      this.requestsFailed += 1;
+    }
+    if (typeof startedAt === 'number') {
+      this.totalResponseTimeMs += Date.now() - startedAt;
+    }
+  }
+
   /**
    * @param {Record<string, unknown>} entry
    * @returns {void}
@@ -668,36 +924,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);