@mcp-fe/mcp-worker 0.0.17 → 0.1.1

package/mcp-service-worker.js

@@ -27614,185 +27614,241 @@ var Server = class extends Protocol {
   }
 };
 
-// libs/mcp-worker/src/lib/mcp-server.ts
-var mcpServer = new Server(
+// libs/mcp-worker/src/lib/tool-registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  register(definition, handler) {
+    this.tools.set(definition.name, definition);
+    this.handlers.set(definition.name, handler);
+  }
+  unregister(name) {
+    const deleted = this.tools.delete(name);
+    this.handlers.delete(name);
+    return deleted;
+  }
+  getTools() {
+    return Array.from(this.tools.values());
+  }
+  getHandler(name) {
+    return this.handlers.get(name);
+  }
+  clear() {
+    this.tools.clear();
+    this.handlers.clear();
+  }
+};
+var toolRegistry = new ToolRegistry();
+
+// libs/mcp-worker/src/lib/built-in-tools.ts
+var builtInTools = [
+  // get_user_events tool
   {
-    name: "mcp-worker-server",
-    version: "1.0.0"
+    definition: {
+      name: "get_user_events",
+      description: "Get user activity events (navigation, clicks, etc.)",
+      inputSchema: {
+        type: "object",
+        properties: {
+          type: {
+            type: "string",
+            enum: ["navigation", "click", "input", "custom"],
+            description: "Filter by event type"
+          },
+          startTime: {
+            type: "number",
+            description: "Start timestamp (Unix timestamp in milliseconds)"
+          },
+          endTime: {
+            type: "number",
+            description: "End timestamp (Unix timestamp in milliseconds)"
+          },
+          path: {
+            type: "string",
+            description: "Filter by path/URL"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of events to return",
+            default: 100
+          }
+        }
+      }
+    },
+    handler: async (args) => {
+      const schema = external_exports3.object({
+        type: external_exports3.enum(["navigation", "click", "input", "custom"]).optional(),
+        startTime: external_exports3.number().optional(),
+        endTime: external_exports3.number().optional(),
+        path: external_exports3.string().optional(),
+        limit: external_exports3.number().optional().default(100)
+      });
+      const validatedArgs = schema.parse(args || {});
+      const events = await queryEvents(validatedArgs);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ events }, null, 2)
+          }
+        ]
+      };
+    }
   },
+  // get_navigation_history tool
   {
-    capabilities: {
-      tools: {}
-    }
-  }
-);
-mcpServer.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: "get_user_events",
-        description: "Get user activity events (navigation, clicks, etc.)",
-        inputSchema: {
-          type: "object",
-          properties: {
-            type: {
-              type: "string",
-              enum: ["navigation", "click", "input", "custom"],
-              description: "Filter by event type"
-            },
-            startTime: {
-              type: "number",
-              description: "Start timestamp (Unix timestamp in milliseconds)"
-            },
-            endTime: {
-              type: "number",
-              description: "End timestamp (Unix timestamp in milliseconds)"
-            },
-            path: {
-              type: "string",
-              description: "Filter by path/URL"
-            },
-            limit: {
-              type: "number",
-              description: "Maximum number of events to return",
-              default: 100
-            }
+    definition: {
+      name: "get_navigation_history",
+      description: "Get user navigation history",
+      inputSchema: {
+        type: "object",
+        properties: {
+          limit: {
+            type: "number",
+            description: "Maximum number of navigation events to return",
+            default: 50
           }
         }
-      },
-      {
-        name: "get_navigation_history",
-        description: "Get user navigation history",
-        inputSchema: {
-          type: "object",
-          properties: {
-            limit: {
-              type: "number",
-              description: "Maximum number of navigation events to return",
-              default: 50
-            }
+      }
+    },
+    handler: async (args) => {
+      const schema = external_exports3.object({
+        limit: external_exports3.number().optional().default(50)
+      });
+      const validatedArgs = schema.parse(args || {});
+      const events = await queryEvents({
+        type: "navigation",
+        limit: validatedArgs.limit
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                navigationHistory: events.map((e) => ({
+                  from: e.from,
+                  to: e.to,
+                  path: e.path,
+                  timestamp: e.timestamp
+                }))
+              },
+              null,
+              2
+            )
           }
-        }
-      },
-      {
-        name: "get_click_events",
-        description: "Get user click events",
-        inputSchema: {
-          type: "object",
-          properties: {
-            element: {
-              type: "string",
-              description: "Filter by element selector or text"
-            },
-            limit: {
-              type: "number",
-              description: "Maximum number of click events to return",
-              default: 100
-            }
+        ]
+      };
+    }
+  },
+  // get_click_events tool
+  {
+    definition: {
+      name: "get_click_events",
+      description: "Get user click events",
+      inputSchema: {
+        type: "object",
+        properties: {
+          element: {
+            type: "string",
+            description: "Filter by element selector or text"
+          },
+          limit: {
+            type: "number",
+            description: "Maximum number of click events to return",
+            default: 100
           }
         }
       }
-    ]
-  };
-});
-mcpServer.setRequestHandler(
-  CallToolRequestSchema,
-  async (request) => {
-    const { name, arguments: args } = request.params;
-    switch (name) {
-      case "get_user_events": {
-        const schema = external_exports3.object({
-          type: external_exports3.enum(["navigation", "click", "input", "custom"]).optional(),
-          startTime: external_exports3.number().optional(),
-          endTime: external_exports3.number().optional(),
-          path: external_exports3.string().optional(),
-          limit: external_exports3.number().optional().default(100)
-        });
-        const validatedArgs = schema.parse(args || {});
-        const events = await queryEvents(validatedArgs);
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify({ events }, null, 2)
-            }
-          ]
-        };
+    },
+    handler: async (args) => {
+      const schema = external_exports3.object({
+        element: external_exports3.string().optional(),
+        limit: external_exports3.number().optional().default(100)
+      });
+      const validatedArgs = schema.parse(args || {});
+      const events = await queryEvents({
+        type: "click",
+        limit: validatedArgs.limit
+      });
+      let filteredEvents = events;
+      if (validatedArgs.element) {
+        const elementFilter = validatedArgs.element.toLowerCase();
+        filteredEvents = events.filter(
+          (e) => e.element?.toLowerCase().includes(elementFilter) || e.elementText?.toLowerCase().includes(elementFilter) || e.elementId?.toLowerCase().includes(elementFilter) || e.elementClass?.toLowerCase().includes(elementFilter)
+        );
       }
-      case "get_navigation_history": {
-        const schema = external_exports3.object({
-          limit: external_exports3.number().optional().default(50)
-        });
-        const validatedArgs = schema.parse(args || {});
-        const events = await queryEvents({
-          type: "navigation",
-          limit: validatedArgs.limit
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  navigationHistory: events.map((e) => ({
-                    from: e.from,
-                    to: e.to,
-                    path: e.path,
-                    timestamp: e.timestamp
-                  }))
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                clickEvents: filteredEvents.map((e) => ({
+                  element: e.element,
+                  elementId: e.elementId,
+                  elementClass: e.elementClass,
+                  elementText: e.elementText,
+                  path: e.path,
+                  timestamp: e.timestamp,
+                  metadata: e.metadata
+                }))
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  }
+];
+function registerBuiltInTools() {
+  builtInTools.forEach(({ definition, handler }) => {
+    toolRegistry.register(definition, handler);
+  });
+}
+
+// libs/mcp-worker/src/lib/mcp-server.ts
+function createMCPServer(options = {}) {
+  const {
+    name = "mcp-worker-server",
+    version: version2 = "1.0.0",
+    autoRegisterBuiltInTools = true
+  } = options;
+  if (autoRegisterBuiltInTools) {
+    registerBuiltInTools();
+  }
+  const server = new Server(
+    {
+      name,
+      version: version2
+    },
+    {
+      capabilities: {
+        tools: {}
       }
-      case "get_click_events": {
-        const schema = external_exports3.object({
-          element: external_exports3.string().optional(),
-          limit: external_exports3.number().optional().default(100)
-        });
-        const validatedArgs = schema.parse(args || {});
-        const events = await queryEvents({
-          type: "click",
-          limit: validatedArgs.limit
-        });
-        let filteredEvents = events;
-        if (validatedArgs.element) {
-          const elementFilter = validatedArgs.element.toLowerCase();
-          filteredEvents = events.filter(
-            (e) => e.element?.toLowerCase().includes(elementFilter) || e.elementText?.toLowerCase().includes(elementFilter) || e.elementId?.toLowerCase().includes(elementFilter) || e.elementClass?.toLowerCase().includes(elementFilter)
-          );
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  clickEvents: filteredEvents.map((e) => ({
-                    element: e.element,
-                    elementId: e.elementId,
-                    elementClass: e.elementClass,
-                    elementText: e.elementText,
-                    path: e.path,
-                    timestamp: e.timestamp,
-                    metadata: e.metadata
-                  }))
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: toolRegistry.getTools()
+    };
+  });
+  server.setRequestHandler(
+    CallToolRequestSchema,
+    async (request) => {
+      const { name: name2, arguments: args } = request.params;
+      const handler = toolRegistry.getHandler(name2);
+      if (!handler) {
+        throw new Error(`Unknown tool: ${name2}`);
       }
-      default:
-        throw new Error(`Unknown tool: ${name}`);
+      return await handler(args);
     }
-  }
-);
+  );
+  return server;
+}
+var mcpServer = createMCPServer();
 
 // libs/mcp-worker/src/lib/websocket-transport.ts
 var WebSocketTransport = class {
@@ -27872,6 +27928,9 @@ var MCPController = class _MCPController {
   keepAliveInterval = null;
   requireAuth;
   isReconnectingForToken = false;
+  // Queue for tool registrations that arrive before MCP server is ready
+  pendingToolRegistrations = [];
+  isMCPServerReady = false;
   startKeepAlive() {
     if (this.keepAliveInterval) {
       clearInterval(this.keepAliveInterval);
@@ -27938,6 +27997,8 @@ var MCPController = class _MCPController {
             logger.log(
               "[MCPController] MCP Server connected to WebSocket transport"
             );
+            this.isMCPServerReady = true;
+            this.processPendingToolRegistrations();
             this.startKeepAlive();
             this.broadcastFn({ type: "CONNECTION_STATUS", connected: true });
             resolve();
@@ -28016,6 +28077,129 @@ var MCPController = class _MCPController {
   async handleGetEvents() {
     return queryEvents({ limit: 50 });
   }
+  /**
+   * Process pending tool registrations after MCP server is ready
+   * @private
+   */
+  processPendingToolRegistrations() {
+    if (this.pendingToolRegistrations.length === 0)
+      return;
+    logger.log(
+      `[MCPController] Processing ${this.pendingToolRegistrations.length} pending tool registrations`
+    );
+    const pending = [...this.pendingToolRegistrations];
+    this.pendingToolRegistrations = [];
+    pending.forEach(async ({ toolData, resolve, reject }) => {
+      try {
+        await this.handleRegisterToolInternal(toolData);
+        resolve();
+      } catch (error48) {
+        reject(error48 instanceof Error ? error48 : new Error(String(error48)));
+      }
+    });
+  }
+  async handleRegisterTool(toolData) {
+    if (!this.isMCPServerReady) {
+      logger.log(
+        `[MCPController] Queueing tool registration '${toolData["name"]}' (MCP server not ready yet)`
+      );
+      return new Promise((resolve, reject) => {
+        this.pendingToolRegistrations.push({
+          toolData,
+          resolve,
+          reject
+        });
+      });
+    }
+    return this.handleRegisterToolInternal(toolData);
+  }
+  /**
+   * Internal method to register tool (assumes MCP server is ready)
+   * @private
+   */
+  async handleRegisterToolInternal(toolData) {
+    const name = toolData["name"];
+    const description = toolData["description"];
+    const inputSchema = toolData["inputSchema"];
+    const handlerType = toolData["handlerType"];
+    if (!name || !description || !inputSchema) {
+      throw new Error(
+        "Missing required tool fields: name, description, inputSchema"
+      );
+    }
+    if (handlerType !== "proxy") {
+      throw new Error(
+        `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
+        });
+      });
+    };
+    toolRegistry.register(
+      {
+        name,
+        description,
+        inputSchema
+      },
+      handler
+    );
+    logger.log(
+      `[MCPController] Registered proxy tool: ${name} (forwards to main thread)`
+    );
+  }
+  pendingToolCalls;
+  handleToolCallResult(callId, result) {
+    if (!this.pendingToolCalls)
+      return;
+    const pendingCall = this.pendingToolCalls.get(callId);
+    if (!pendingCall) {
+      logger.warn(
+        `[MCPController] Received result for unknown call: ${callId}`
+      );
+      return;
+    }
+    clearTimeout(pendingCall.timeout);
+    this.pendingToolCalls.delete(callId);
+    const resultData = result;
+    if (resultData.success && resultData.result) {
+      pendingCall.resolve(resultData.result);
+    } else {
+      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}`);
+    }
+    return success2;
+  }
   getConnectionStatus() {
     return this.socket?.readyState === WebSocket.OPEN;
   }
@@ -28056,11 +28240,17 @@ var setBackendUrl = (url2) => {
         try {
           client.postMessage(message);
         } catch (e) {
-          logger.error("[ServiceWorker] Failed to post message to client:", e);
+          logger.error(
+            "[ServiceWorker] Failed to post message to client:",
+            e
+          );
         }
       });
     }).catch((err) => {
-      logger.error("[ServiceWorker] Failed to match clients for broadcast:", err);
+      logger.error(
+        "[ServiceWorker] Failed to match clients for broadcast:",
+        err
+      );
     });
   });
   return controller;
@@ -28105,64 +28295,175 @@ self.addEventListener("message", async (event) => {
     return;
   }
   if (msg["type"] === "STORE_EVENT") {
-    event.waitUntil((async () => {
-      try {
-        if (!backendUrl || !controller) {
+    event.waitUntil(
+      (async () => {
+        try {
+          if (!backendUrl || !controller) {
+            if (event.ports && event.ports[0]) {
+              event.ports[0].postMessage({
+                success: false,
+                error: "Worker not initialized"
+              });
+            } else {
+              logger.warn("[ServiceWorker] STORE_EVENT before INIT, ignoring");
+            }
+            return;
+          }
+          const userEvent = event.data.event;
+          await getController().handleStoreEvent(userEvent);
           if (event.ports && event.ports[0]) {
-            event.ports[0].postMessage({ success: false, error: "Worker not initialized" });
+            event.ports[0].postMessage({ success: true });
+          }
+        } catch (error48) {
+          logger.error("[ServiceWorker] Failed to store event:", error48);
+          if (event.ports && event.ports[0]) {
+            event.ports[0].postMessage({
+              success: false,
+              error: error48 instanceof Error ? error48.message : "Failed to store event"
+            });
           }
-          return;
-        }
-        const userEvent = event.data.event;
-        await getController().handleStoreEvent(userEvent);
-        if (event.ports && event.ports[0]) {
-          event.ports[0].postMessage({ success: true });
-        }
-      } catch (error48) {
-        if (event.ports && event.ports[0]) {
-          event.ports[0].postMessage({ success: false, error: error48 instanceof Error ? error48.message : "Worker not initialized" });
         }
-      }
-    })());
+      })()
+    );
     return;
   }
   if (msg["type"] === "GET_EVENTS") {
-    event.waitUntil((async () => {
-      try {
-        if (!backendUrl || !controller) {
+    event.waitUntil(
+      (async () => {
+        try {
+          if (!backendUrl || !controller) {
+            if (event.ports && event.ports[0]) {
+              event.ports[0].postMessage({
+                success: false,
+                error: "Worker not initialized"
+              });
+            }
+            return;
+          }
+          const events = await getController().handleGetEvents();
           if (event.ports && event.ports[0]) {
-            event.ports[0].postMessage({ success: false, error: "Worker not initialized" });
+            event.ports[0].postMessage({ success: true, events });
+          }
+        } catch (error48) {
+          if (event.ports && event.ports[0]) {
+            event.ports[0].postMessage({
+              success: false,
+              error: error48 instanceof Error ? error48.message : "Worker not initialized"
+            });
           }
-          return;
-        }
-        const events = await getController().handleGetEvents();
-        if (event.ports && event.ports[0]) {
-          event.ports[0].postMessage({ success: true, events });
-        }
-      } catch (error48) {
-        if (event.ports && event.ports[0]) {
-          event.ports[0].postMessage({ success: false, error: error48 instanceof Error ? error48.message : "Worker not initialized" });
         }
-      }
-    })());
+      })()
+    );
     return;
   }
   if (msg["type"] === "GET_CONNECTION_STATUS") {
     if (event.ports && event.ports[0]) {
       if (!backendUrl || !controller) {
-        event.ports[0].postMessage({ success: false, error: "Worker not initialized" });
+        event.ports[0].postMessage({
+          success: false,
+          error: "Worker not initialized"
+        });
       } else {
-        event.ports[0].postMessage({ success: true, connected: getController().getConnectionStatus() });
+        event.ports[0].postMessage({
+          success: true,
+          connected: getController().getConnectionStatus()
+        });
       }
     }
     return;
   }
+  if (msg["type"] === "REGISTER_TOOL") {
+    event.waitUntil(
+      (async () => {
+        try {
+          if (!backendUrl || !controller) {
+            if (event.ports && event.ports[0]) {
+              event.ports[0].postMessage({
+                success: false,
+                error: "Worker not initialized"
+              });
+            }
+            return;
+          }
+          const toolData = msg;
+          await getController().handleRegisterTool(toolData);
+          if (event.ports && event.ports[0]) {
+            event.ports[0].postMessage({ success: true });
+          }
+        } catch (error48) {
+          if (event.ports && event.ports[0]) {
+            event.ports[0].postMessage({
+              success: false,
+              error: error48 instanceof Error ? error48.message : "Failed to register tool"
+            });
+          }
+        }
+      })()
+    );
+    return;
+  }
+  if (msg["type"] === "UNREGISTER_TOOL") {
+    event.waitUntil(
+      (async () => {
+        try {
+          if (!backendUrl || !controller) {
+            if (event.ports && event.ports[0]) {
+              event.ports[0].postMessage({
+                success: false,
+                error: "Worker not initialized"
+              });
+            }
+            return;
+          }
+          const toolName = msg["name"];
+          if (!toolName) {
+            if (event.ports && event.ports[0]) {
+              event.ports[0].postMessage({
+                success: false,
+                error: "Tool name is required"
+              });
+            }
+            return;
+          }
+          const success2 = await getController().handleUnregisterTool(toolName);
+          if (event.ports && event.ports[0]) {
+            event.ports[0].postMessage({ success: success2 });
+          }
+        } catch (error48) {
+          if (event.ports && event.ports[0]) {
+            event.ports[0].postMessage({
+              success: false,
+              error: error48 instanceof Error ? error48.message : "Failed to unregister tool"
+            });
+          }
+        }
+      })()
+    );
+    return;
+  }
+  if (msg["type"] === "TOOL_CALL_RESULT") {
+    try {
+      if (!controller) {
+        logger.warn(
+          "[ServiceWorker] Received TOOL_CALL_RESULT but no controller"
+        );
+        return;
+      }
+      const callId = msg["callId"];
+      if (!callId) {
+        logger.warn("[ServiceWorker] TOOL_CALL_RESULT missing callId");
+        return;
+      }
+      getController().handleToolCallResult(callId, msg);
+    } catch (error48) {
+      logger.error("[ServiceWorker] Failed to handle TOOL_CALL_RESULT:", error48);
+    }
+    return;
+  }
 });
 self.addEventListener("install", (event) => {
   event.waitUntil(self.skipWaiting());
 });
 self.addEventListener("activate", (event) => {
-  event.waitUntil(
-    Promise.resolve(self.clients.claim())
-  );
+  event.waitUntil(Promise.resolve(self.clients.claim()));
 });