@mcp-fe/mcp-worker 0.0.17 → 0.1.0

package/index.js

@@ -42,6 +42,17 @@ var WorkerClient = class {
   connectionStatusCallbacks = /* @__PURE__ */ new Set();
   // Mutex/promise to prevent concurrent init runs
   initPromise = null;
+  // Initialization state
+  isInitialized = false;
+  initResolvers = [];
+  // Queue for operations that need to wait for initialization
+  pendingRegistrations = [];
+  // Map to store tool handlers in main thread
+  toolHandlers = /* @__PURE__ */ new Map();
+  // Tool registry for tracking registrations and reference counting
+  toolRegistry = /* @__PURE__ */ new Map();
+  // Subscribers for tool changes (for React hooks reactivity)
+  toolChangeListeners = /* @__PURE__ */ new Map();
   // Initialize and choose worker implementation (prefer SharedWorker)
   // Accept either a ServiceWorkerRegistration OR WorkerInitOptions to configure URLs
   async init(registrationOrOptions) {
@@ -98,18 +109,72 @@ var WorkerClient = class {
           return;
         }
         const sharedOk = await this.initSharedWorker();
-        if (sharedOk)
+        if (sharedOk) {
+          this.markAsInitialized();
           return;
+        }
         await this.initServiceWorkerFallback();
+        this.markAsInitialized();
       } finally {
         this.initPromise = null;
       }
     })();
     return this.initPromise;
   }
+  /**
+   * Mark worker as initialized and process pending registrations
+   * @private
+   */
+  markAsInitialized() {
+    this.isInitialized = true;
+    logger.log(
+      "[WorkerClient] Worker initialized, processing pending operations"
+    );
+    this.initResolvers.forEach((resolve) => resolve());
+    this.initResolvers = [];
+    const pending = [...this.pendingRegistrations];
+    this.pendingRegistrations = [];
+    pending.forEach(
+      async ({ name, description, inputSchema, handler, resolve, reject }) => {
+        try {
+          await this.registerToolInternal(
+            name,
+            description,
+            inputSchema,
+            handler
+          );
+          resolve();
+        } catch (error) {
+          reject(error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+    );
+  }
+  /**
+   * Wait for worker initialization
+   * @returns Promise that resolves when worker is initialized
+   */
+  async waitForInit() {
+    if (this.isInitialized) {
+      return Promise.resolve();
+    }
+    if (this.initPromise) {
+      await this.initPromise;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.initResolvers.push(resolve);
+    });
+  }
+  /**
+   * Check if worker is initialized
+   */
+  get initialized() {
+    return this.isInitialized;
+  }
   async initSharedWorker() {
     if (typeof SharedWorker === "undefined") {
-      return false;
+      return Promise.resolve(false);
     }
     try {
       this.sharedWorker = new SharedWorker(this.sharedWorkerUrl, {
@@ -140,7 +205,7 @@ var WorkerClient = class {
               resolved = true;
               this.workerType = "shared";
               p.onmessage = null;
-              resolve();
+              resolve(true);
             }
           } catch {
           }
@@ -174,6 +239,15 @@ var WorkerClient = class {
                 } catch {
                 }
               });
+            } else if (data && data.type === "CALL_TOOL") {
+              this.handleToolCall(data.toolName, data.args, data.callId).catch(
+                (error) => {
+                  logger.error(
+                    "[WorkerClient] Failed to handle tool call:",
+                    error
+                  );
+                }
+              );
             }
           } catch {
           }
@@ -205,6 +279,33 @@ var WorkerClient = class {
           this.serviceWorkerUrl
         );
         this.workerType = "service";
+        if ("serviceWorker" in navigator) {
+          navigator.serviceWorker.addEventListener(
+            "message",
+            (ev) => {
+              try {
+                const data = ev.data;
+                if (data && data.type === "CALL_TOOL") {
+                  this.handleToolCall(
+                    data.toolName,
+                    data.args,
+                    data.callId
+                  ).catch((error) => {
+                    logger.error(
+                      "[WorkerClient] Failed to handle tool call:",
+                      error
+                    );
+                  });
+                }
+              } catch (error) {
+                logger.error(
+                  "[WorkerClient] Error processing ServiceWorker message:",
+                  error
+                );
+              }
+            }
+          );
+        }
         logger.info("[WorkerClient] Using MCP ServiceWorker (fallback)");
         try {
           const initMsg = {
@@ -430,7 +531,7 @@ var WorkerClient = class {
           token
         });
       } catch (e) {
-        logger.error(
+        console.error(
           "[WorkerClient] Failed to send auth token to ServiceWorker:",
           e
         );
@@ -442,7 +543,7 @@ var WorkerClient = class {
           token
         });
       } catch (e) {
-        logger.error(
+        console.error(
           "[WorkerClient] Failed to send auth token to ServiceWorker.controller:",
           e
         );
@@ -490,6 +591,264 @@ var WorkerClient = class {
     } else {
     }
   }
+  /**
+   * Register a custom MCP tool dynamically
+   *
+   * The handler function runs in the MAIN THREAD (browser context), not in the worker.
+   * This means you have full access to:
+   * - React context, hooks, Redux store
+   * - DOM API, window, localStorage
+   * - All your imports and dependencies
+   * - Closures and external variables
+   *
+   * The worker acts as a proxy - it receives MCP tool calls and forwards them
+   * to your handler via MessageChannel.
+   *
+   * @param name - Tool name
+   * @param description - Tool description
+   * @param inputSchema - JSON Schema for tool inputs
+   * @param handler - Async function that handles the tool execution (runs in main thread)
+   * @returns Promise that resolves when tool is registered
+   *
+   * @example With full access to imports and context:
+   * ```typescript
+   * import { z } from 'zod';
+   * import { useMyStore } from './store';
+   *
+   * const store = useMyStore();
+   *
+   * await client.registerTool(
+   *   'validate_user',
+   *   'Validate user data',
+   *   { type: 'object', properties: { username: { type: 'string' } } },
+   *   async (args: any) => {
+   *     // Full access to everything!
+   *     const schema = z.object({ username: z.string().min(3) });
+   *     const validated = schema.parse(args);
+   *
+   *     // Can access store, context, etc.
+   *     const currentUser = store.getState().user;
+   *
+   *     return {
+   *       content: [{
+   *         type: 'text',
+   *         text: JSON.stringify({ validated, currentUser })
+   *       }]
+   *     };
+   *   }
+   * );
+   * ```
+   */
+  async registerTool(name, description, inputSchema, handler) {
+    if (!this.isInitialized) {
+      logger.log(
+        `[WorkerClient] Queueing tool registration '${name}' (worker not initialized yet)`
+      );
+      return new Promise((resolve, reject) => {
+        this.pendingRegistrations.push({
+          name,
+          description,
+          inputSchema,
+          handler,
+          resolve,
+          reject
+        });
+      });
+    }
+    return this.registerToolInternal(name, description, inputSchema, handler);
+  }
+  /**
+   * Internal method to register tool (assumes worker is initialized)
+   * @private
+   */
+  async registerToolInternal(name, description, inputSchema, handler) {
+    const existing = this.toolRegistry.get(name);
+    if (existing) {
+      existing.refCount++;
+      logger.log(
+        `[WorkerClient] Incremented ref count for '${name}': ${existing.refCount}`
+      );
+      this.toolHandlers.set(name, handler);
+      this.notifyToolChange(name);
+      return;
+    }
+    this.toolHandlers.set(name, handler);
+    await this.request("REGISTER_TOOL", {
+      name,
+      description,
+      inputSchema,
+      handlerType: "proxy"
+      // Tell worker this is a proxy handler
+    });
+    this.toolRegistry.set(name, {
+      refCount: 1,
+      description,
+      inputSchema,
+      isRegistered: true
+    });
+    logger.log(
+      `[WorkerClient] Registered tool '${name}' with main-thread handler`
+    );
+    this.notifyToolChange(name);
+  }
+  /**
+   * Unregister a previously registered MCP tool
+   * @param name - Tool name to unregister
+   * @returns Promise that resolves to true if tool was found and removed
+   */
+  async unregisterTool(name) {
+    const existing = this.toolRegistry.get(name);
+    if (!existing) {
+      logger.warn(`[WorkerClient] Cannot unregister '${name}': not found`);
+      return false;
+    }
+    existing.refCount--;
+    logger.log(
+      `[WorkerClient] Decremented ref count for '${name}': ${existing.refCount}`
+    );
+    if (existing.refCount <= 0) {
+      this.toolHandlers.delete(name);
+      const result = await this.request(
+        "UNREGISTER_TOOL",
+        { name }
+      );
+      this.toolRegistry.delete(name);
+      logger.log(`[WorkerClient] Unregistered tool '${name}'`);
+      this.notifyToolChange(name);
+      return result?.success ?? false;
+    }
+    this.notifyToolChange(name);
+    return true;
+  }
+  /**
+   * Subscribe to tool changes for a specific tool
+   * Returns unsubscribe function
+   */
+  onToolChange(toolName, callback) {
+    if (!this.toolChangeListeners.has(toolName)) {
+      this.toolChangeListeners.set(toolName, /* @__PURE__ */ new Set());
+    }
+    const listeners = this.toolChangeListeners.get(toolName);
+    listeners.add(callback);
+    const current = this.toolRegistry.get(toolName);
+    if (current) {
+      callback({
+        refCount: current.refCount,
+        isRegistered: current.isRegistered
+      });
+    } else {
+      callback(null);
+    }
+    return () => {
+      listeners.delete(callback);
+      if (listeners.size === 0) {
+        this.toolChangeListeners.delete(toolName);
+      }
+    };
+  }
+  /**
+   * Notify all listeners about tool changes
+   * @private
+   */
+  notifyToolChange(toolName) {
+    const listeners = this.toolChangeListeners.get(toolName);
+    if (!listeners || listeners.size === 0)
+      return;
+    const info = this.toolRegistry.get(toolName);
+    const payload = info ? {
+      refCount: info.refCount,
+      isRegistered: info.isRegistered
+    } : null;
+    listeners.forEach((callback) => {
+      try {
+        callback(payload);
+      } catch (error) {
+        logger.error("[WorkerClient] Error in tool change listener:", error);
+      }
+    });
+  }
+  /**
+   * Get tool info from registry
+   */
+  getToolInfo(toolName) {
+    const info = this.toolRegistry.get(toolName);
+    if (!info)
+      return null;
+    return {
+      refCount: info.refCount,
+      isRegistered: info.isRegistered
+    };
+  }
+  /**
+   * Get all registered tool names
+   */
+  getRegisteredTools() {
+    return Array.from(this.toolRegistry.keys()).filter(
+      (name) => this.toolRegistry.get(name)?.isRegistered
+    );
+  }
+  /**
+   * Check if a tool is registered
+   */
+  isToolRegistered(toolName) {
+    return this.toolRegistry.get(toolName)?.isRegistered ?? false;
+  }
+  /**
+   * Handle tool call from worker - execute handler in main thread and return result
+   * @private
+   */
+  async handleToolCall(toolName, args, callId) {
+    logger.log(`[WorkerClient] Handling tool call: ${toolName}`, {
+      callId,
+      args
+    });
+    try {
+      const handler = this.toolHandlers.get(toolName);
+      if (!handler) {
+        throw new Error(`Tool handler not found: ${toolName}`);
+      }
+      const result = await handler(args);
+      this.sendToolCallResult(callId, { success: true, result });
+    } catch (error) {
+      logger.error(`[WorkerClient] Tool call failed: ${toolName}`, error);
+      this.sendToolCallResult(callId, {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  /**
+   * Send tool call result back to worker
+   * @private
+   */
+  sendToolCallResult(callId, result) {
+    const message = {
+      type: "TOOL_CALL_RESULT",
+      callId,
+      success: result.success,
+      result: result.result,
+      error: result.error
+    };
+    if (this.workerType === "shared" && this.sharedWorkerPort) {
+      try {
+        this.sharedWorkerPort.postMessage(message);
+      } catch (error) {
+        logger.error(
+          "[WorkerClient] Failed to send result to SharedWorker:",
+          error
+        );
+      }
+    } else if (this.workerType === "service" && this.serviceWorkerRegistration?.active) {
+      try {
+        this.serviceWorkerRegistration.active.postMessage(message);
+      } catch (error) {
+        logger.error(
+          "[WorkerClient] Failed to send result to ServiceWorker:",
+          error
+        );
+      }
+    }
+  }
 };
 
 // libs/mcp-worker/src/lib/database.ts
@@ -546,6 +905,7 @@ async function queryEvents(filters) {
 // libs/mcp-worker/src/index.ts
 var workerClient = new WorkerClient();
 export {
+  WorkerClient,
   logger,
   queryEvents,
   workerClient