@mcp-fe/mcp-worker 0.0.16 → 0.0.17

package/mcp-service-worker.js

@@ -4375,13 +4375,13 @@ var require_core = __commonJS({
     }, warn() {
     }, error() {
     } };
-    function getLogger(logger) {
-      if (logger === false)
+    function getLogger(logger2) {
+      if (logger2 === false)
         return noLogs;
-      if (logger === void 0)
+      if (logger2 === void 0)
         return console;
-      if (logger.log && logger.warn && logger.error)
-        return logger;
+      if (logger2.log && logger2.warn && logger2.error)
+        return logger2;
       throw new Error("logger must implement log, warn and error methods");
     }
     var KEYWORD_NAME = /^[a-z_$][a-z0-9_$:-]*$/i;
@@ -11017,7 +11017,7 @@ __export(core_exports2, {
   parse: () => parse,
   parseAsync: () => parseAsync,
   prettifyError: () => prettifyError,
-  process: () => process,
+  process: () => process2,
   regexes: () => regexes_exports,
   registry: () => registry,
   safeDecode: () => safeDecode,
@@ -21417,7 +21417,7 @@ function initializeContext(params) {
     external: params?.external ?? void 0
   };
 }
-function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a2;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
@@ -21454,7 +21454,7 @@ function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
     if (parent) {
       if (!result.ref)
         result.ref = parent;
-      process(parent, ctx, params);
+      process2(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
@@ -21735,14 +21735,14 @@ function isTransforming(_schema, _ctx) {
 }
 var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
 var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
@@ -21999,7 +21999,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
   if (typeof maximum === "number")
     json2.maxItems = maximum;
   json2.type = "array";
-  json2.items = process(def.element, ctx, { ...params, path: [...params.path, "items"] });
+  json2.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] });
 };
 var objectProcessor = (schema, ctx, _json, params) => {
   const json2 = _json;
@@ -22008,7 +22008,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json2.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json2.properties[key] = process(shape[key], ctx, {
+    json2.properties[key] = process2(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -22031,7 +22031,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
     if (ctx.io === "output")
       json2.additionalProperties = false;
   } else if (def.catchall) {
-    json2.additionalProperties = process(def.catchall, ctx, {
+    json2.additionalProperties = process2(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -22040,7 +22040,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
-  const options = def.options.map((x, i) => process(x, ctx, {
+  const options = def.options.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
@@ -22052,11 +22052,11 @@ var unionProcessor = (schema, ctx, json2, params) => {
 };
 var intersectionProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  const a = process(def.left, ctx, {
+  const a = process2(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
   });
-  const b = process(def.right, ctx, {
+  const b = process2(def.right, ctx, {
     ...params,
     path: [...params.path, "allOf", 1]
   });
@@ -22073,11 +22073,11 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   json2.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-  const prefixItems = def.items.map((x, i) => process(x, ctx, {
+  const prefixItems = def.items.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, prefixPath, i]
   }));
-  const rest = def.rest ? process(def.rest, ctx, {
+  const rest = def.rest ? process2(def.rest, ctx, {
     ...params,
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
@@ -22117,7 +22117,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
-    const valueSchema = process(def.valueType, ctx, {
+    const valueSchema = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
@@ -22127,12 +22127,12 @@ var recordProcessor = (schema, ctx, _json, params) => {
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json2.propertyNames = process(def.keyType, ctx, {
+      json2.propertyNames = process2(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json2.additionalProperties = process(def.valueType, ctx, {
+    json2.additionalProperties = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -22147,7 +22147,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
 };
 var nullableProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  const inner = process(def.innerType, ctx, params);
+  const inner = process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
@@ -22158,20 +22158,20 @@ var nullableProcessor = (schema, ctx, json2, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json2.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
@@ -22179,7 +22179,7 @@ var prefaultProcessor = (schema, ctx, json2, params) => {
 };
 var catchProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   let catchValue;
@@ -22193,32 +22193,32 @@ var catchProcessor = (schema, ctx, json2, params) => {
 var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json2, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json2.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var lazyProcessor = (schema, ctx, _json, params) => {
   const innerType = schema._zod.innerType;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
@@ -22270,7 +22270,7 @@ function toJSONSchema(input, params) {
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
       const [_, schema] = entry;
-      process(schema, ctx2);
+      process2(schema, ctx2);
     }
     const schemas = {};
     const external = {
@@ -22293,7 +22293,7 @@ function toJSONSchema(input, params) {
     return { schemas };
   }
   const ctx = initializeContext({ ...params, processors: allProcessors });
-  process(input, ctx);
+  process2(input, ctx);
   extractDefs(ctx, input);
   return finalize(ctx, input);
 }
@@ -22351,7 +22351,7 @@ var JSONSchemaGenerator = class {
    * This must be called before emit().
    */
   process(schema, _params = { path: [], schemaPath: [] }) {
-    return process(schema, this.ctx, _params);
+    return process2(schema, this.ctx, _params);
   }
   /**
    * Emit the final JSON Schema after processing.
@@ -27828,6 +27828,34 @@ var WebSocketTransport = class {
   }
 };
 
+// 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/mcp-controller.ts
 var MAX_RECONNECT_DELAY = 3e4;
 var INITIAL_RECONNECT_DELAY = 1e3;
@@ -27843,6 +27871,7 @@ var MCPController = class _MCPController {
   authToken = null;
   keepAliveInterval = null;
   requireAuth;
+  isReconnectingForToken = false;
   startKeepAlive() {
     if (this.keepAliveInterval) {
       clearInterval(this.keepAliveInterval);
@@ -27864,7 +27893,9 @@ var MCPController = class _MCPController {
   }
   async connectWebSocket() {
     if (this.requireAuth && !this.authToken) {
-      console.log("[MCPController] Skipping WebSocket connect: auth token not set and requireAuth=true");
+      logger.log(
+        "[MCPController] Skipping WebSocket connect: auth token not set and requireAuth=true"
+      );
       return;
     }
     if (this.socket?.readyState === WebSocket.OPEN || this.socket?.readyState === WebSocket.CONNECTING) {
@@ -27874,7 +27905,7 @@ var MCPController = class _MCPController {
       try {
         await mcpServer.close();
       } catch (error48) {
-        console.error("[MCPController] Error closing MCP server:", error48);
+        logger.error("[MCPController] Error closing MCP server:", error48);
       }
       this.transport = null;
     }
@@ -27891,8 +27922,9 @@ var MCPController = class _MCPController {
       const url2 = this.authToken ? `${this.backendUrl}?token=${this.authToken}` : this.backendUrl;
       this.socket = new WebSocket(url2);
       this.socket.onopen = async () => {
-        console.log("[MCPController] Connected to backend MCP server");
+        logger.log("[MCPController] Connected to backend MCP server");
         this.reconnectAttempts = 0;
+        this.isReconnectingForToken = false;
         try {
           if (this.socket) {
             this.transport = new WebSocketTransport(this.socket);
@@ -27903,13 +27935,16 @@ var MCPController = class _MCPController {
               }
             }
             await mcpServer.connect(this.transport);
-            console.log("[MCPController] MCP Server connected to WebSocket transport");
+            logger.log(
+              "[MCPController] MCP Server connected to WebSocket transport"
+            );
             this.startKeepAlive();
             this.broadcastFn({ type: "CONNECTION_STATUS", connected: true });
             resolve();
           }
         } catch (error48) {
-          console.error("[MCPController] Error setting up MCP server:", error48);
+          logger.error("[MCPController] Error setting up MCP server:", error48);
+          this.isReconnectingForToken = false;
           this.broadcastFn({ type: "CONNECTION_STATUS", connected: false });
           if (this.socket) {
             this.socket.close();
@@ -27918,31 +27953,37 @@ var MCPController = class _MCPController {
         }
       };
       this.socket.onclose = async (event) => {
-        console.log("[MCPController] Disconnected from backend MCP server", event?.code, event?.reason);
-        this.broadcastFn({ type: "CONNECTION_STATUS", connected: false });
+        logger.log(
+          "[MCPController] Disconnected from backend MCP server",
+          event?.code,
+          event?.reason
+        );
+        if (!this.isReconnectingForToken) {
+          this.broadcastFn({ type: "CONNECTION_STATUS", connected: false });
+        }
         if (this.transport) {
           try {
             await mcpServer.close();
           } catch (error48) {
-            console.error("[MCPController] Error closing MCP server:", error48);
+            logger.error("[MCPController] Error closing MCP server:", error48);
           }
           this.transport = null;
         }
         this.socket = null;
         this.stopKeepAlive();
-        if (event?.code !== 1e3) {
+        if (!this.isReconnectingForToken && event?.code !== 1e3) {
           const delay = Math.min(
             INITIAL_RECONNECT_DELAY * Math.pow(2, this.reconnectAttempts),
             MAX_RECONNECT_DELAY
           );
           this.reconnectAttempts++;
-          console.log(`[MCPController] Retrying in ${delay}ms...`);
+          logger.log(`[MCPController] Retrying in ${delay}ms...`);
           setTimeout(() => this.connectWebSocket(), delay);
         }
         resolve();
       };
       this.socket.onerror = (event) => {
-        console.error("[MCPController] WebSocket error:", event);
+        logger.error("[MCPController] WebSocket error:", event);
         this.broadcastFn({ type: "CONNECTION_STATUS", connected: false });
       };
     });
@@ -27951,12 +27992,21 @@ var MCPController = class _MCPController {
     const tokenChanged = this.authToken !== token;
     this.authToken = token;
     if (tokenChanged) {
-      console.log("[MCPController] Auth token changed, reconnecting WebSocket...");
+      logger.log(
+        "[MCPController] Auth token changed, reconnecting WebSocket..."
+      );
+      this.isReconnectingForToken = true;
       if (this.socket && (this.socket.readyState === WebSocket.OPEN || this.socket.readyState === WebSocket.CONNECTING)) {
         this.socket.close(1e3, "Reconnecting with new auth token");
       }
       setTimeout(() => {
-        this.connectWebSocket().catch((error48) => console.error("[MCPController] Failed to reconnect with new token:", error48));
+        this.connectWebSocket().catch((error48) => {
+          logger.error(
+            "[MCPController] Failed to reconnect with new token:",
+            error48
+          );
+          this.isReconnectingForToken = false;
+        });
       }, 100);
     }
   }
@@ -28006,11 +28056,11 @@ var setBackendUrl = (url2) => {
         try {
           client.postMessage(message);
         } catch (e) {
-          console.error("[ServiceWorker] Failed to post message to client:", e);
+          logger.error("[ServiceWorker] Failed to post message to client:", e);
         }
       });
     }).catch((err) => {
-      console.error("[ServiceWorker] Failed to match clients for broadcast:", err);
+      logger.error("[ServiceWorker] Failed to match clients for broadcast:", err);
     });
   });
   return controller;
@@ -28022,7 +28072,7 @@ self.addEventListener("message", async (event) => {
   if (msg["type"] === "INIT") {
     const url2 = msg["backendUrl"];
     if (!url2) {
-      console.error("[ServiceWorker] INIT missing backendUrl");
+      logger.error("[ServiceWorker] INIT missing backendUrl");
       return;
     }
     try {
@@ -28035,7 +28085,7 @@ self.addEventListener("message", async (event) => {
         pendingToken = null;
       }
     } catch (e) {
-      console.error("[ServiceWorker] Failed to apply INIT:", e);
+      logger.error("[ServiceWorker] Failed to apply INIT:", e);
     }
     return;
   }
@@ -28050,7 +28100,7 @@ self.addEventListener("message", async (event) => {
         pendingToken = token;
       }
     } catch (e) {
-      console.error("[ServiceWorker] Failed to set auth token:", e);
+      logger.error("[ServiceWorker] Failed to set auth token:", e);
     }
     return;
   }