@mcp-fe/mcp-worker 0.0.16 → 0.0.17

package/LICENSE

@@ -188,7 +188,7 @@
       same page as the copyright notice for easier identification within
       third-party archives.
 
-   Copyright 2026 [name of copyright owner]
+   Copyright 2026 Michal Kopecky
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/index.js

@@ -1,3 +1,31 @@
+// libs/mcp-worker/src/lib/logger.ts
+var isProduction = typeof process !== "undefined" && true;
+var mcpDebug = typeof process !== "undefined" && process.env?.["MCP_DEBUG"];
+var debugEnabled = mcpDebug === "true" || !isProduction && mcpDebug !== "false";
+var logger = {
+  log: (...args) => {
+    if (debugEnabled) {
+      console.log(...args);
+    }
+  },
+  debug: (...args) => {
+    if (debugEnabled) {
+      console.debug(...args);
+    }
+  },
+  info: (...args) => {
+    console.info(...args);
+  },
+  error: (...args) => {
+    console.error(...args);
+  },
+  warn: (...args) => {
+    if (debugEnabled) {
+      console.warn(...args);
+    }
+  }
+};
+
 // libs/mcp-worker/src/lib/worker-client.ts
 var WorkerClient = class {
   // Configurable worker script URLs (defaults kept for backward compatibility)
@@ -17,12 +45,20 @@ var WorkerClient = class {
   // Initialize and choose worker implementation (prefer SharedWorker)
   // Accept either a ServiceWorkerRegistration OR WorkerInitOptions to configure URLs
   async init(registrationOrOptions) {
+    logger.log("[WorkerClient] init() called", {
+      hasOptions: !!registrationOrOptions,
+      currentWorkerType: this.workerType,
+      initInProgress: !!this.initPromise,
+      timestamp: Date.now()
+    });
     let explicitRegistration;
     const maybeReg = registrationOrOptions;
     if (maybeReg && typeof maybeReg.scope === "string") {
       explicitRegistration = registrationOrOptions;
+      logger.log("[WorkerClient] Using explicit ServiceWorker registration");
     } else if (registrationOrOptions) {
       const opts = registrationOrOptions;
+      logger.log("[WorkerClient] Using WorkerClientInitOptions:", opts);
       if (opts.sharedWorkerUrl)
         this.sharedWorkerUrl = opts.sharedWorkerUrl;
       if (opts.serviceWorkerUrl)
@@ -42,11 +78,14 @@ var WorkerClient = class {
         if (explicitRegistration) {
           this.serviceWorkerRegistration = explicitRegistration;
           this.workerType = "service";
-          console.log(
+          logger.info(
             "[WorkerClient] Using ServiceWorker (explicit registration)"
           );
           try {
-            const initMsg = { type: "INIT", backendUrl: this.backendWsUrl };
+            const initMsg = {
+              type: "INIT",
+              backendUrl: this.backendWsUrl
+            };
             if (this.pendingAuthToken)
               initMsg["token"] = this.pendingAuthToken;
             if (this.serviceWorkerRegistration.active) {
@@ -110,13 +149,19 @@ var WorkerClient = class {
       const portAfterInit = this.sharedWorkerPort;
       if (portAfterInit) {
         try {
-          const initMsg = { type: "INIT", backendUrl: this.backendWsUrl };
+          const initMsg = {
+            type: "INIT",
+            backendUrl: this.backendWsUrl
+          };
           if (this.pendingAuthToken)
             initMsg["token"] = this.pendingAuthToken;
           portAfterInit.postMessage(initMsg);
           this.pendingAuthToken = null;
         } catch (e) {
-          console.warn("[WorkerClient] Failed to send INIT to SharedWorker port:", e);
+          logger.warn(
+            "[WorkerClient] Failed to send INIT to SharedWorker port:",
+            e
+          );
         }
         portAfterInit.onmessage = (ev) => {
           try {
@@ -134,10 +179,10 @@ var WorkerClient = class {
           }
         };
       }
-      console.log("[WorkerClient] Using SharedWorker");
+      logger.info("[WorkerClient] Using SharedWorker");
       return true;
     } catch (error) {
-      console.warn(
+      logger.warn(
         "[WorkerClient] SharedWorker not available, falling back to ServiceWorker:",
         error
       );
@@ -151,7 +196,7 @@ var WorkerClient = class {
         if (existingRegistration) {
           this.serviceWorkerRegistration = existingRegistration;
           this.workerType = "service";
-          console.log(
+          logger.info(
             "[WorkerClient] Using existing ServiceWorker registration"
           );
           return;
@@ -160,9 +205,12 @@ var WorkerClient = class {
           this.serviceWorkerUrl
         );
         this.workerType = "service";
-        console.log("[WorkerClient] Using MCP ServiceWorker (fallback)");
+        logger.info("[WorkerClient] Using MCP ServiceWorker (fallback)");
         try {
-          const initMsg = { type: "INIT", backendUrl: this.backendWsUrl };
+          const initMsg = {
+            type: "INIT",
+            backendUrl: this.backendWsUrl
+          };
           if (this.pendingAuthToken)
             initMsg["token"] = this.pendingAuthToken;
           if (this.serviceWorkerRegistration.active) {
@@ -174,10 +222,7 @@ var WorkerClient = class {
         } catch {
         }
       } catch (error) {
-        console.error(
-          "[WorkerClient] Failed to register ServiceWorker:",
-          error
-        );
+        logger.error("[WorkerClient] Failed to register ServiceWorker:", error);
         throw error;
       }
     } else {
@@ -186,32 +231,70 @@ var WorkerClient = class {
   }
   // Low-level request that expects a reply via MessageChannel
   async request(type, payload, timeoutMs = 5e3) {
+    logger.log("[WorkerClient] Request started:", {
+      type,
+      payload,
+      timeoutMs,
+      workerType: this.workerType,
+      hasSharedWorkerPort: !!this.sharedWorkerPort,
+      hasServiceWorkerReg: !!this.serviceWorkerRegistration
+    });
     if (this.workerType === "shared" && this.sharedWorkerPort) {
       return new Promise((resolve, reject) => {
         const mc = new MessageChannel();
+        const requestId = Math.random().toString(36).substring(7);
+        const startTime = Date.now();
         const timer = setTimeout(() => {
+          const elapsed = Date.now() - startTime;
+          logger.error("[WorkerClient] Request timeout:", {
+            type,
+            requestId,
+            elapsed,
+            timeoutMs
+          });
           mc.port1.onmessage = null;
           reject(new Error("Request timeout"));
         }, timeoutMs);
         mc.port1.onmessage = (ev) => {
-          clearTimeout(timer);
-          if (ev.data && ev.data.success) {
-            resolve(ev.data);
-          } else if (ev.data && ev.data.success === false) {
-            reject(new Error(ev.data.error || "Worker error"));
-          } else {
-            resolve(ev.data);
+          try {
+            const elapsed = Date.now() - startTime;
+            logger.log("[WorkerClient] Request response received:", {
+              type,
+              requestId,
+              elapsed,
+              success: ev.data?.success
+            });
+            clearTimeout(timer);
+            if (ev.data && ev.data.success) {
+              resolve(ev.data);
+            } else if (ev.data && ev.data.success === false) {
+              reject(new Error(ev.data.error || "Worker error"));
+            } else {
+              resolve(ev.data);
+            }
+          } catch (handlerError) {
+            clearTimeout(timer);
+            mc.port1.onmessage = null;
+            reject(
+              handlerError instanceof Error ? handlerError : new Error(String(handlerError))
+            );
           }
         };
         try {
           const port = this.sharedWorkerPort;
           if (!port) {
             clearTimeout(timer);
+            logger.error("[WorkerClient] SharedWorker port not available");
             return reject(new Error("SharedWorker port not available"));
           }
+          logger.log("[WorkerClient] Posting message to SharedWorker:", {
+            type,
+            requestId
+          });
           port.postMessage({ type, ...payload || {} }, [mc.port2]);
         } catch (e) {
           clearTimeout(timer);
+          logger.error("[WorkerClient] Failed to post message:", e);
           reject(e instanceof Error ? e : new Error(String(e)));
         }
       });
@@ -221,6 +304,7 @@ var WorkerClient = class {
       if (!reg)
         throw new Error("Service worker registration missing");
       if (!reg.active) {
+        logger.log("[WorkerClient] ServiceWorker not active, waiting...");
         await navigator.serviceWorker.ready;
         if (!reg.active) {
           throw new Error("Service worker not active");
@@ -228,31 +312,66 @@ var WorkerClient = class {
       }
       return new Promise((resolve, reject) => {
         const mc = new MessageChannel();
+        const requestId = Math.random().toString(36).substring(7);
+        const startTime = Date.now();
         const timer = setTimeout(() => {
+          const elapsed = Date.now() - startTime;
+          logger.error("[WorkerClient] ServiceWorker request timeout:", {
+            type,
+            requestId,
+            elapsed,
+            timeoutMs
+          });
           mc.port1.onmessage = null;
           reject(new Error("Request timeout"));
         }, timeoutMs);
         mc.port1.onmessage = (ev) => {
-          clearTimeout(timer);
-          if (ev.data && ev.data.success) {
-            resolve(ev.data);
-          } else if (ev.data && ev.data.success === false) {
-            reject(new Error(ev.data.error || "Worker error"));
-          } else {
-            resolve(ev.data);
+          try {
+            const elapsed = Date.now() - startTime;
+            logger.log("[WorkerClient] ServiceWorker response received:", {
+              type,
+              requestId,
+              elapsed,
+              success: ev.data?.success
+            });
+            clearTimeout(timer);
+            if (ev.data && ev.data.success) {
+              resolve(ev.data);
+            } else if (ev.data && ev.data.success === false) {
+              reject(new Error(ev.data.error || "Worker error"));
+            } else {
+              resolve(ev.data);
+            }
+          } catch (handlerError) {
+            clearTimeout(timer);
+            mc.port1.onmessage = null;
+            reject(
+              handlerError instanceof Error ? handlerError : new Error(String(handlerError))
+            );
           }
         };
         try {
           const active = reg.active;
           if (!active) {
             clearTimeout(timer);
+            logger.error(
+              "[WorkerClient] ServiceWorker active instance not available"
+            );
             return reject(
               new Error("Service worker active instance not available")
             );
           }
+          logger.log("[WorkerClient] Posting message to ServiceWorker:", {
+            type,
+            requestId
+          });
           active.postMessage({ type, ...payload || {} }, [mc.port2]);
         } catch (e) {
           clearTimeout(timer);
+          logger.error(
+            "[WorkerClient] Failed to post message to ServiceWorker:",
+            e
+          );
           reject(e instanceof Error ? e : new Error(String(e)));
         }
       });
@@ -265,7 +384,7 @@ var WorkerClient = class {
       try {
         this.sharedWorkerPort.postMessage({ type, ...payload || {} });
       } catch (e) {
-        console.error("[WorkerClient] Failed to post to SharedWorker:", e);
+        logger.error("[WorkerClient] Failed to post to SharedWorker:", e);
       }
       return;
     }
@@ -276,7 +395,7 @@ var WorkerClient = class {
           ...payload || {}
         });
       } catch (e) {
-        console.error(
+        logger.error(
           "[WorkerClient] Failed to post to ServiceWorker (active):",
           e
         );
@@ -290,7 +409,7 @@ var WorkerClient = class {
           ...payload || {}
         });
       } catch (e) {
-        console.error(
+        logger.error(
           "[WorkerClient] Failed to post to ServiceWorker.controller:",
           e
         );
@@ -311,7 +430,7 @@ var WorkerClient = class {
           token
         });
       } catch (e) {
-        console.error(
+        logger.error(
           "[WorkerClient] Failed to send auth token to ServiceWorker:",
           e
         );
@@ -323,7 +442,7 @@ var WorkerClient = class {
           token
         });
       } catch (e) {
-        console.error(
+        logger.error(
           "[WorkerClient] Failed to send auth token to ServiceWorker.controller:",
           e
         );
@@ -360,7 +479,7 @@ var WorkerClient = class {
         this.sharedWorkerPort.postMessage({ type: "SET_AUTH_TOKEN", token });
         this.pendingAuthToken = null;
       } catch (e) {
-        console.error(
+        logger.error(
           "[WorkerClient] Failed to set auth token on SharedWorker:",
           e
         );
@@ -427,6 +546,7 @@ async function queryEvents(filters) {
 // libs/mcp-worker/src/index.ts
 var workerClient = new WorkerClient();
 export {
+  logger,
   queryEvents,
   workerClient
 };