@browserbridge/bbx 1.0.0 → 1.1.0

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

@@ -5,8 +5,16 @@ import net from 'node:net';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
 
-import { installAgentFiles, isSupportedTarget, removeAgentFiles } from '../../agent-client/src/install.js';
-import { installMcpConfig, isMcpClientName, removeMcpConfig } from '../../agent-client/src/mcp-config.js';
+import {
+  installAgentFiles,
+  isSupportedTarget,
+  removeAgentFiles,
+} from '../../agent-client/src/install.js';
+import {
+  installMcpConfig,
+  isMcpClientName,
+  removeMcpConfig,
+} from '../../agent-client/src/mcp-config.js';
 import { collectSetupStatus } from '../../agent-client/src/setup-status.js';
 import {
   createFailure,
@@ -19,15 +27,22 @@ import {
   parseJsonLines,
   PROTOCOL_VERSION,
   SUPPORTED_VERSIONS,
-  validateBridgeRequest
+  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 */
 /**
@@ -76,10 +91,18 @@ function getVersionNegotiationPayload(requestedVersion) {
     ...(localIsNewer ? { deprecated_since: latestSupported } : {}),
     migration_hint: localIsNewer
       ? `Browser Bridge daemon is newer than the client protocol ${requestedVersion}. Restart or update the Browser Bridge CLI/npm package to ${latestSupported} or later.`
-      : `Browser Bridge daemon is older than the client protocol ${requestedVersion}. Restart or update the Browser Bridge CLI so the daemon supports ${requestedVersion}.`
+      : `Browser Bridge daemon is older than the client protocol ${requestedVersion}. Restart or update the Browser Bridge CLI so the daemon supports ${requestedVersion}.`,
   };
 }
 
+/**
+ * @param {string} socketPath
+ * @returns {boolean}
+ */
+function isWindowsNamedPipePath(socketPath) {
+  return socketPath.startsWith('\\\\.\\pipe\\');
+}
+
 /**
  * @typedef {{
  *   type?: string,
@@ -101,6 +124,7 @@ function getVersionNegotiationPayload(requestedVersion) {
 export class BridgeDaemon {
   /**
    * @param {{
+   *   transport?: BridgeTransport,
    *   socketPath?: string,
    *   listenOptions?: import('node:net').ListenOptions | null,
    *   setupStatusLoader?: () => Promise<SetupStatus>,
@@ -108,9 +132,18 @@ export class BridgeDaemon {
    *   logger?: Pick<Console, 'log' | 'error'>
    * }} [options={}]
    */
-  constructor({ socketPath = getSocketPath(), listenOptions = null, setupStatusLoader = collectSetupStatus, setupInstaller = installSetupTarget, logger = console } = {}) {
-    this.socketPath = socketPath;
-    this.listenOptions = listenOptions;
+  constructor({
+    transport = getBridgeTransport(),
+    socketPath = undefined,
+    listenOptions = null,
+    setupStatusLoader = collectSetupStatus,
+    setupInstaller = installSetupTarget,
+    logger = console,
+  } = {}) {
+    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;
@@ -124,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
@@ -140,10 +280,13 @@ export class BridgeDaemon {
     if (message.role === 'extension') {
       const extensionId = randomUUID();
       socket.__extensionId = extensionId;
-      socket.__browserName = typeof message.browserName === 'string' ? message.browserName : undefined;
-      socket.__profileLabel = typeof message.profileLabel === 'string' ? message.profileLabel : undefined;
+      socket.__browserName =
+        typeof message.browserName === 'string' ? message.browserName : undefined;
+      socket.__profileLabel =
+        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;
     }
@@ -152,7 +295,11 @@ export class BridgeDaemon {
       const clientId = message.clientId || randomUUID();
       this.agentSockets.set(clientId, socket);
       socket.__clientId = clientId;
-      void writeJsonLine(socket, { type: 'registered', role: 'agent', clientId });
+      void writeJsonLine(socket, {
+        type: 'registered',
+        role: 'agent',
+        clientId,
+      });
       return;
     }
   }
@@ -160,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') {
@@ -168,8 +315,10 @@ export class BridgeDaemon {
       }
       try {
         await fs.promises.access(this.socketPath);
-        if (await pingExistingDaemon(this.socketPath)) {
-          throw new Error(`Another daemon is already running on ${this.socketPath}. Stop it before starting a new one.`);
+        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);
       } catch (error) {
@@ -189,7 +338,10 @@ export class BridgeDaemon {
       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?.(
+            '[daemon] handler error:',
+            err instanceof Error ? err.message : String(err)
+          );
         });
       });
       typedSocket.on('close', () => this.handleSocketClose(typedSocket));
@@ -203,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);
     }
 
@@ -241,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();
@@ -251,6 +401,7 @@ export class BridgeDaemon {
       socket.destroy();
     }
     this.extensionSockets.clear();
+    this.invalidateConnectedExtensionsCache();
 
     if (this.server) {
       const server = this.server;
@@ -266,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 });
         }
       }
@@ -314,7 +465,10 @@ export class BridgeDaemon {
 
     await writeJsonLine(socket, {
       type: 'error',
-      error: { code: ERROR_CODES.INVALID_REQUEST, message: 'Unknown message type.' }
+      error: {
+        code: ERROR_CODES.INVALID_REQUEST,
+        message: 'Unknown message type.',
+      },
     });
   }
 
@@ -331,8 +485,9 @@ export class BridgeDaemon {
           daemon: 'ok',
           extensionConnected: false,
           socketPath: this.socketPath,
+          transport: formatBridgeTransport(this.transport),
           connectedExtensions: [],
-          ...getVersionNegotiationPayload(request.meta?.protocol_version)
+          ...getVersionNegotiationPayload(request.meta?.protocol_version),
         });
         await writeJsonLine(socket, { type: 'agent.response', response });
         return;
@@ -341,7 +496,7 @@ export class BridgeDaemon {
 
     if (request.method === 'log.tail') {
       const response = createSuccess(request.id, {
-        entries: this.recentLog.slice(-DEFAULT_LOG_TAIL_LIMIT)
+        entries: this.recentLog.slice(-DEFAULT_LOG_TAIL_LIMIT),
       });
       await writeJsonLine(socket, { type: 'agent.response', response });
       return;
@@ -349,7 +504,7 @@ export class BridgeDaemon {
 
     if (request.method === 'setup.get_status') {
       const response = createSuccess(request.id, await this.setupStatusLoader(), {
-        method: request.method
+        method: request.method,
       });
       await writeJsonLine(socket, { type: 'agent.response', response });
       return;
@@ -357,9 +512,13 @@ export class BridgeDaemon {
 
     if (request.method === 'setup.install') {
       try {
-        const response = createSuccess(request.id, await this.setupInstaller(request.params ?? {}), {
-          method: request.method
-        });
+        const response = createSuccess(
+          request.id,
+          await this.setupInstaller(request.params ?? {}),
+          {
+            method: request.method,
+          }
+        );
         await writeJsonLine(socket, { type: 'agent.response', response });
       } catch (error) {
         const response = createFailure(
@@ -374,27 +533,43 @@ export class BridgeDaemon {
       return;
     }
 
-    const targetBrowser = typeof request.meta?.target_browser === 'string' ? request.meta.target_browser : null;
-    const targetProfile = typeof request.meta?.target_profile === 'string' ? request.meta.target_profile : null;
+    const targetBrowser =
+      typeof request.meta?.target_browser === 'string' ? request.meta.target_browser : null;
+    const targetProfile =
+      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) {
@@ -409,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 : '',
@@ -417,17 +592,20 @@ export class BridgeDaemon {
       timeoutId: setTimeout(() => {
         const pending = this.pendingRequests.get(request.id);
         if (!pending) return;
-        this.pendingRequests.delete(request.id);
-        const response = createFailure(request.id, ERROR_CODES.TIMEOUT, 'Extension did not respond in time.');
-        void writeJsonLine(pending.socket, { type: 'agent.response', response });
-      }, this.pendingTimeoutMs)
+        this.clearPendingRequest(request.id, pending);
+        const response = createFailure(
+          request.id,
+          ERROR_CODES.TIMEOUT,
+          'Extension did not respond in time.'
+        );
+        void writeJsonLine(pending.socket, {
+          type: 'agent.response',
+          response,
+        });
+      }, this.pendingTimeoutMs),
     });
     const broadcastPayload = { type: 'extension.request', request };
-    await Promise.all(
-      targets.map(
-        (extSocket) => writeJsonLine(extSocket, broadcastPayload)
-      )
-    );
+    await Promise.all(targets.map((extSocket) => writeJsonLine(extSocket, broadcastPayload)));
   }
 
   /**
@@ -440,15 +618,15 @@ export class BridgeDaemon {
       await writeJsonLine(socket, {
         type: 'extension.setup_status.response',
         requestId: message.requestId,
-        status: await this.setupStatusLoader()
+        status: await this.setupStatusLoader(),
       });
     } catch (error) {
       await writeJsonLine(socket, {
         type: 'extension.setup_status.error',
         requestId: message.requestId,
         error: {
-          message: error instanceof Error ? error.message : String(error)
-        }
+          message: error instanceof Error ? error.message : String(error),
+        },
       });
     }
   }
@@ -459,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();
+    }
   }
 
   /**
@@ -473,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;
   }
 
   /**
@@ -483,9 +673,7 @@ export class BridgeDaemon {
    */
   handleExtensionActivity(socket, message) {
     socket.__lastActiveAt =
-      typeof message.at === 'number' && Number.isFinite(message.at)
-        ? message.at
-        : Date.now();
+      typeof message.at === 'number' && Number.isFinite(message.at) ? message.at : Date.now();
   }
 
   /**
@@ -504,41 +692,40 @@ 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,
         ok: true,
         id: responseMessage.id,
-        source: pending.source || null
+        source: pending.source || null,
       });
-      const response = pending.method === 'health.ping'
-        ? createSuccess(responseMessage.id, {
-          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
-            })
-          ),
-          .../** @type {Record<string, unknown>} */ (responseMessage.result)
-        }, {
-          ...responseMessage.meta,
-          method: responseMessage.meta?.method ?? pending.method
-        })
-        : responseMessage;
+      const response =
+        pending.method === 'health.ping'
+          ? createSuccess(
+              responseMessage.id,
+              {
+                daemon: 'ok',
+                extensionConnected: true,
+                socketPath: this.socketPath,
+                transport: formatBridgeTransport(this.transport),
+                connectedExtensions: this.getConnectedExtensionsSnapshot(),
+                .../** @type {Record<string, unknown>} */ (responseMessage.result),
+              },
+              {
+                ...responseMessage.meta,
+                method: responseMessage.meta?.method ?? pending.method,
+              }
+            )
+          : responseMessage;
 
       await writeJsonLine(pending.socket, {
         type: 'agent.response',
-        response
+        response,
       });
       return;
     }
@@ -556,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);
       }
     }
@@ -589,27 +789,29 @@ export class BridgeDaemon {
     }
 
     clearTimeout(pending.timeoutId);
-    this.pendingRequests.delete(requestId);
+    this.clearPendingRequest(requestId, pending);
 
-    const response = pending.lastErrorResponse ?? createFailure(
-      requestId,
-      ERROR_CODES.EXTENSION_DISCONNECTED,
-      'Target extension disconnected before responding.',
-      null,
-      { method: pending.method }
-    );
+    const response =
+      pending.lastErrorResponse ??
+      createFailure(
+        requestId,
+        ERROR_CODES.EXTENSION_DISCONNECTED,
+        'Target extension disconnected before responding.',
+        null,
+        { method: pending.method }
+      );
 
     this.pushLog({
       at: new Date().toISOString(),
       method: response.meta?.method ?? pending.method ?? null,
       ok: false,
       id: requestId,
-      source: pending.source || null
+      source: pending.source || null,
     });
 
     await writeJsonLine(pending.socket, {
       type: 'agent.response',
-      response
+      response,
     });
   }
 
@@ -626,37 +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);
@@ -679,16 +869,18 @@ async function pingExistingDaemon(socketPath) {
     });
 
     socket.once('connect', () => {
-      socket.write(`${JSON.stringify({
-        type: 'agent.request',
-        request: {
-          id: 'ping_probe',
-          method: 'health.ping',
-          tab_id: null,
-          params: {},
-          meta: { protocol_version: PROTOCOL_VERSION, token_budget: null }
-        }
-      })}\n`);
+      socket.write(
+        `${JSON.stringify({
+          type: 'agent.request',
+          request: {
+            id: 'ping_probe',
+            method: 'health.ping',
+            tab_id: null,
+            params: {},
+            meta: { protocol_version: PROTOCOL_VERSION, token_budget: null },
+          },
+        })}\n`
+      );
     });
   });
 }
@@ -724,7 +916,7 @@ export async function installSetupTarget(
     installMcpConfig,
     isMcpClientName,
     removeMcpConfig,
-    cwd: process.cwd()
+    cwd: process.cwd(),
   }
 ) {
   /** @type {SetupInstallDeps} */
@@ -734,14 +926,21 @@ export async function installSetupTarget(
     if (!resolvedDeps.isMcpClientName(normalized.target)) {
       throw new Error(`Unsupported MCP client "${normalized.target}".`);
     }
-    const paths = normalized.action === 'uninstall'
-      ? await resolvedDeps.removeMcpConfig(normalized.target, { global: true })
-      : [await resolvedDeps.installMcpConfig(normalized.target, { global: true })];
+    const paths =
+      normalized.action === 'uninstall'
+        ? await resolvedDeps.removeMcpConfig(normalized.target, {
+            global: true,
+          })
+        : [
+            await resolvedDeps.installMcpConfig(normalized.target, {
+              global: true,
+            }),
+          ];
     return {
       action: normalized.action,
       kind: 'mcp',
       target: normalized.target,
-      paths
+      paths,
     };
   }
 
@@ -749,21 +948,22 @@ export async function installSetupTarget(
     throw new Error(`Unsupported skill target "${normalized.target}".`);
   }
 
-  const paths = normalized.action === 'uninstall'
-    ? await resolvedDeps.removeAgentFiles({
-      targets: [normalized.target],
-      projectPath: resolvedDeps.cwd,
-      global: true
-    })
-    : await resolvedDeps.installAgentFiles({
-      targets: [normalized.target],
-      projectPath: resolvedDeps.cwd,
-      global: true
-    });
+  const paths =
+    normalized.action === 'uninstall'
+      ? await resolvedDeps.removeAgentFiles({
+          targets: [normalized.target],
+          projectPath: resolvedDeps.cwd,
+          global: true,
+        })
+      : await resolvedDeps.installAgentFiles({
+          targets: [normalized.target],
+          projectPath: resolvedDeps.cwd,
+          global: true,
+        });
   return {
     action: normalized.action,
     kind: 'skill',
     target: normalized.target,
-    paths
+    paths,
   };
 }