@vibebrowser/mcp 0.2.5 → 0.2.7

package/dist/relay.js

@@ -13,6 +13,7 @@ import { writeFileSync, readFileSync, existsSync, unlinkSync, mkdirSync } from '
 import { join } from 'path';
 import { homedir } from 'os';
 import { EventEmitter } from 'events';
+import { DevtoolsFallbackConnection } from './devtools-fallback.js';
 function parseEnvPort(name, fallback) {
     const raw = process.env[name];
     if (!raw) {
@@ -24,6 +25,9 @@ function parseEnvPort(name, fallback) {
     }
     return port;
 }
+function normalizeToolName(value) {
+    return value.replace(/[-\s]/g, '_').toLowerCase();
+}
 // Ports (19888/19889 to avoid conflict with Playwriter MCP which uses 19988/19989)
 export const EXTENSION_PORT = parseEnvPort('VIBE_MCP_EXTENSION_PORT', 19889);
 export const AGENT_PORT = parseEnvPort('VIBE_MCP_AGENT_PORT', 19888);
@@ -33,20 +37,27 @@ const PID_FILE = join(VIBE_DIR, 'relay.pid');
 const LOG_FILE = join(VIBE_DIR, 'relay.log');
 /**
  * Vibe MCP Relay Server
+ *
+ * Owns exactly one shared chrome-devtools fallback backend process per relay
+ * daemon instance. All connected MCP clients (vibebrowser-mcp and
+ * vibebrowser-cli) route through this relay, so fallback lifecycle and tool
+ * routing stay deterministic across concurrent agents.
  */
 export class RelayServer extends EventEmitter {
     extensionWss = null;
     agentWss = null;
-    extensionWs = null;
+    extensionSessions = new Map();
+    socketToSessionId = new Map();
     agents = new Map();
     pendingRequests = new Map();
-    tools = [];
     requestIdCounter = 0;
+    anonymousSessionCounter = 0;
     debug;
-    toolsSyncTimer = null;
+    devtoolsFallback;
     constructor(debug = false) {
         super();
         this.debug = debug;
+        this.devtoolsFallback = new DevtoolsFallbackConnection(debug);
     }
     /**
      * Start the relay server
@@ -60,6 +71,19 @@ export class RelayServer extends EventEmitter {
         await this.startExtensionServer();
         // Start agent WebSocket server
         await this.startAgentServer();
+        await this.devtoolsFallback.start();
+        this.devtoolsFallback.on('tools_updated', () => {
+            this.broadcastDefaultToolsToAgents();
+            this.broadcastSessionState();
+        });
+        this.devtoolsFallback.on('connected', () => {
+            this.broadcastDefaultToolsToAgents();
+            this.broadcastSessionState();
+        });
+        this.devtoolsFallback.on('unavailable', () => {
+            this.broadcastDefaultToolsToAgents();
+            this.broadcastSessionState();
+        });
         // Write PID file
         writeFileSync(PID_FILE, String(process.pid));
         this.log(`Relay started (PID: ${process.pid})`);
@@ -109,17 +133,8 @@ export class RelayServer extends EventEmitter {
      * Handle extension connection
      */
     handleExtensionConnection(ws) {
-        const previousWs = this.extensionWs;
-        const replacedConnection = previousWs !== null && previousWs !== ws;
-        // Replace prior extension connection (background/service worker can reconnect).
-        if (previousWs && previousWs !== ws) {
-            previousWs.close();
-        }
-        this.log('Extension connected');
-        this.extensionWs = ws;
+        this.log('Extension socket connected; waiting for session handshake');
         ws.on('message', (data) => {
-            if (this.extensionWs !== ws)
-                return;
             try {
                 const message = JSON.parse(data.toString());
                 this.handleExtensionMessage(ws, message);
@@ -130,25 +145,29 @@ export class RelayServer extends EventEmitter {
         });
         ws.on('close', (code, reasonBuffer) => {
             const reason = reasonBuffer?.toString() || '';
-            this.log(`Extension disconnected (code=${code}${reason ? `, reason=${reason}` : ''})`);
-            // Ignore stale close events from replaced sockets.
-            if (this.extensionWs !== ws) {
+            const sessionId = this.socketToSessionId.get(ws);
+            this.log(`Extension disconnected${sessionId ? ` (${sessionId})` : ''} (code=${code}${reason ? `, reason=${reason}` : ''})`);
+            if (!sessionId) {
+                return;
+            }
+            const session = this.extensionSessions.get(sessionId);
+            if (!session || session.ws !== ws) {
+                this.socketToSessionId.delete(ws);
                 return;
             }
-            this.extensionWs = null;
-            this.tools = [];
-            this.stopToolsSyncLoop();
-            // Notify all agents
-            this.broadcastToAgents({ type: 'extension_disconnected' });
+            this.socketToSessionId.delete(ws);
+            this.extensionSessions.delete(sessionId);
+            this.stopToolsSyncLoop(session);
+            this.rejectPendingRequestsForSession(sessionId, `Extension session disconnected: ${sessionId}`);
+            this.broadcastSessionState();
+            if (this.extensionSessions.size === 0) {
+                this.broadcastToAgents({ type: 'extension_disconnected' });
+                this.broadcastDefaultToolsToAgents();
+            }
         });
         ws.on('error', (error) => {
             this.log(`Extension WebSocket error: ${error.message}`);
         });
-        // Request tools list, with retries in case the extension wasn't ready yet.
-        this.startToolsSyncLoop();
-        if (replacedConnection) {
-            this.replayPendingRequests(ws);
-        }
     }
     /**
      * Handle agent connection
@@ -162,19 +181,19 @@ export class RelayServer extends EventEmitter {
         };
         this.agents.set(agentId, agent);
         this.log(`Agent connected: ${agentId} (total: ${this.agents.size})`);
-        // Send current tools list
-        if (this.tools.length > 0) {
-            ws.send(JSON.stringify({ type: 'tools_list', data: this.tools }));
+        this.sendSessionStateToAgent(ws);
+        const defaultSession = this.getDefaultSession();
+        const tools = this.getToolsForSession(defaultSession);
+        if (tools.length > 0) {
+            ws.send(JSON.stringify({ type: 'tools_list', data: tools, sessionId: defaultSession?.sessionId }));
         }
-        // Send extension status
-        ws.send(JSON.stringify({
-            type: 'extension_status',
-            connected: this.extensionWs !== null
-        }));
         ws.on('message', (data) => {
             try {
                 const message = JSON.parse(data.toString());
-                this.handleAgentMessage(agentId, message);
+                this.handleAgentMessage(agentId, message).catch((error) => {
+                    const reason = error instanceof Error ? error.message : String(error);
+                    this.log(`Unhandled agent message failure (${agentId}): ${reason}`);
+                });
             }
             catch (error) {
                 this.log(`Failed to parse agent message: ${error}`);
@@ -198,26 +217,18 @@ export class RelayServer extends EventEmitter {
      * Handle message from extension
      */
     handleExtensionMessage(sourceWs, message) {
-        if (this.extensionWs !== sourceWs) {
-            this.log(`Ignoring stale extension message: ${message.type}`);
+        const session = this.ensureSessionForSocket(sourceWs, message);
+        if (!session) {
+            this.log(`Ignoring extension message before handshake: ${message.type}`);
             return;
         }
-        this.log(`Extension message: ${message.type}`);
+        this.log(`Extension message (${session.sessionId}): ${message.type}`);
         if (message.type === 'connected') {
-            // Local extension clients announce their websocket handshake with a
-            // standalone `connected` message. That is not itself a failure signal,
-            // and rejecting pending requests here breaks otherwise healthy reconnects.
-            return;
-        }
-        // Handle tools list
-        if (message.type === 'tools_list') {
-            this.tools = message.data;
-            this.stopToolsSyncLoop();
-            // Broadcast to all agents
-            this.broadcastToAgents({ type: 'tools_list', data: this.tools });
             return;
         }
-        // Handle response to a request
+        // Handle response to a pending request first — this must run before the
+        // tools_list broadcast so that `refreshTools()` resolves promptly instead
+        // of waiting for its 30 s timeout.
         if (message.requestId) {
             const pending = this.pendingRequests.get(message.requestId);
             if (pending) {
@@ -225,59 +236,212 @@ export class RelayServer extends EventEmitter {
                 // Forward response to the requesting agent
                 const agent = this.agents.get(pending.agentId);
                 if (agent) {
-                    agent.ws.send(JSON.stringify({
-                        ...message,
-                        requestId: pending.originalRequestId,
-                    }));
+                    if (message.type === 'tools_list') {
+                        agent.ws.send(JSON.stringify({
+                            type: 'tools_list',
+                            requestId: pending.originalRequestId,
+                            data: this.getToolsForSession(this.extensionSessions.get(pending.sessionId) || null),
+                            sessionId: pending.sessionId,
+                        }));
+                    }
+                    else {
+                        agent.ws.send(JSON.stringify({
+                            ...message,
+                            sessionId: session.sessionId,
+                            requestId: pending.originalRequestId,
+                        }));
+                    }
+                }
+                // For tools_list we still want to cache + broadcast to *other* agents
+                // so they stay in sync, but the requesting agent already got its copy.
+                if (message.type === 'tools_list') {
+                    session.tools = this.parseToolDefinitions(message.data);
+                    this.stopToolsSyncLoop(session);
+                    this.broadcastDefaultToolsToAgents(pending.agentId);
+                    this.broadcastSessionState();
                 }
                 return;
             }
         }
+        // Handle unsolicited tools list (e.g. extension announces on connect)
+        if (message.type === 'tools_list') {
+            session.tools = this.parseToolDefinitions(message.data);
+            this.stopToolsSyncLoop(session);
+            this.broadcastDefaultToolsToAgents();
+            this.broadcastSessionState();
+            return;
+        }
         // Broadcast other messages to all agents
-        this.broadcastToAgents(message);
+        this.broadcastToAgents({ ...message, sessionId: session.sessionId });
     }
     /**
      * Handle message from an agent
      */
-    handleAgentMessage(agentId, message) {
-        this.log(`Agent ${agentId} message: ${message.type}`);
-        if (!this.extensionWs) {
-            // No extension connected, send error back
+    async handleAgentMessage(agentId, message) {
+        try {
+            this.log(`Agent ${agentId} message: ${message.type}`);
+            if (message.type === 'list_sessions') {
+                const agent = this.agents.get(agentId);
+                if (agent && message.requestId) {
+                    agent.ws.send(JSON.stringify({
+                        type: 'sessions_list',
+                        requestId: message.requestId,
+                        sessions: this.buildSessionsList(),
+                    }));
+                }
+                return;
+            }
+            const requestedSessionId = typeof message.data?.sessionId === 'string' ? message.data.sessionId : undefined;
+            const targetSession = this.resolveTargetSession(requestedSessionId);
             const agent = this.agents.get(agentId);
-            if (agent && message.requestId) {
+            if (!agent || !message.requestId) {
+                return;
+            }
+            if (message.type === 'list_tools') {
+                if (requestedSessionId && !targetSession) {
+                    agent.ws.send(JSON.stringify({
+                        type: 'error',
+                        requestId: message.requestId,
+                        error: `No browser session connected for sessionId=${requestedSessionId}`,
+                    }));
+                    return;
+                }
+                agent.ws.send(JSON.stringify({
+                    type: 'tools_list',
+                    requestId: message.requestId,
+                    data: this.getToolsForSession(targetSession),
+                    sessionId: targetSession?.sessionId,
+                }));
+                return;
+            }
+            if (message.type === 'call_tool') {
+                const requestedToolName = message.data?.name;
+                if (typeof requestedToolName !== 'string' || requestedToolName.trim().length === 0) {
+                    agent.ws.send(JSON.stringify({
+                        type: 'error',
+                        requestId: message.requestId,
+                        error: 'Tool name is required',
+                    }));
+                    return;
+                }
+                if (requestedSessionId && !targetSession) {
+                    agent.ws.send(JSON.stringify({
+                        type: 'error',
+                        requestId: message.requestId,
+                        error: `No browser session connected for sessionId=${requestedSessionId}`,
+                    }));
+                    return;
+                }
+                const extensionTool = this.findExtensionTool(targetSession, requestedToolName);
+                if (extensionTool && targetSession) {
+                    const relayRequestId = `relay_${++this.requestIdCounter}`;
+                    const cleanData = message.data ? { ...message.data } : undefined;
+                    if (cleanData && 'sessionId' in cleanData) {
+                        delete cleanData.sessionId;
+                    }
+                    const forwardMessage = {
+                        ...message,
+                        requestId: relayRequestId,
+                        ...(cleanData ? { data: cleanData } : {}),
+                    };
+                    this.pendingRequests.set(relayRequestId, {
+                        agentId,
+                        originalRequestId: message.requestId,
+                        lastSentAt: Date.now(),
+                        forwardMessage,
+                        sessionId: targetSession.sessionId,
+                    });
+                    targetSession.ws.send(JSON.stringify(forwardMessage));
+                    return;
+                }
+                if (!this.hasConnectedExtensionSession() && this.findFallbackTool(requestedToolName)) {
+                    try {
+                        const args = message.data?.arguments && typeof message.data.arguments === 'object'
+                            ? message.data.arguments
+                            : {};
+                        const result = await this.devtoolsFallback.callTool(requestedToolName, args);
+                        agent.ws.send(JSON.stringify({
+                            type: 'tool_result',
+                            requestId: message.requestId,
+                            data: result,
+                            sessionId: targetSession?.sessionId,
+                        }));
+                    }
+                    catch (error) {
+                        const reason = error instanceof Error ? error.message : String(error);
+                        agent.ws.send(JSON.stringify({
+                            type: 'error',
+                            requestId: message.requestId,
+                            error: reason,
+                            sessionId: targetSession?.sessionId,
+                        }));
+                    }
+                    return;
+                }
                 agent.ws.send(JSON.stringify({
                     type: 'error',
                     requestId: message.requestId,
-                    error: 'No extension connected',
+                    error: targetSession
+                        ? `Tool not found: ${requestedToolName}`
+                        : 'No extension connected',
+                }));
+                return;
+            }
+            if (!targetSession) {
+                // No extension connected, send error back
+                agent.ws.send(JSON.stringify({
+                    type: 'error',
+                    requestId: message.requestId,
+                    error: requestedSessionId
+                        ? `No browser session connected for sessionId=${requestedSessionId}`
+                        : 'No extension connected',
+                }));
+                return;
+            }
+            // Generate relay request ID
+            const relayRequestId = `relay_${++this.requestIdCounter}`;
+            const cleanData = message.data ? { ...message.data } : undefined;
+            if (cleanData && 'sessionId' in cleanData) {
+                delete cleanData.sessionId;
+            }
+            const forwardMessage = {
+                ...message,
+                requestId: relayRequestId,
+                ...(cleanData ? { data: cleanData } : {}),
+            };
+            // Store pending request mapping so it can be replayed if the extension
+            // swaps sockets mid-flight.
+            this.pendingRequests.set(relayRequestId, {
+                agentId,
+                originalRequestId: message.requestId,
+                lastSentAt: Date.now(),
+                forwardMessage,
+                sessionId: targetSession.sessionId,
+            });
+            // Forward to extension with relay request ID
+            targetSession.ws.send(JSON.stringify(forwardMessage));
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            this.log(`Failed to handle agent message (${agentId}, ${message.type}): ${reason}`);
+            const agent = this.agents.get(agentId);
+            if (agent && message.requestId && agent.ws.readyState === WebSocket.OPEN) {
+                agent.ws.send(JSON.stringify({
+                    type: 'error',
+                    requestId: message.requestId,
+                    error: `Relay error: ${reason}`,
                 }));
             }
-            return;
         }
-        // Generate relay request ID
-        const relayRequestId = `relay_${++this.requestIdCounter}`;
-        const forwardMessage = {
-            ...message,
-            requestId: relayRequestId,
-        };
-        // Store pending request mapping so it can be replayed if the extension
-        // swaps sockets mid-flight.
-        this.pendingRequests.set(relayRequestId, {
-            agentId,
-            originalRequestId: message.requestId,
-            lastSentAt: Date.now(),
-            forwardMessage,
-        });
-        // Forward to extension with relay request ID
-        this.extensionWs.send(JSON.stringify(forwardMessage));
     }
     /**
      * Request tools list from extension
      */
-    requestToolsFromExtension() {
-        if (!this.extensionWs)
+    requestToolsFromExtension(session) {
+        if (session.ws.readyState !== WebSocket.OPEN)
             return;
         const requestId = `relay_${++this.requestIdCounter}`;
-        this.extensionWs.send(JSON.stringify({
+        session.ws.send(JSON.stringify({
             type: 'list_tools',
             requestId,
         }));
@@ -289,16 +453,19 @@ export class RelayServer extends EventEmitter {
      * same relay request ID lets us survive a transient socket swap without
      * dropping the original MCP call or double-running it under normal reconnects.
      */
-    replayPendingRequests(targetWs) {
+    replayPendingRequests(session) {
         if (this.pendingRequests.size === 0)
             return;
-        if (targetWs.readyState !== WebSocket.OPEN)
+        if (session.ws.readyState !== WebSocket.OPEN)
             return;
-        this.log(`Replaying ${this.pendingRequests.size} pending request(s) on replacement connection`);
-        for (const [relayRequestId, pending] of this.pendingRequests) {
+        const pendingForSession = [...this.pendingRequests.entries()].filter(([, pending]) => pending.sessionId === session.sessionId);
+        if (pendingForSession.length === 0)
+            return;
+        this.log(`Replaying ${pendingForSession.length} pending request(s) on replacement connection for ${session.sessionId}`);
+        for (const [relayRequestId, pending] of pendingForSession) {
             pending.lastSentAt = Date.now();
             try {
-                targetWs.send(JSON.stringify(pending.forwardMessage));
+                session.ws.send(JSON.stringify(pending.forwardMessage));
             }
             catch (error) {
                 this.log(`Failed to replay ${relayRequestId}: ${error}`);
@@ -308,29 +475,31 @@ export class RelayServer extends EventEmitter {
     /**
      * Keep requesting tools until extension responds with tools_list.
      */
-    startToolsSyncLoop() {
-        this.stopToolsSyncLoop();
-        this.requestToolsFromExtension();
-        this.toolsSyncTimer = setInterval(() => {
-            if (!this.extensionWs) {
-                this.stopToolsSyncLoop();
+    startToolsSyncLoop(session) {
+        this.stopToolsSyncLoop(session);
+        this.requestToolsFromExtension(session);
+        session.toolsSyncTimer = setInterval(() => {
+            if (session.ws.readyState !== WebSocket.OPEN) {
+                this.stopToolsSyncLoop(session);
                 return;
             }
-            this.requestToolsFromExtension();
+            this.requestToolsFromExtension(session);
         }, 1_000);
     }
-    stopToolsSyncLoop() {
-        if (this.toolsSyncTimer) {
-            clearInterval(this.toolsSyncTimer);
-            this.toolsSyncTimer = null;
+    stopToolsSyncLoop(session) {
+        if (session.toolsSyncTimer) {
+            clearInterval(session.toolsSyncTimer);
+            session.toolsSyncTimer = null;
         }
     }
     /**
      * Broadcast message to all connected agents
      */
-    broadcastToAgents(message) {
+    broadcastToAgents(message, excludeAgentId) {
         const payload = JSON.stringify(message);
         for (const agent of this.agents.values()) {
+            if (agent.id === excludeAgentId)
+                continue;
             try {
                 agent.ws.send(payload);
             }
@@ -363,12 +532,19 @@ export class RelayServer extends EventEmitter {
             }
         }
         this.agents.clear();
-        // Close extension connection
-        if (this.extensionWs) {
-            this.extensionWs.close();
-            this.extensionWs = null;
+        // Close extension connections
+        for (const session of this.extensionSessions.values()) {
+            try {
+                session.ws.close();
+            }
+            catch (error) {
+                // Ignore
+            }
+            this.stopToolsSyncLoop(session);
         }
-        this.stopToolsSyncLoop();
+        this.extensionSessions.clear();
+        this.socketToSessionId.clear();
+        await this.devtoolsFallback.stop();
         // Close servers
         if (this.agentWss) {
             this.agentWss.close();
@@ -398,6 +574,175 @@ export class RelayServer extends EventEmitter {
             // Ignore log errors
         }
     }
+    ensureSessionForSocket(ws, message) {
+        const existingSessionId = this.socketToSessionId.get(ws);
+        if (existingSessionId) {
+            return this.extensionSessions.get(existingSessionId) || null;
+        }
+        const announcedSessionId = this.extractAnnouncedSessionId(message) || `session_${++this.anonymousSessionCounter}`;
+        const existing = this.extensionSessions.get(announcedSessionId);
+        if (existing) {
+            const previousWs = existing.ws;
+            if (previousWs !== ws) {
+                this.log(`Extension session ${announcedSessionId} reconnecting, replacing previous socket`);
+                this.socketToSessionId.delete(previousWs);
+                existing.ws = ws;
+                existing.connectedAt = Date.now();
+                this.socketToSessionId.set(ws, announcedSessionId);
+                this.broadcastSessionState();
+                this.startToolsSyncLoop(existing);
+                this.replayPendingRequests(existing);
+                try {
+                    previousWs.close();
+                }
+                catch (error) {
+                    // ignore close errors on replaced sockets
+                }
+            }
+            return existing;
+        }
+        const session = {
+            ws,
+            sessionId: announcedSessionId,
+            connectedAt: Date.now(),
+            tools: [],
+            toolsSyncTimer: null,
+        };
+        this.extensionSessions.set(announcedSessionId, session);
+        this.socketToSessionId.set(ws, announcedSessionId);
+        this.broadcastSessionState();
+        this.startToolsSyncLoop(session);
+        return session;
+    }
+    extractAnnouncedSessionId(message) {
+        if (typeof message.sessionId === 'string' && message.sessionId.trim().length > 0) {
+            return message.sessionId.trim();
+        }
+        if (message.data && typeof message.data === 'object') {
+            const candidate = message.data.sessionId;
+            if (typeof candidate === 'string' && candidate.trim().length > 0) {
+                return candidate.trim();
+            }
+        }
+        return undefined;
+    }
+    buildSessionsList() {
+        return [...this.extensionSessions.values()].map((session) => ({
+            sessionId: session.sessionId,
+            connected: session.ws.readyState === WebSocket.OPEN,
+            connectedAt: session.connectedAt,
+            toolCount: session.tools.length,
+        }));
+    }
+    getDefaultSession() {
+        for (const session of this.extensionSessions.values()) {
+            if (session.ws.readyState === WebSocket.OPEN) {
+                return session;
+            }
+        }
+        return null;
+    }
+    resolveTargetSession(requestedSessionId) {
+        if (requestedSessionId) {
+            const session = this.extensionSessions.get(requestedSessionId);
+            if (session && session.ws.readyState === WebSocket.OPEN) {
+                return session;
+            }
+            return null;
+        }
+        return this.getDefaultSession();
+    }
+    parseToolDefinitions(data) {
+        if (!Array.isArray(data)) {
+            return [];
+        }
+        return data
+            .filter((entry) => Boolean(entry) && typeof entry === 'object' && typeof entry.name === 'string')
+            .map((entry) => entry);
+    }
+    getToolsForSession(session) {
+        if (session) {
+            return [...session.tools];
+        }
+        if (this.hasConnectedExtensionSession()) {
+            return [];
+        }
+        return [...this.devtoolsFallback.getTools()];
+    }
+    findExtensionTool(session, toolName) {
+        if (!session) {
+            return undefined;
+        }
+        const key = normalizeToolName(toolName);
+        return session.tools.find((tool) => normalizeToolName(tool.name) === key);
+    }
+    findFallbackTool(toolName) {
+        const key = normalizeToolName(toolName);
+        return this.devtoolsFallback.getTools().find((tool) => normalizeToolName(tool.name) === key);
+    }
+    broadcastDefaultToolsToAgents(excludeAgentId) {
+        const defaultSession = this.getDefaultSession();
+        const tools = this.getToolsForSession(defaultSession);
+        this.broadcastToAgents({
+            type: 'tools_list',
+            data: tools,
+            sessionId: defaultSession?.sessionId,
+        }, excludeAgentId);
+    }
+    hasConnectedExtensionSession() {
+        return this.getDefaultSession() !== null;
+    }
+    sendSessionStateToAgent(ws) {
+        const sessions = this.buildSessionsList();
+        const defaultSession = this.getDefaultSession();
+        ws.send(JSON.stringify({
+            type: 'sessions_list',
+            sessions,
+            sessionIds: sessions.map((session) => session.sessionId),
+            connected: sessions.some((session) => session.connected),
+            sessionId: defaultSession?.sessionId,
+        }));
+        ws.send(JSON.stringify({
+            type: 'extension_status',
+            connected: sessions.some((session) => session.connected),
+            sessionIds: sessions.map((session) => session.sessionId),
+            sessionId: defaultSession?.sessionId,
+        }));
+    }
+    broadcastSessionState() {
+        const sessions = this.buildSessionsList();
+        const defaultSession = this.getDefaultSession();
+        this.broadcastToAgents({
+            type: 'sessions_list',
+            sessions,
+            sessionIds: sessions.map((session) => session.sessionId),
+            connected: sessions.some((session) => session.connected),
+            sessionId: defaultSession?.sessionId,
+        });
+        this.broadcastToAgents({
+            type: 'extension_status',
+            connected: sessions.some((session) => session.connected),
+            sessionIds: sessions.map((session) => session.sessionId),
+            sessionId: defaultSession?.sessionId,
+        });
+    }
+    rejectPendingRequestsForSession(sessionId, errorMessage) {
+        for (const [relayId, pending] of this.pendingRequests) {
+            if (pending.sessionId !== sessionId) {
+                continue;
+            }
+            this.pendingRequests.delete(relayId);
+            const agent = this.agents.get(pending.agentId);
+            if (agent && agent.ws.readyState === WebSocket.OPEN) {
+                agent.ws.send(JSON.stringify({
+                    type: 'error',
+                    requestId: pending.originalRequestId,
+                    error: errorMessage,
+                    sessionId,
+                }));
+            }
+        }
+    }
 }
 /**
  * Check if relay is already running