@mcp-fe/mcp-worker 0.1.3 → 0.1.5

package/mcp-service-worker.js

@@ -27808,6 +27808,33 @@ function registerBuiltInTools() {
     toolRegistry.register(definition, handler);
   });
 }
+function registerTabManagementTool(tabManager) {
+  toolRegistry.register(
+    {
+      name: "list_browser_tabs",
+      description: "List all active browser tabs running this application. Returns tab IDs, URLs, titles, and active status. Use this to discover available tabs before calling tools with specific tabId parameters.",
+      inputSchema: {
+        type: "object",
+        properties: {}
+      }
+    },
+    async () => {
+      const tabs = tabManager.getAllTabs().map((tab) => ({
+        ...tab,
+        isActive: tab.tabId === tabManager.getActiveTabId(),
+        lastSeen: new Date(tab.lastSeen).toISOString()
+      }));
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(tabs, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
 
 // libs/mcp-worker/src/lib/mcp-server.ts
 function createMCPServer(options = {}) {
@@ -27912,6 +27939,249 @@ var logger = {
   }
 };
 
+// libs/mcp-worker/src/lib/tab-manager.ts
+var TabManager = class {
+  // Registry of all active tabs
+  tabRegistry = /* @__PURE__ */ new Map();
+  // Currently active/focused tab
+  activeTabId = null;
+  // Tool handlers per tab: Map<ToolName, Set<TabId>>
+  toolHandlersByTab = /* @__PURE__ */ new Map();
+  /**
+   * Register a new tab
+   */
+  registerTab(tabId, url2, title) {
+    if (!tabId) {
+      logger.warn("[TabManager] Cannot register tab: missing tabId");
+      return;
+    }
+    this.tabRegistry.set(tabId, {
+      url: url2 || "",
+      title: title || "",
+      lastSeen: Date.now()
+    });
+    logger.log(`[TabManager] Registered tab: ${tabId} (${title})`);
+  }
+  /**
+   * Set the active/focused tab
+   */
+  setActiveTab(tabId) {
+    if (!tabId) {
+      logger.warn("[TabManager] Cannot set active tab: missing tabId");
+      return;
+    }
+    this.activeTabId = tabId;
+    logger.log(`[TabManager] Active tab changed: ${tabId}`);
+    const tab = this.tabRegistry.get(tabId);
+    if (tab) {
+      tab.lastSeen = Date.now();
+    }
+  }
+  /**
+   * Get the currently active tab ID
+   */
+  getActiveTabId() {
+    return this.activeTabId;
+  }
+  /**
+   * Get all registered tabs
+   */
+  getAllTabs() {
+    return Array.from(this.tabRegistry.entries()).map(([tabId, info]) => ({
+      tabId,
+      ...info
+    }));
+  }
+  /**
+   * Get tab info by ID
+   */
+  getTabInfo(tabId) {
+    return this.tabRegistry.get(tabId);
+  }
+  /**
+   * Check if tab exists
+   */
+  hasTab(tabId) {
+    return this.tabRegistry.has(tabId);
+  }
+  /**
+   * Remove a tab from registry
+   */
+  removeTab(tabId) {
+    const existed = this.tabRegistry.delete(tabId);
+    if (existed) {
+      logger.log(`[TabManager] Removed tab: ${tabId}`);
+      if (this.activeTabId === tabId) {
+        this.activeTabId = null;
+      }
+      this.cleanupTabTools(tabId);
+    }
+    return existed;
+  }
+  /**
+   * Register a tool for a specific tab
+   */
+  registerToolForTab(toolName, tabId) {
+    if (!this.toolHandlersByTab.has(toolName)) {
+      this.toolHandlersByTab.set(toolName, /* @__PURE__ */ new Set());
+    }
+    const tabHandlers = this.toolHandlersByTab.get(toolName);
+    const isNewTab = !tabHandlers.has(tabId);
+    tabHandlers.add(tabId);
+    if (isNewTab) {
+      logger.log(
+        `[TabManager] Tab ${tabId} registered tool '${toolName}' (${tabHandlers.size} tab(s) total)`
+      );
+    } else {
+      logger.log(
+        `[TabManager] Tab ${tabId} re-registered tool '${toolName}' (already tracked)`
+      );
+    }
+    return isNewTab;
+  }
+  /**
+   * Unregister a tool from a specific tab
+   */
+  unregisterToolFromTab(toolName, tabId) {
+    const tabHandlers = this.toolHandlersByTab.get(toolName);
+    if (!tabHandlers || !tabHandlers.has(tabId)) {
+      return { wasRemoved: false, remainingTabs: 0, wasActiveTab: false };
+    }
+    const wasActiveTab = tabId === this.activeTabId;
+    tabHandlers.delete(tabId);
+    const remainingTabs = tabHandlers.size;
+    logger.log(
+      `[TabManager] Removed tab ${tabId} from tool '${toolName}' (${remainingTabs} tab(s) remaining)`
+    );
+    if (remainingTabs === 0) {
+      this.toolHandlersByTab.delete(toolName);
+    }
+    return { wasRemoved: true, remainingTabs, wasActiveTab };
+  }
+  /**
+   * Get all tabs that have a specific tool
+   */
+  getTabsForTool(toolName) {
+    return this.toolHandlersByTab.get(toolName) || /* @__PURE__ */ new Set();
+  }
+  /**
+   * Check if a tab has a specific tool
+   */
+  tabHasTool(toolName, tabId) {
+    const tabHandlers = this.toolHandlersByTab.get(toolName);
+    return tabHandlers ? tabHandlers.has(tabId) : false;
+  }
+  /**
+   * Smart routing: determine which tab should handle a tool call
+   *
+   * Priority:
+   * 1. Explicit tabId parameter (if provided and valid)
+   * 2. Only one tab has tool -> use it (regardless of focus)
+   * 3. Active tab has tool -> use it
+   * 4. Active tab doesn't have tool -> use first available
+   * 5. No active tab -> use first available
+   */
+  routeToolCall(toolName, explicitTabId) {
+    const tabHandlers = this.toolHandlersByTab.get(toolName);
+    if (!tabHandlers || tabHandlers.size === 0) {
+      return null;
+    }
+    if (explicitTabId) {
+      if (tabHandlers.has(explicitTabId)) {
+        return {
+          targetTabId: explicitTabId,
+          reason: "explicit tabId parameter"
+        };
+      } else {
+        return null;
+      }
+    }
+    if (tabHandlers.size === 1) {
+      const targetTabId = tabHandlers.values().next().value;
+      return {
+        targetTabId,
+        reason: "only one tab has tool"
+      };
+    }
+    if (this.activeTabId && tabHandlers.has(this.activeTabId)) {
+      return {
+        targetTabId: this.activeTabId,
+        reason: "active tab has tool"
+      };
+    }
+    const firstTab = tabHandlers.values().next().value;
+    const reason = this.activeTabId ? "active tab lacks tool, using first available" : "no active tab, using first available";
+    return {
+      targetTabId: firstTab,
+      reason
+    };
+  }
+  /**
+   * Get routing statistics for debugging
+   */
+  getRoutingInfo(toolName) {
+    const tabHandlers = this.toolHandlersByTab.get(toolName);
+    const tabsWithTool = tabHandlers ? Array.from(tabHandlers) : [];
+    return {
+      toolExists: tabsWithTool.length > 0,
+      tabsWithTool,
+      activeTabHasTool: this.activeTabId ? this.tabHasTool(toolName, this.activeTabId) : false,
+      recommendedTab: this.routeToolCall(toolName)?.targetTabId || null
+    };
+  }
+  /**
+   * Clean up all tools for a specific tab
+   * @private
+   */
+  cleanupTabTools(tabId) {
+    const removedTools = [];
+    for (const [toolName, tabHandlers] of this.toolHandlersByTab.entries()) {
+      if (tabHandlers.has(tabId)) {
+        tabHandlers.delete(tabId);
+        removedTools.push(toolName);
+        if (tabHandlers.size === 0) {
+          this.toolHandlersByTab.delete(toolName);
+        }
+      }
+    }
+    if (removedTools.length > 0) {
+      logger.log(
+        `[TabManager] Cleaned up ${removedTools.length} tool(s) for tab ${tabId}: ${removedTools.join(", ")}`
+      );
+    }
+  }
+  /**
+   * Get statistics for monitoring
+   */
+  getStats() {
+    const toolsPerTab = {};
+    for (const [tabId] of this.tabRegistry) {
+      let toolCount = 0;
+      for (const tabHandlers of this.toolHandlersByTab.values()) {
+        if (tabHandlers.has(tabId)) {
+          toolCount++;
+        }
+      }
+      toolsPerTab[tabId] = toolCount;
+    }
+    return {
+      totalTabs: this.tabRegistry.size,
+      activeTabId: this.activeTabId,
+      totalTools: this.toolHandlersByTab.size,
+      toolsPerTab
+    };
+  }
+  /**
+   * Clear all data (for testing)
+   */
+  clear() {
+    this.tabRegistry.clear();
+    this.activeTabId = null;
+    this.toolHandlersByTab.clear();
+    logger.log("[TabManager] Cleared all data");
+  }
+};
+
 // libs/mcp-worker/src/lib/mcp-controller.ts
 var MAX_RECONNECT_DELAY = 3e4;
 var INITIAL_RECONNECT_DELAY = 1e3;
@@ -27920,6 +28190,7 @@ var MCPController = class _MCPController {
     this.backendUrl = backendUrl2;
     this.broadcastFn = broadcastFn;
     this.requireAuth = requireAuth;
+    registerTabManagementTool(this.tabManager);
   }
   socket = null;
   transport = null;
@@ -27931,6 +28202,40 @@ var MCPController = class _MCPController {
   // Queue for tool registrations that arrive before MCP server is ready
   pendingToolRegistrations = [];
   isMCPServerReady = false;
+  // Multi-tab support via TabManager
+  tabManager = new TabManager();
+  // Map to track pending tool calls
+  pendingToolCalls = /* @__PURE__ */ new Map();
+  /**
+   * Handle tab registration from WorkerClient
+   * @public
+   */
+  handleRegisterTab(data) {
+    const tabId = data["tabId"];
+    const url2 = data["url"];
+    const title = data["title"];
+    if (!tabId) {
+      logger.warn("[MCPController] REGISTER_TAB missing tabId");
+      return;
+    }
+    this.tabManager.registerTab(tabId, url2, title);
+    this.broadcastFn({
+      type: "TAB_LIST_UPDATED",
+      tabs: this.tabManager.getAllTabs()
+    });
+  }
+  /**
+   * Handle active tab change from WorkerClient
+   * @public
+   */
+  handleSetActiveTab(data) {
+    const tabId = data["tabId"];
+    if (!tabId) {
+      logger.warn("[MCPController] SET_ACTIVE_TAB missing tabId");
+      return;
+    }
+    this.tabManager.setActiveTab(tabId);
+  }
   startKeepAlive() {
     if (this.keepAliveInterval) {
       clearInterval(this.keepAliveInterval);
@@ -28122,6 +28427,7 @@ var MCPController = class _MCPController {
     const description = toolData["description"];
     const inputSchema = toolData["inputSchema"];
     const handlerType = toolData["handlerType"];
+    const tabId = toolData["tabId"];
     if (!name || !description || !inputSchema) {
       throw new Error(
         "Missing required tool fields: name, description, inputSchema"
@@ -28132,49 +28438,72 @@ var MCPController = class _MCPController {
         `Unsupported handler type: ${handlerType}. Only 'proxy' handlers are supported.`
       );
     }
-    const handler = async (args) => {
-      const callId = `call_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
-      logger.log(`[MCPController] Proxying tool call to main thread: ${name}`, {
-        callId,
-        args
-      });
-      return new Promise((resolve, reject) => {
-        const pendingCall = {
-          resolve,
-          reject,
-          timeout: setTimeout(() => {
-            reject(new Error(`Tool call timeout: ${name}`));
-          }, 3e4)
-          // 30 second timeout
-        };
-        if (!this.pendingToolCalls) {
-          this.pendingToolCalls = /* @__PURE__ */ new Map();
-        }
-        this.pendingToolCalls.set(callId, pendingCall);
-        this.broadcastFn({
-          type: "CALL_TOOL",
-          toolName: name,
-          args,
-          callId
+    const isNewTab = this.tabManager.registerToolForTab(name, tabId);
+    if (!isNewTab) {
+      return;
+    }
+    const tabsWithTool = this.tabManager.getTabsForTool(name);
+    if (tabsWithTool.size === 1) {
+      const handler = async (args) => {
+        const argsObj = args;
+        const explicitTabId = argsObj["tabId"];
+        const routingResult = this.tabManager.routeToolCall(
+          name,
+          explicitTabId
+        );
+        if (!routingResult) {
+          const available = Array.from(this.tabManager.getTabsForTool(name));
+          if (explicitTabId) {
+            throw new Error(
+              `Tool '${name}' not available in tab '${explicitTabId}'. Available tabs: ${available.join(", ")}`
+            );
+          } else {
+            throw new Error(
+              `Tool '${name}' has no registered tabs. Please specify tabId parameter.`
+            );
+          }
+        }
+        const { targetTabId, reason } = routingResult;
+        logger.log(
+          `[MCPController] Routing '${name}' to tab ${targetTabId}: ${reason}`
+        );
+        const callId = `call_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+        return new Promise((resolve, reject) => {
+          const pendingCall = {
+            resolve,
+            reject,
+            timeout: setTimeout(() => {
+              this.pendingToolCalls.delete(callId);
+              reject(
+                new Error(`Tool call timeout: ${name} (tab: ${targetTabId})`)
+              );
+            }, 3e4)
+            // 30 second timeout
+          };
+          this.pendingToolCalls.set(callId, pendingCall);
+          this.broadcastFn({
+            type: "CALL_TOOL",
+            toolName: name,
+            args,
+            callId,
+            targetTabId
+          });
         });
-      });
-    };
-    toolRegistry.register(
-      {
-        name,
-        description,
-        inputSchema
-      },
-      handler
-    );
-    logger.log(
-      `[MCPController] Registered proxy tool: ${name} (forwards to main thread)`
-    );
+      };
+      toolRegistry.register(
+        {
+          name,
+          description,
+          inputSchema
+        },
+        handler
+      );
+      logger.log(
+        `[MCPController] Registered proxy tool: ${name} with smart multi-tab routing`
+      );
+    }
   }
-  pendingToolCalls;
   handleToolCallResult(callId, result) {
-    if (!this.pendingToolCalls)
-      return;
     const pendingCall = this.pendingToolCalls.get(callId);
     if (!pendingCall) {
       logger.warn(
@@ -28191,14 +28520,35 @@ var MCPController = class _MCPController {
       pendingCall.reject(new Error(resultData.error || "Tool call failed"));
     }
   }
-  async handleUnregisterTool(toolName) {
-    const success2 = toolRegistry.unregister(toolName);
-    if (success2) {
-      logger.log(`[MCPController] Unregistered tool: ${toolName}`);
-    } else {
-      logger.log(`[MCPController] Tool not found: ${toolName}`);
+  async handleUnregisterTool(toolName, tabId) {
+    if (!tabId) {
+      logger.warn(
+        `[MCPController] UNREGISTER_TOOL missing tabId for '${toolName}'`
+      );
+      return false;
+    }
+    const result = this.tabManager.unregisterToolFromTab(toolName, tabId);
+    if (!result.wasRemoved) {
+      logger.warn(
+        `[MCPController] Tool '${toolName}' not found in tab ${tabId}`
+      );
+      return false;
+    }
+    if (result.wasActiveTab && result.remainingTabs > 0) {
+      logger.log(
+        `[MCPController] Active tab ${tabId} unregistered '${toolName}', but ${result.remainingTabs} other tab(s) still have it. Future calls will route to available tabs.`
+      );
+    }
+    if (result.remainingTabs === 0) {
+      const success2 = toolRegistry.unregister(toolName);
+      if (success2) {
+        logger.log(
+          `[MCPController] Unregistered tool from MCP: ${toolName} (no tabs remaining)`
+        );
+      }
+      return success2;
     }
-    return success2;
+    return true;
   }
   getConnectionStatus() {
     return this.socket?.readyState === WebSocket.OPEN;
@@ -28232,27 +28582,44 @@ var getController = () => {
   return controller;
 };
 var setBackendUrl = (url2) => {
-  backendUrl = url2;
-  controller = null;
-  controller = MCPController.create(url2, (message) => {
-    self.clients.matchAll().then((clients) => {
-      clients.forEach((client) => {
-        try {
-          client.postMessage(message);
-        } catch (e) {
-          logger.error(
-            "[ServiceWorker] Failed to post message to client:",
-            e
-          );
-        }
+  if (controller && backendUrl === url2) {
+    logger.log(
+      "[ServiceWorker] Controller already initialized with same URL, reusing"
+    );
+    return controller;
+  }
+  if (backendUrl !== url2) {
+    logger.log(
+      `[ServiceWorker] Initializing/updating controller with URL: ${url2}`
+    );
+    backendUrl = url2;
+    if (controller) {
+      try {
+        controller.dispose();
+      } catch (e) {
+        logger.warn("[ServiceWorker] Failed to dispose old controller:", e);
+      }
+    }
+    controller = MCPController.create(url2, (message) => {
+      self.clients.matchAll().then((clients) => {
+        clients.forEach((client) => {
+          try {
+            client.postMessage(message);
+          } catch (e) {
+            logger.error(
+              "[ServiceWorker] Failed to post message to client:",
+              e
+            );
+          }
+        });
+      }).catch((err) => {
+        logger.error(
+          "[ServiceWorker] Failed to match clients for broadcast:",
+          err
+        );
       });
-    }).catch((err) => {
-      logger.error(
-        "[ServiceWorker] Failed to match clients for broadcast:",
-        err
-      );
     });
-  });
+  }
   return controller;
 };
 self.addEventListener("message", async (event) => {
@@ -28372,6 +28739,26 @@ self.addEventListener("message", async (event) => {
     }
     return;
   }
+  if (msg["type"] === "REGISTER_TAB") {
+    try {
+      if (controller) {
+        getController().handleRegisterTab(msg);
+      }
+    } catch (error48) {
+      logger.error("[ServiceWorker] Failed to register tab:", error48);
+    }
+    return;
+  }
+  if (msg["type"] === "SET_ACTIVE_TAB") {
+    try {
+      if (controller) {
+        getController().handleSetActiveTab(msg);
+      }
+    } catch (error48) {
+      logger.error("[ServiceWorker] Failed to set active tab:", error48);
+    }
+    return;
+  }
   if (msg["type"] === "REGISTER_TOOL") {
     event.waitUntil(
       (async () => {
@@ -28416,6 +28803,7 @@ self.addEventListener("message", async (event) => {
             return;
           }
           const toolName = msg["name"];
+          const tabId = msg["tabId"];
           if (!toolName) {
             if (event.ports && event.ports[0]) {
               event.ports[0].postMessage({
@@ -28425,7 +28813,10 @@ self.addEventListener("message", async (event) => {
             }
             return;
           }
-          const success2 = await getController().handleUnregisterTool(toolName);
+          const success2 = await getController().handleUnregisterTool(
+            toolName,
+            tabId
+          );
           if (event.ports && event.ports[0]) {
             event.ports[0].postMessage({ success: success2 });
           }