mcp-remote 0.1.24 → 0.1.25

package/dist/{chunk-PXT7ZCDC.js → chunk-RUKVRRRN.js}

@@ -11872,7 +11872,7 @@ var Client = class extends Protocol {
 };
 
 // package.json
-var version = "0.1.24";
+var version = "0.1.25";
 
 // node_modules/.pnpm/pkce-challenge@5.0.0/node_modules/pkce-challenge/dist/index.node.js
 var crypto;
@@ -13675,9 +13675,7 @@ function debugLog(message, ...args) {
 }
 function log(str, ...rest) {
   console.error(`[${pid}] ${str}`, ...rest);
-  if (DEBUG && global.currentServerUrlHash) {
-    debugLog(str, ...rest);
-  }
+  debugLog(str, ...rest);
 }
 var MESSAGE_BLOCKED = Symbol("MessageBlocked");
 var isMessageBlocked = (value) => value === MESSAGE_BLOCKED;
@@ -13749,34 +13747,28 @@ function mcpProxy({
       return;
     }
     log("[Local\u2192Remote]", message.method || message.id);
-    if (DEBUG) {
-      debugLog("Local \u2192 Remote message", {
-        method: message.method,
-        id: message.id,
-        params: message.params ? JSON.stringify(message.params).substring(0, 500) : void 0
-      });
-    }
+    debugLog("Local \u2192 Remote message", {
+      method: message.method,
+      id: message.id,
+      params: message.params ? JSON.stringify(message.params).substring(0, 500) : void 0
+    });
     if (message.method === "initialize") {
       const { clientInfo } = message.params;
       if (clientInfo) clientInfo.name = `${clientInfo.name} (via mcp-remote ${version})`;
       log(JSON.stringify(message, null, 2));
-      if (DEBUG) {
-        debugLog("Initialize message with modified client info", { clientInfo });
-      }
+      debugLog("Initialize message with modified client info", { clientInfo });
     }
     transportToServer.send(message).catch(onServerError);
   };
   transportToServer.onmessage = (_message) => {
     const message = messageTransformer.interceptResponse(_message);
     log("[Remote\u2192Local]", message.method || message.id);
-    if (DEBUG) {
-      debugLog("Remote \u2192 Local message", {
-        method: message.method,
-        id: message.id,
-        result: message.result ? "result-present" : void 0,
-        error: message.error
-      });
-    }
+    debugLog("Remote \u2192 Local message", {
+      method: message.method,
+      id: message.id,
+      result: message.result ? "result-present" : void 0,
+      error: message.error
+    });
     transportToClient.send(message).catch(onClientError);
   };
   transportToClient.onclose = () => {
@@ -13784,7 +13776,7 @@ function mcpProxy({
       return;
     }
     transportToClientClosed = true;
-    if (DEBUG) debugLog("Local transport closed, closing remote transport");
+    debugLog("Local transport closed, closing remote transport");
     transportToServer.close().catch(onServerError);
   };
   transportToServer.onclose = () => {
@@ -13792,18 +13784,18 @@ function mcpProxy({
       return;
     }
     transportToServerClosed = true;
-    if (DEBUG) debugLog("Remote transport closed, closing local transport");
+    debugLog("Remote transport closed, closing local transport");
     transportToClient.close().catch(onClientError);
   };
   transportToClient.onerror = onClientError;
   transportToServer.onerror = onServerError;
   function onClientError(error) {
     log("Error from local client:", error);
-    if (DEBUG) debugLog("Error from local client", { stack: error.stack });
+    debugLog("Error from local client", { stack: error.stack });
   }
   function onServerError(error) {
     log("Error from remote server:", error);
-    if (DEBUG) debugLog("Error from remote server", { stack: error.stack });
+    debugLog("Error from remote server", { stack: error.stack });
   }
 }
 async function connectToRemoteServer(client, serverUrl, authProvider, headers, authInitializer, transportStrategy = "http-first", recursionReasons = /* @__PURE__ */ new Set()) {
@@ -13836,15 +13828,15 @@ async function connectToRemoteServer(client, serverUrl, authProvider, headers, a
     requestInit: { headers }
   });
   try {
-    if (DEBUG) debugLog("Attempting to connect to remote server", { sseTransport });
+    debugLog("Attempting to connect to remote server", { sseTransport });
     if (client) {
-      if (DEBUG) debugLog("Connecting client to transport");
+      debugLog("Connecting client to transport");
       await client.connect(transport);
     } else {
-      if (DEBUG) debugLog("Starting transport directly");
+      debugLog("Starting transport directly");
       await transport.start();
       if (!sseTransport) {
-        if (DEBUG) debugLog("Creating test transport for HTTP-only connection test");
+        debugLog("Creating test transport for HTTP-only connection test");
         const testTransport = new StreamableHTTPClientTransport(url, { authProvider, requestInit: { headers } });
         const testClient = new Client({ name: "mcp-remote-fallback-test", version: "0.0.0" }, { capabilities: {} });
         await testClient.connect(testTransport);
@@ -13873,57 +13865,52 @@ async function connectToRemoteServer(client, serverUrl, authProvider, headers, a
       );
     } else if (error instanceof UnauthorizedError || error instanceof Error && error.message.includes("Unauthorized")) {
       log("Authentication required. Initializing auth...");
-      if (DEBUG) {
-        debugLog("Authentication error detected", {
-          errorCode: error instanceof OAuthError ? error.errorCode : void 0,
-          errorMessage: error.message,
-          stack: error.stack
-        });
-      }
-      if (DEBUG) debugLog("Calling authInitializer to start auth flow");
+      debugLog("Authentication error detected", {
+        errorCode: error instanceof OAuthError ? error.errorCode : void 0,
+        errorMessage: error.message,
+        stack: error.stack
+      });
+      debugLog("Calling authInitializer to start auth flow");
       const { waitForAuthCode, skipBrowserAuth } = await authInitializer();
       if (skipBrowserAuth) {
         log("Authentication required but skipping browser auth - using shared auth");
       } else {
         log("Authentication required. Waiting for authorization...");
       }
-      if (DEBUG) debugLog("Waiting for auth code from callback server");
+      debugLog("Waiting for auth code from callback server");
       const code = await waitForAuthCode();
-      if (DEBUG) debugLog("Received auth code from callback server");
+      debugLog("Received auth code from callback server");
       try {
         log("Completing authorization...");
         await transport.finishAuth(code);
-        if (DEBUG) debugLog("Authorization completed successfully");
+        debugLog("Authorization completed successfully");
         if (recursionReasons.has(REASON_AUTH_NEEDED)) {
           const errorMessage = `Already attempted reconnection for reason: ${REASON_AUTH_NEEDED}. Giving up.`;
           log(errorMessage);
-          if (DEBUG)
-            debugLog("Already attempted auth reconnection, giving up", {
-              recursionReasons: Array.from(recursionReasons)
-            });
+          debugLog("Already attempted auth reconnection, giving up", {
+            recursionReasons: Array.from(recursionReasons)
+          });
           throw new Error(errorMessage);
         }
         recursionReasons.add(REASON_AUTH_NEEDED);
         log(`Recursively reconnecting for reason: ${REASON_AUTH_NEEDED}`);
-        if (DEBUG) debugLog("Recursively reconnecting after auth", { recursionReasons: Array.from(recursionReasons) });
+        debugLog("Recursively reconnecting after auth", { recursionReasons: Array.from(recursionReasons) });
         return connectToRemoteServer(client, serverUrl, authProvider, headers, authInitializer, transportStrategy, recursionReasons);
       } catch (authError) {
         log("Authorization error:", authError);
-        if (DEBUG)
-          debugLog("Authorization error during finishAuth", {
-            errorMessage: authError.message,
-            stack: authError.stack
-          });
+        debugLog("Authorization error during finishAuth", {
+          errorMessage: authError.message,
+          stack: authError.stack
+        });
         throw authError;
       }
     } else {
       log("Connection error:", error);
-      if (DEBUG)
-        debugLog("Connection error", {
-          errorMessage: error.message,
-          stack: error.stack,
-          transportType: transport.constructor.name
-        });
+      debugLog("Connection error", {
+        errorMessage: error.message,
+        stack: error.stack,
+        transportType: transport.constructor.name
+      });
       throw error;
     }
   }
@@ -14145,9 +14132,7 @@ async function parseCommandLineArgs(args, usage) {
   }
   const serverUrlHash = getServerUrlHash(serverUrl);
   global.currentServerUrlHash = serverUrlHash;
-  if (DEBUG) {
-    debugLog(`Starting mcp-remote with server URL: ${serverUrl}`);
-  }
+  debugLog(`Starting mcp-remote with server URL: ${serverUrl}`);
   const defaultPort = calculateDefaultPort(serverUrlHash);
   const [existingClientPort, availablePort] = await Promise.all([findExistingClientPort(serverUrlHash), findAvailablePort(defaultPort)]);
   let callbackPort;
@@ -14290,9 +14275,9 @@ var NodeOAuthClientProvider = class {
    * @returns The client information or undefined
    */
   async clientInformation() {
-    if (DEBUG) debugLog("Reading client info");
+    debugLog("Reading client info");
     if (this.staticOAuthClientInfo) {
-      if (DEBUG) debugLog("Returning static client info");
+      debugLog("Returning static client info");
       return this.staticOAuthClientInfo;
     }
     const clientInfo = await readJsonFile(
@@ -14306,10 +14291,10 @@ var NodeOAuthClientProvider = class {
       });
       if (scopesData?.scopes) {
         this._scopes = scopesData.scopes;
-        if (DEBUG) debugLog("Loaded stored scopes from registration", { scopes: this._scopes });
+        debugLog("Loaded stored scopes from registration", { scopes: this._scopes });
       }
     }
-    if (DEBUG) debugLog("Client info result:", clientInfo ? "Found" : "Not found");
+    debugLog("Client info result:", clientInfo ? "Found" : "Not found");
     return clientInfo;
   }
   /**
@@ -14329,9 +14314,9 @@ var NodeOAuthClientProvider = class {
    * @param clientInformation The client information to save
    */
   async saveClientInformation(clientInformation) {
-    if (DEBUG) debugLog("Saving client info", { client_id: clientInformation.client_id });
+    debugLog("Saving client info", { client_id: clientInformation.client_id });
     const scopes = this.extractScopesFromRegistration(clientInformation);
-    if (DEBUG) debugLog("Extracted scopes from registration response", { scopes });
+    debugLog("Extracted scopes from registration response", { scopes });
     this._scopes = scopes;
     await writeJsonFile(this.serverUrlHash, "client_info.json", clientInformation);
     await writeJsonFile(this.serverUrlHash, "scopes.json", { scopes });
@@ -14341,56 +14326,50 @@ var NodeOAuthClientProvider = class {
    * @returns The OAuth tokens or undefined
    */
   async tokens() {
-    if (DEBUG) {
-      debugLog("Reading OAuth tokens");
-      debugLog("Token request stack trace:", new Error().stack);
-    }
+    debugLog("Reading OAuth tokens");
+    debugLog("Token request stack trace:", new Error().stack);
     const tokens = await readJsonFile(this.serverUrlHash, "tokens.json", OAuthTokensSchema);
-    if (DEBUG) {
-      if (tokens) {
-        const timeLeft = tokens.expires_in || 0;
-        if (typeof tokens.expires_in !== "number" || tokens.expires_in < 0) {
-          debugLog("\u26A0\uFE0F WARNING: Invalid expires_in detected while reading tokens \u26A0\uFE0F", {
-            expiresIn: tokens.expires_in,
-            tokenObject: JSON.stringify(tokens),
-            stack: new Error("Invalid expires_in value").stack
-          });
-        }
-        debugLog("Token result:", {
-          found: true,
-          hasAccessToken: !!tokens.access_token,
-          hasRefreshToken: !!tokens.refresh_token,
-          expiresIn: `${timeLeft} seconds`,
-          isExpired: timeLeft <= 0,
-          expiresInValue: tokens.expires_in
-        });
-      } else {
-        debugLog("Token result: Not found");
-      }
-    }
-    return tokens;
-  }
-  /**
-   * Saves OAuth tokens
-   * @param tokens The tokens to save
-   */
-  async saveTokens(tokens) {
-    if (DEBUG) {
+    if (tokens) {
       const timeLeft = tokens.expires_in || 0;
       if (typeof tokens.expires_in !== "number" || tokens.expires_in < 0) {
-        debugLog("\u26A0\uFE0F WARNING: Invalid expires_in detected in tokens \u26A0\uFE0F", {
+        debugLog("\u26A0\uFE0F WARNING: Invalid expires_in detected while reading tokens \u26A0\uFE0F", {
           expiresIn: tokens.expires_in,
           tokenObject: JSON.stringify(tokens),
           stack: new Error("Invalid expires_in value").stack
         });
       }
-      debugLog("Saving tokens", {
+      debugLog("Token result:", {
+        found: true,
         hasAccessToken: !!tokens.access_token,
         hasRefreshToken: !!tokens.refresh_token,
         expiresIn: `${timeLeft} seconds`,
+        isExpired: timeLeft <= 0,
         expiresInValue: tokens.expires_in
       });
+    } else {
+      debugLog("Token result: Not found");
+    }
+    return tokens;
+  }
+  /**
+   * Saves OAuth tokens
+   * @param tokens The tokens to save
+   */
+  async saveTokens(tokens) {
+    const timeLeft = tokens.expires_in || 0;
+    if (typeof tokens.expires_in !== "number" || tokens.expires_in < 0) {
+      debugLog("\u26A0\uFE0F WARNING: Invalid expires_in detected in tokens \u26A0\uFE0F", {
+        expiresIn: tokens.expires_in,
+        tokenObject: JSON.stringify(tokens),
+        stack: new Error("Invalid expires_in value").stack
+      });
     }
+    debugLog("Saving tokens", {
+      hasAccessToken: !!tokens.access_token,
+      hasRefreshToken: !!tokens.refresh_token,
+      expiresIn: `${timeLeft} seconds`,
+      expiresInValue: tokens.expires_in
+    });
     await writeJsonFile(this.serverUrlHash, "tokens.json", tokens);
   }
   /**
@@ -14403,19 +14382,19 @@ var NodeOAuthClientProvider = class {
     }
     if (this._scopes) {
       authorizationUrl.searchParams.set("scope", this._scopes);
-      if (DEBUG) debugLog("Added scope parameter to authorization URL", { scopes: this._scopes });
+      debugLog("Added scope parameter to authorization URL", { scopes: this._scopes });
     }
     log(`
 Please authorize this client by visiting:
 ${authorizationUrl.toString()}
 `);
-    if (DEBUG) debugLog("Redirecting to authorization URL", authorizationUrl.toString());
+    debugLog("Redirecting to authorization URL", authorizationUrl.toString());
     try {
       await open(sanitizeUrl(authorizationUrl.toString()));
       log("Browser opened automatically.");
     } catch (error) {
       log("Could not open browser automatically. Please copy and paste the URL above into your browser.");
-      if (DEBUG) debugLog("Failed to open browser", error);
+      debugLog("Failed to open browser", error);
     }
   }
   /**
@@ -14423,7 +14402,7 @@ ${authorizationUrl.toString()}
    * @param codeVerifier The code verifier to save
    */
   async saveCodeVerifier(codeVerifier) {
-    if (DEBUG) debugLog("Saving code verifier");
+    debugLog("Saving code verifier");
     await writeTextFile(this.serverUrlHash, "code_verifier.txt", codeVerifier);
   }
   /**
@@ -14431,9 +14410,9 @@ ${authorizationUrl.toString()}
    * @returns The code verifier
    */
   async codeVerifier() {
-    if (DEBUG) debugLog("Reading code verifier");
+    debugLog("Reading code verifier");
     const verifier = await readTextFile(this.serverUrlHash, "code_verifier.txt", "No code verifier saved for session");
-    if (DEBUG) debugLog("Code verifier found:", !!verifier);
+    debugLog("Code verifier found:", !!verifier);
     return verifier;
   }
   /**
@@ -14441,7 +14420,7 @@ ${authorizationUrl.toString()}
    * @param scope The scope of credentials to invalidate
    */
   async invalidateCredentials(scope) {
-    if (DEBUG) debugLog(`Invalidating credentials: ${scope}`);
+    debugLog(`Invalidating credentials: ${scope}`);
     switch (scope) {
       case "all":
         await Promise.all([
@@ -14450,20 +14429,20 @@ ${authorizationUrl.toString()}
           deleteConfigFile(this.serverUrlHash, "code_verifier.txt"),
           deleteConfigFile(this.serverUrlHash, "scopes.json")
         ]);
-        if (DEBUG) debugLog("All credentials invalidated");
+        debugLog("All credentials invalidated");
         break;
       case "client":
         await Promise.all([deleteConfigFile(this.serverUrlHash, "client_info.json"), deleteConfigFile(this.serverUrlHash, "scopes.json")]);
         this._scopes = this.options.scopes || "openid email profile";
-        if (DEBUG) debugLog("Client information invalidated");
+        debugLog("Client information invalidated");
         break;
       case "tokens":
         await deleteConfigFile(this.serverUrlHash, "tokens.json");
-        if (DEBUG) debugLog("OAuth tokens invalidated");
+        debugLog("OAuth tokens invalidated");
         break;
       case "verifier":
         await deleteConfigFile(this.serverUrlHash, "code_verifier.txt");
-        if (DEBUG) debugLog("Code verifier invalidated");
+        debugLog("Code verifier invalidated");
         break;
       default:
         throw new Error(`Unknown credential scope: ${scope}`);
@@ -14477,32 +14456,31 @@ import { unlinkSync } from "fs";
 async function isPidRunning(pid2) {
   try {
     process.kill(pid2, 0);
-    if (DEBUG) debugLog(`Process ${pid2} is running`);
+    debugLog(`Process ${pid2} is running`);
     return true;
   } catch (err) {
-    if (DEBUG) debugLog(`Process ${pid2} is not running`, err);
+    debugLog(`Process ${pid2} is not running`, err);
     return false;
   }
 }
 async function isLockValid(lockData) {
-  if (DEBUG) debugLog("Checking if lockfile is valid", lockData);
+  debugLog("Checking if lockfile is valid", lockData);
   const MAX_LOCK_AGE = 30 * 60 * 1e3;
   if (Date.now() - lockData.timestamp > MAX_LOCK_AGE) {
     log("Lockfile is too old");
-    if (DEBUG)
-      debugLog("Lockfile is too old", {
-        age: Date.now() - lockData.timestamp,
-        maxAge: MAX_LOCK_AGE
-      });
+    debugLog("Lockfile is too old", {
+      age: Date.now() - lockData.timestamp,
+      maxAge: MAX_LOCK_AGE
+    });
     return false;
   }
   if (!await isPidRunning(lockData.pid)) {
     log("Process from lockfile is not running");
-    if (DEBUG) debugLog("Process from lockfile is not running", { pid: lockData.pid });
+    debugLog("Process from lockfile is not running", { pid: lockData.pid });
     return false;
   }
   try {
-    if (DEBUG) debugLog("Checking if endpoint is accessible", { port: lockData.port });
+    debugLog("Checking if endpoint is accessible", { port: lockData.port });
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 1e3);
     const response = await fetch(`http://127.0.0.1:${lockData.port}/wait-for-auth?poll=false`, {
@@ -14510,11 +14488,11 @@ async function isLockValid(lockData) {
     });
     clearTimeout(timeout);
     const isValid2 = response.status === 200 || response.status === 202;
-    if (DEBUG) debugLog(`Endpoint check result: ${isValid2 ? "valid" : "invalid"}`, { status: response.status });
+    debugLog(`Endpoint check result: ${isValid2 ? "valid" : "invalid"}`, { status: response.status });
     return isValid2;
   } catch (error) {
     log(`Error connecting to auth server: ${error.message}`);
-    if (DEBUG) debugLog("Error connecting to auth server", error);
+    debugLog("Error connecting to auth server", error);
     return false;
   }
 }
@@ -14526,29 +14504,29 @@ async function waitForAuthentication(port) {
       attempts++;
       const url = `http://127.0.0.1:${port}/wait-for-auth`;
       log(`Querying: ${url}`);
-      if (DEBUG) debugLog(`Poll attempt ${attempts}`);
+      debugLog(`Poll attempt ${attempts}`);
       try {
         const response = await fetch(url);
-        if (DEBUG) debugLog(`Poll response status: ${response.status}`);
+        debugLog(`Poll response status: ${response.status}`);
         if (response.status === 200) {
           log(`Authentication completed by other instance`);
           return true;
         } else if (response.status === 202) {
           log(`Authentication still in progress`);
-          if (DEBUG) debugLog(`Will retry in 1s`);
+          debugLog(`Will retry in 1s`);
           await new Promise((resolve) => setTimeout(resolve, 1e3));
         } else {
           log(`Unexpected response status: ${response.status}`);
           return false;
         }
       } catch (fetchError) {
-        if (DEBUG) debugLog(`Fetch error during poll`, fetchError);
+        debugLog(`Fetch error during poll`, fetchError);
         await new Promise((resolve) => setTimeout(resolve, 2e3));
       }
     }
   } catch (error) {
     log(`Error waiting for authentication: ${error.message}`);
-    if (DEBUG) debugLog(`Error waiting for authentication`, error);
+    debugLog(`Error waiting for authentication`, error);
     return false;
   }
 }
@@ -14557,37 +14535,35 @@ function createLazyAuthCoordinator(serverUrlHash, callbackPort, events, authTime
   return {
     initializeAuth: async () => {
       if (authState) {
-        if (DEBUG) debugLog("Auth already initialized, reusing existing state");
+        debugLog("Auth already initialized, reusing existing state");
         return authState;
       }
       log("Initializing auth coordination on-demand");
-      if (DEBUG) debugLog("Initializing auth coordination on-demand", { serverUrlHash, callbackPort });
+      debugLog("Initializing auth coordination on-demand", { serverUrlHash, callbackPort });
       authState = await coordinateAuth(serverUrlHash, callbackPort, events, authTimeoutMs);
-      if (DEBUG) debugLog("Auth coordination completed", { skipBrowserAuth: authState.skipBrowserAuth });
+      debugLog("Auth coordination completed", { skipBrowserAuth: authState.skipBrowserAuth });
       return authState;
     }
   };
 }
 async function coordinateAuth(serverUrlHash, callbackPort, events, authTimeoutMs) {
-  if (DEBUG) debugLog("Coordinating authentication", { serverUrlHash, callbackPort });
+  debugLog("Coordinating authentication", { serverUrlHash, callbackPort });
   const lockData = process.platform === "win32" ? null : await checkLockfile(serverUrlHash);
-  if (DEBUG) {
-    if (process.platform === "win32") {
-      debugLog("Skipping lockfile check on Windows");
-    } else {
-      debugLog("Lockfile check result", { found: !!lockData, lockData });
-    }
+  if (process.platform === "win32") {
+    debugLog("Skipping lockfile check on Windows");
+  } else {
+    debugLog("Lockfile check result", { found: !!lockData, lockData });
   }
   if (lockData && await isLockValid(lockData)) {
     log(`Another instance is handling authentication on port ${lockData.port} (pid: ${lockData.pid})`);
     try {
-      if (DEBUG) debugLog("Waiting for authentication from other instance");
+      debugLog("Waiting for authentication from other instance");
       const authCompleted = await waitForAuthentication(lockData.port);
       if (authCompleted) {
         log("Authentication completed by another instance. Using tokens from disk");
         const dummyServer = express2().listen(0);
         const dummyPort = dummyServer.address().port;
-        if (DEBUG) debugLog("Started dummy server", { port: dummyPort });
+        debugLog("Started dummy server", { port: dummyPort });
         const dummyWaitForAuthCode = () => {
           log("WARNING: waitForAuthCode called in secondary instance - this is unexpected");
           return new Promise(() => {
@@ -14603,15 +14579,15 @@ async function coordinateAuth(serverUrlHash, callbackPort, events, authTimeoutMs
       }
     } catch (error) {
       log(`Error waiting for authentication: ${error}`);
-      if (DEBUG) debugLog("Error waiting for authentication", error);
+      debugLog("Error waiting for authentication", error);
     }
-    if (DEBUG) debugLog("Other instance did not complete auth successfully, deleting lockfile");
+    debugLog("Other instance did not complete auth successfully, deleting lockfile");
     await deleteLockfile(serverUrlHash);
   } else if (lockData) {
     log("Found invalid lockfile, deleting it");
     await deleteLockfile(serverUrlHash);
   }
-  if (DEBUG) debugLog("Setting up OAuth callback server", { port: callbackPort });
+  debugLog("Setting up OAuth callback server", { port: callbackPort });
   const { server, waitForAuthCode, authCompletedPromise } = setupOAuthCallbackServerWithLongPoll({
     port: callbackPort,
     path: "/oauth/callback",
@@ -14620,7 +14596,7 @@ async function coordinateAuth(serverUrlHash, callbackPort, events, authTimeoutMs
   });
   const address = server.address();
   const actualPort = address.port;
-  if (DEBUG) debugLog("OAuth callback server running", { port: actualPort });
+  debugLog("OAuth callback server running", { port: actualPort });
   log(`Creating lockfile for server ${serverUrlHash} with process ${process.pid} on port ${actualPort}`);
   await createLockfile(serverUrlHash, process.pid, actualPort);
   const cleanupHandler = async () => {
@@ -14629,23 +14605,23 @@ async function coordinateAuth(serverUrlHash, callbackPort, events, authTimeoutMs
       await deleteLockfile(serverUrlHash);
     } catch (error) {
       log(`Error cleaning up lockfile: ${error}`);
-      if (DEBUG) debugLog("Error cleaning up lockfile", error);
+      debugLog("Error cleaning up lockfile", error);
     }
   };
   process.once("exit", () => {
     try {
       const configPath = getConfigFilePath(serverUrlHash, "lock.json");
       unlinkSync(configPath);
-      if (DEBUG) console.error(`[DEBUG] Removed lockfile on exit: ${configPath}`);
+      debugLog(`Removed lockfile on exit: ${configPath}`);
     } catch (error) {
-      if (DEBUG) console.error(`[DEBUG] Error removing lockfile on exit:`, error);
+      debugLog(`Error removing lockfile on exit:`, error);
     }
   });
   process.once("SIGINT", async () => {
-    if (DEBUG) debugLog("Received SIGINT signal, cleaning up");
+    debugLog("Received SIGINT signal, cleaning up");
     await cleanupHandler();
   });
-  if (DEBUG) debugLog("Auth coordination complete, returning primary instance handlers");
+  debugLog("Auth coordination complete, returning primary instance handlers");
   return {
     server,
     waitForAuthCode,

package/dist/client.js

@@ -11,7 +11,7 @@ import {
   parseCommandLineArgs,
   setupSignalHandlers,
   version
-} from "./chunk-PXT7ZCDC.js";
+} from "./chunk-RUKVRRRN.js";
 
 // src/client.ts
 import { EventEmitter } from "events";

package/dist/proxy.js

@@ -9,7 +9,7 @@ import {
   mcpProxy,
   parseCommandLineArgs,
   setupSignalHandlers
-} from "./chunk-PXT7ZCDC.js";
+} from "./chunk-RUKVRRRN.js";
 
 // src/proxy.ts
 import { EventEmitter } from "events";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-remote",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "Remote proxy for Model Context Protocol, allowing local-only clients to connect to remote servers using oAuth",
   "keywords": [
     "mcp",