@automattic/mcp-wordpress-remote 0.2.17 → 0.2.19

package/dist/proxy.js

@@ -36036,7 +36036,7 @@ async function selectCallbackPort(serverUrl, specifiedPort, _unused) {
 }
 
 // src/lib/config.ts
-var MCP_WORDPRESS_REMOTE_VERSION = "0.2.17";
+var MCP_WORDPRESS_REMOTE_VERSION = "0.2.19";
 var CONFIG = {
   // API Configuration
   WP_API_URL: process.env.WP_API_URL || "https://example.com",
@@ -36086,8 +36086,57 @@ var CONFIG = {
   CUSTOM_HEADERS: process.env.CUSTOM_HEADERS || "",
   // JSON string or comma-separated header:value pairs
   // Environment
-  NODE_ENV: process.env.NODE_ENV || "development"
+  NODE_ENV: process.env.NODE_ENV || "development",
+  // Proxy Configuration
+  USE_SYSTEM_PROXY: process.env.USE_SYSTEM_PROXY === "true"
+  // Enable system proxy detection (PAC files, env vars)
 };
+var getConfig = () => ({
+  /** WordPress site API endpoint */
+  wpApiUrl: CONFIG.WP_API_URL,
+  /** Whether OAuth authentication is enabled */
+  oauthEnabled: CONFIG.OAUTH_ENABLED,
+  /** Port for OAuth callback server (undefined for auto-detection on self-hosted sites) */
+  oauthCallbackPort: CONFIG.OAUTH_CALLBACK_PORT,
+  /** Hostname for OAuth callback */
+  oauthHost: CONFIG.OAUTH_HOST,
+  /** WordPress OAuth client ID */
+  wpOAuthClientId: CONFIG.WP_OAUTH_CLIENT_ID,
+  /** OAuth flow type (authorization_code recommended, implicit for legacy) */
+  oauthFlowType: CONFIG.OAUTH_FLOW_TYPE,
+  /** Whether to use PKCE (required for OAuth 2.1) */
+  oauthUsePKCE: CONFIG.OAUTH_USE_PKCE,
+  /** Whether to support dynamic client registration */
+  oauthDynamicRegistration: CONFIG.OAUTH_DYNAMIC_REGISTRATION,
+  /** Whether to use resource indicators (RFC 8707) */
+  oauthResourceIndicator: CONFIG.OAUTH_RESOURCE_INDICATOR,
+  /** Custom OAuth scopes (comma-separated) */
+  oauthScopes: CONFIG.OAUTH_SCOPES,
+  /** OAuth operation timeout in milliseconds */
+  oauthTimeout: CONFIG.OAUTH_TIMEOUT,
+  /** Lock operation timeout in milliseconds */
+  lockTimeout: CONFIG.LOCK_TIMEOUT,
+  /** Configuration directory path */
+  configDir: CONFIG.WP_MCP_CONFIG_DIR,
+  /** Log file path (null if not set) */
+  logFile: CONFIG.LOG_FILE,
+  /** WordPress API username (legacy) */
+  wpApiUsername: CONFIG.WP_API_USERNAME,
+  /** WordPress API password (legacy) */
+  wpApiPassword: CONFIG.WP_API_PASSWORD,
+  /** JWT token for authentication */
+  jwtToken: CONFIG.JWT_TOKEN,
+  /** WooCommerce customer key */
+  wooCustomerKey: CONFIG.WOO_CUSTOMER_KEY,
+  /** WooCommerce customer secret */
+  wooCustomerSecret: CONFIG.WOO_CUSTOMER_SECRET,
+  /** Custom headers for API requests */
+  customHeaders: CONFIG.CUSTOM_HEADERS,
+  /** Current environment */
+  nodeEnv: CONFIG.NODE_ENV,
+  /** Whether to use system proxy (PAC files on macOS, env vars on all platforms) */
+  useSystemProxy: CONFIG.USE_SYSTEM_PROXY
+});
 function parseOAuthScopes(envScopes, defaultScopes) {
   if (!envScopes || envScopes.trim() === "") {
     return defaultScopes;
@@ -36218,7 +36267,9 @@ function log(message, level = 2 /* INFO */, category = "GENERAL", ...args) {
   const formattedArgs = args.length > 0 ? args.map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : arg).join(" ") : "";
   const logMessage = `${timestamp} [${levelName}] [${category}] ${message}${formattedArgs ? "\n" + formattedArgs : ""}
 `;
-  process.stderr.write(logMessage);
+  if (process.env.LOG_TO_STDERR === "true") {
+    process.stderr.write(logMessage);
+  }
   if (process.env.LOG_FILE) {
     fs2.appendFileSync(process.env.LOG_FILE, logMessage);
   }
@@ -36248,6 +36299,165 @@ function validateNodeVersion(requiredVersion = 18) {
   }
 }
 
+// src/lib/proxy-utils.ts
+import { execSync } from "child_process";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import { HttpsProxyAgent } from "https-proxy-agent";
+var proxyConfig = { type: "none" };
+var initializationPromise = null;
+function detectMacOsPac() {
+  if (process.platform !== "darwin") return null;
+  try {
+    const output = execSync("scutil --proxy", { encoding: "utf-8", timeout: 3e3 });
+    const pacEnabled = output.match(/ProxyAutoConfigEnable\s*:\s*(\d)/)?.[1] === "1";
+    const pacUrl = output.match(/ProxyAutoConfigURLString\s*:\s*(\S+)/)?.[1];
+    if (pacEnabled && pacUrl) {
+      return pacUrl;
+    }
+  } catch {
+  }
+  return null;
+}
+function isSocksProxy(url) {
+  return url.toLowerCase().startsWith("socks");
+}
+function sanitizeProxyUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.password) parsed.password = "***";
+    return parsed.toString();
+  } catch {
+    return url.replace(/\/\/[^:]+:[^@]+@/, "//***:***@");
+  }
+}
+function shouldBypassProxy(targetUrl) {
+  const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+  if (!noProxy) return false;
+  let hostname2;
+  try {
+    hostname2 = new URL(targetUrl).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  const rules = noProxy.split(",").map((r2) => r2.trim().toLowerCase()).filter((r2) => r2.length > 0);
+  for (const rule of rules) {
+    if (rule === "*") return true;
+    if (hostname2 === rule) return true;
+    if (rule.startsWith(".") && hostname2.endsWith(rule) || !rule.startsWith(".") && hostname2.endsWith(`.${rule}`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function detectEnvProxy() {
+  const socksProxy = process.env.SOCKS_PROXY || process.env.socks_proxy;
+  if (socksProxy) {
+    return { url: socksProxy, type: "socks" };
+  }
+  const httpsProxy = process.env.HTTPS_PROXY || process.env.https_proxy;
+  if (httpsProxy) {
+    return { url: httpsProxy, type: isSocksProxy(httpsProxy) ? "socks" : "http" };
+  }
+  const allProxy = process.env.ALL_PROXY || process.env.all_proxy;
+  if (allProxy) {
+    return { url: allProxy, type: isSocksProxy(allProxy) ? "socks" : "http" };
+  }
+  const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
+  if (httpProxy) {
+    return { url: httpProxy, type: isSocksProxy(httpProxy) ? "socks" : "http" };
+  }
+  return null;
+}
+async function initializeProxy() {
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+  initializationPromise = doInitializeProxy().catch((error) => {
+    initializationPromise = null;
+    throw error;
+  });
+  return initializationPromise;
+}
+async function doInitializeProxy() {
+  const pacUrl = detectMacOsPac();
+  if (pacUrl) {
+    try {
+      const response = await fetch(pacUrl);
+      const pacScript = await response.text();
+      const { getQuickJS } = await import("@tootallnate/quickjs-emscripten");
+      const { createPacResolver } = await import("pac-resolver");
+      const qjs = await getQuickJS();
+      const resolver = createPacResolver(qjs, pacScript);
+      proxyConfig = {
+        type: "pac",
+        pacResolver: resolver
+      };
+      logger.info(`PAC proxy initialized from ${sanitizeProxyUrl(pacUrl)}`, "PROXY");
+      return;
+    } catch (error) {
+      logger.error(`Failed to initialize PAC proxy: ${error}`, "PROXY");
+    }
+  }
+  const envProxy = detectEnvProxy();
+  if (envProxy) {
+    proxyConfig = { type: "env", envProxy };
+    logger.info(`Proxy configured from environment: ${sanitizeProxyUrl(envProxy.url)}`, "PROXY");
+    return;
+  }
+  logger.debug("No proxy configured", "PROXY");
+  proxyConfig = { type: "none" };
+}
+async function getAgentForUrl(url) {
+  if (proxyConfig.type === "none") {
+    return void 0;
+  }
+  if (shouldBypassProxy(url)) {
+    logger.debug(`Bypassing proxy for ${url} (matches NO_PROXY)`, "PROXY");
+    return void 0;
+  }
+  if (proxyConfig.type === "pac" && proxyConfig.pacResolver) {
+    try {
+      const result = await proxyConfig.pacResolver(url);
+      const directives = result.split(";");
+      for (const rawDirective of directives) {
+        const directive = rawDirective.trim();
+        if (!directive) continue;
+        if (directive.toUpperCase() === "DIRECT") {
+          logger.debug(`PAC returned DIRECT for ${url}`, "PROXY");
+          return void 0;
+        }
+        const socksMatch = directive.match(/SOCKS5?\s+(\S+):(\d+)/i);
+        if (socksMatch) {
+          const proxyUrl = `socks5://${socksMatch[1]}:${socksMatch[2]}`;
+          logger.debug(`PAC returned SOCKS proxy for ${url}: ${sanitizeProxyUrl(proxyUrl)}`, "PROXY");
+          return new SocksProxyAgent(proxyUrl);
+        }
+        const proxyMatch = directive.match(/PROXY\s+(\S+):(\d+)/i);
+        if (proxyMatch) {
+          const proxyUrl = `http://${proxyMatch[1]}:${proxyMatch[2]}`;
+          logger.debug(`PAC returned HTTP proxy for ${url}: ${sanitizeProxyUrl(proxyUrl)}`, "PROXY");
+          return new HttpsProxyAgent(proxyUrl);
+        }
+      }
+      logger.debug(`PAC returned no usable proxy for ${url}: ${result}`, "PROXY");
+    } catch (error) {
+      logger.warn(`PAC evaluation failed for ${url}: ${error}`, "PROXY");
+    }
+    return void 0;
+  }
+  if (proxyConfig.type === "env" && proxyConfig.envProxy) {
+    const { url: proxyUrl, type } = proxyConfig.envProxy;
+    try {
+      logger.debug(`Using env proxy ${sanitizeProxyUrl(proxyUrl)} for ${url}`, "PROXY");
+      return type === "socks" ? new SocksProxyAgent(proxyUrl) : new HttpsProxyAgent(proxyUrl);
+    } catch (error) {
+      logger.error(`Invalid proxy URL "${proxyUrl}": ${error}`, "PROXY");
+      return void 0;
+    }
+  }
+  return void 0;
+}
+
 // src/lib/fetch-utils.ts
 async function setupFetchPolyfill() {
   if (typeof globalThis.fetch !== "function") {
@@ -36267,6 +36477,22 @@ async function setupFetchPolyfill() {
   } else {
     logger.info("Using native fetch API", "SYSTEM");
   }
+  if (getConfig().useSystemProxy) {
+    await initializeProxy();
+  } else {
+    logger.debug("System proxy support disabled (USE_SYSTEM_PROXY=false)", "PROXY");
+  }
+}
+async function proxyFetch(url, init) {
+  if (!getConfig().useSystemProxy) {
+    return fetch(url, init);
+  }
+  const agent = await getAgentForUrl(url);
+  if (agent) {
+    const nodeFetch = (await Promise.resolve().then(() => (init_src(), src_exports))).default;
+    return nodeFetch(url, { ...init, agent });
+  }
+  return fetch(url, init);
 }
 
 // src/lib/wordpress-api.ts
@@ -36781,7 +37007,7 @@ async function discoverAuthorizationServerMetadata(authorizationServerUrl) {
     const metadataUrl = new URL("/.well-known/oauth-authorization-server", authorizationServerUrl);
     logger.oauth(`Discovering authorization server metadata: ${metadataUrl}`);
     const customHeaders = getCustomHeaders();
-    const response = await fetch(metadataUrl.toString(), {
+    const response = await proxyFetch(metadataUrl.toString(), {
       headers: {
         "Accept": "application/json",
         ...customHeaders
@@ -36818,7 +37044,7 @@ async function discoverProtectedResourceMetadata(resourceUrl) {
     const metadataUrl = new URL("/.well-known/oauth-protected-resource", url.origin);
     logger.oauth(`Discovering protected resource metadata: ${metadataUrl}`);
     const customHeaders = getCustomHeaders();
-    const response = await fetch(metadataUrl.toString(), {
+    const response = await proxyFetch(metadataUrl.toString(), {
       headers: {
         "Accept": "application/json",
         ...customHeaders
@@ -36884,7 +37110,7 @@ async function registerDynamicClient(registrationEndpoint, registrationRequest)
   try {
     logger.oauth(`Attempting dynamic client registration: ${registrationEndpoint}`);
     const customHeaders = getCustomHeaders();
-    const response = await fetch(registrationEndpoint, {
+    const response = await proxyFetch(registrationEndpoint, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -36936,7 +37162,7 @@ async function exchangeAuthorizationCode(tokenEndpoint, code, redirectUri, clien
       params.set("resource", resource);
     }
     const customHeaders = getCustomHeaders();
-    const response = await fetch(tokenEndpoint, {
+    const response = await proxyFetch(tokenEndpoint, {
       method: "POST",
       headers: {
         "Content-Type": "application/x-www-form-urlencoded",
@@ -37404,7 +37630,7 @@ var MCPOAuthProvider = class {
     try {
       logger.oauth("Attempting discovery via 401 response method");
       const customHeaders = getCustomHeaders();
-      const response = await fetch(this.config.serverUrl, {
+      const response = await proxyFetch(this.config.serverUrl, {
         headers: {
           Accept: "application/json",
           ...customHeaders
@@ -37416,7 +37642,7 @@ var MCPOAuthProvider = class {
           const authInfo = parseWWWAuthenticateHeader(wwwAuthHeader);
           logger.oauth("WWW-Authenticate header parsed successfully");
           if (authInfo.resource_metadata_url) {
-            const metadataResponse = await fetch(authInfo.resource_metadata_url, {
+            const metadataResponse = await proxyFetch(authInfo.resource_metadata_url, {
               headers: {
                 "Accept": "application/json",
                 ...customHeaders
@@ -38491,7 +38717,7 @@ async function wpRequest(requestData, useJsonRpc = true) {
     logger.api("Sending request to WordPress API...");
     logger.debug(`Request URL: ${url}`, "API");
     logger.debug(`Request method: ${method}`, "API");
-    const response = await fetch(url, fetchOptions);
+    const response = await proxyFetch(url, fetchOptions);
     logger.debug(`Response status: ${response.status}`, "API");
     if (!response.ok) {
       const errorText = await response.text();
@@ -38578,28 +38804,83 @@ function createSessionContext() {
 }
 
 // src/lib/transport-detection.ts
-async function detectTransportType(context) {
-  logger.info("Initializing connection to WordPress API with transport detection...", "PROXY");
+async function detectTransportType(context, initParams) {
+  logger.info("\u{1F50D} Starting transport detection and WordPress API initialization...", "TRANSPORT_DETECT");
   let init;
   let transportType = null;
+  const enhancedParams = initParams ? { ...initParams } : {};
+  if (enhancedParams.clientInfo) {
+    if (typeof enhancedParams.clientInfo === "object" && enhancedParams.clientInfo !== null && !Array.isArray(enhancedParams.clientInfo)) {
+      const originalClient = enhancedParams.clientInfo?.name || "unknown";
+      const newClientInfo = { ...enhancedParams.clientInfo };
+      if (newClientInfo.proxied && typeof newClientInfo.proxied === "object") {
+        newClientInfo.proxied = {
+          ...newClientInfo.proxied,
+          name: "@automattic/mcp-wordpress-remote",
+          version: MCP_WORDPRESS_REMOTE_VERSION
+        };
+      } else {
+        newClientInfo.proxied = {
+          name: "@automattic/mcp-wordpress-remote",
+          version: MCP_WORDPRESS_REMOTE_VERSION
+        };
+      }
+      enhancedParams.clientInfo = newClientInfo;
+      logger.info("\u{1F4CB} Added proxy information to clientInfo", "TRANSPORT_DETECT", {
+        originalClient,
+        proxyName: "@automattic/mcp-wordpress-remote",
+        proxyVersion: MCP_WORDPRESS_REMOTE_VERSION
+      });
+    } else {
+      logger.warn("clientInfo is present but not a valid object, skipping enhancement", "TRANSPORT_DETECT", {
+        clientInfoType: typeof enhancedParams.clientInfo,
+        isArray: Array.isArray(enhancedParams.clientInfo),
+        isNull: enhancedParams.clientInfo === null
+      });
+    }
+  } else {
+    logger.debug("No clientInfo provided in initialize parameters", "TRANSPORT_DETECT");
+  }
   try {
-    logger.info("Attempting JSON-RPC transport...", "PROXY");
-    const initMessage = addSessionInfo({ method: "initialize" }, {}, context);
+    logger.info("\u{1F4E1} Attempting JSON-RPC transport...", "TRANSPORT_DETECT");
+    const wpRequestParams = {
+      method: "initialize",
+      ...enhancedParams
+    };
+    const initMessage = addSessionInfo(wpRequestParams, {}, context);
+    logger.info("Sending initialization message via JSON-RPC:", "TRANSPORT_DETECT", {
+      method: initMessage.method,
+      id: initMessage.id,
+      jsonrpc: initMessage.jsonrpc,
+      hasParams: !!initMessage.params && Object.keys(initMessage.params).length > 1
+      // More than just _proxy_request_id
+    });
+    logger.debug("Complete JSON-RPC init message:", "TRANSPORT_DETECT", initMessage);
     const initResponse = await wpRequest(initMessage, true);
     init = initResponse;
     transportType = "jsonrpc";
-    logger.info("\u2705 JSON-RPC transport detected and working", "PROXY");
+    logger.info("\u2705 JSON-RPC transport detected and working", "TRANSPORT_DETECT");
+    logger.debug("JSON-RPC initialization response:", "TRANSPORT_DETECT", init);
   } catch (error) {
-    logger.warn("JSON-RPC transport failed, trying simple transport...", "PROXY");
-    logger.debug("JSON-RPC error:", "PROXY", error);
+    logger.warn("\u26A0\uFE0F  JSON-RPC transport failed, trying simple transport...", "TRANSPORT_DETECT");
+    logger.debug("JSON-RPC error details:", "TRANSPORT_DETECT", error);
     try {
-      const simpleInitRequest = { method: "initialize" };
-      const initResponse = await wpRequest(simpleInitRequest, false);
+      const simpleRequestParams = {
+        method: "initialize",
+        ...enhancedParams
+      };
+      logger.info("Sending initialization message via Simple transport:", "TRANSPORT_DETECT", {
+        method: simpleRequestParams.method,
+        hasParams: Object.keys(simpleRequestParams).length > 1
+      });
+      logger.debug("Complete Simple init message:", "TRANSPORT_DETECT", simpleRequestParams);
+      const initResponse = await wpRequest(simpleRequestParams, false);
       init = initResponse;
       transportType = "simple";
-      logger.info("\u2705 Simple transport detected and working", "PROXY");
+      logger.info("\u2705 Simple transport detected and working", "TRANSPORT_DETECT");
+      logger.debug("Simple initialization response:", "TRANSPORT_DETECT", init);
     } catch (simpleError) {
-      logger.error("Both JSON-RPC and simple transports failed", "PROXY", simpleError);
+      logger.error("\u274C Both JSON-RPC and simple transports failed", "TRANSPORT_DETECT", simpleError);
       throw new Error("Unable to establish connection with either transport type");
     }
   }
@@ -38621,36 +38902,54 @@ async function detectTransportType(context) {
 
 // src/lib/error-utils.ts
 function mapHttpStatusToMcpCode(statusCode) {
-  const MCP_ERROR_CODES = {
+  const JSONRPC_ERROR_CODES = {
     PARSE_ERROR: -32700,
     INVALID_REQUEST: -32600,
     METHOD_NOT_FOUND: -32601,
     INVALID_PARAMS: -32602,
-    INTERNAL_ERROR: -32603,
-    UNAUTHORIZED: -32010,
-    PERMISSION_DENIED: -32008
+    INTERNAL_ERROR: -32603
+  };
+  const MCP_ERROR_CODES = {
+    SERVER_ERROR: -32e3,
+    // Generic server error
+    TIMEOUT_ERROR: -32001,
+    // Request timeout
+    RESOURCE_NOT_FOUND: -32002,
+    // Resource not found
+    TOOL_NOT_FOUND: -32003,
+    // Tool not found  
+    PROMPT_NOT_FOUND: -32004,
+    // Prompt not found
+    PERMISSION_DENIED: -32008,
+    // Access denied/forbidden
+    UNAUTHORIZED: -32010
+    // Authentication required
   };
   switch (statusCode) {
     case 400:
-      return MCP_ERROR_CODES.INVALID_REQUEST;
+      return JSONRPC_ERROR_CODES.INVALID_REQUEST;
     case 401:
       return MCP_ERROR_CODES.UNAUTHORIZED;
     case 403:
       return MCP_ERROR_CODES.PERMISSION_DENIED;
     case 404:
-      return MCP_ERROR_CODES.METHOD_NOT_FOUND;
+      return JSONRPC_ERROR_CODES.METHOD_NOT_FOUND;
+    case 408:
+      return MCP_ERROR_CODES.TIMEOUT_ERROR;
+    case 413:
+    // Payload Too Large
     case 422:
-      return MCP_ERROR_CODES.INVALID_PARAMS;
+      return JSONRPC_ERROR_CODES.INVALID_PARAMS;
     case 500:
-    // Internal Server Error
+      return JSONRPC_ERROR_CODES.INTERNAL_ERROR;
     case 502:
     // Bad Gateway
     case 503:
-    // Service Unavailable
+      return MCP_ERROR_CODES.SERVER_ERROR;
     case 504:
-    // Gateway Timeout
+      return MCP_ERROR_CODES.TIMEOUT_ERROR;
     default:
-      return MCP_ERROR_CODES.INTERNAL_ERROR;
+      return JSONRPC_ERROR_CODES.INTERNAL_ERROR;
   }
 }
 function convertAPIErrorToMcpError(error) {
@@ -38680,17 +38979,38 @@ function createRequestHandler(config, context) {
 function createWrappedHandler(config, context) {
   const handler = createRequestHandler(config, context);
   return async (request) => {
-    logger.debug(`Received ${config.name} request`, "MCP", request);
+    logger.info(`\u{1F4E9} Client Message: ${config.name}`, "CLIENT");
+    logger.info(`Request ID: ${request.id || "none"} | Method: ${config.method}`, "CLIENT");
+    if (request.params && Object.keys(request.params).length > 0) {
+      logger.info(`Request parameters:`, "CLIENT", {
+        paramCount: Object.keys(request.params).length,
+        paramKeys: Object.keys(request.params)
+      });
+      logger.debug(`Full request parameters:`, "CLIENT", request.params);
+    } else {
+      logger.info(`No request parameters`, "CLIENT");
+    }
     logger.debug(
-      `Adding session info - Session ID: ${context.sessionId}, MCP Request ID: ${request.id}`,
-      "SESSION"
+      `Session context - ID: ${context.sessionId || "none"}, Transport: ${context.transportType || "detecting"}, Counter: ${context.requestIdCounter}`,
+      "CLIENT"
     );
+    logger.debug(`Complete client request object:`, "CLIENT", request);
+    const startTime = Date.now();
     try {
       const response = await handler(request);
-      logger.debug(`${config.name} response sent`, "MCP");
+      const duration = Date.now() - startTime;
+      logger.info(`\u2705 Client Response: ${config.name} completed in ${duration}ms`, "CLIENT");
+      logger.debug(`Response sent to client:`, "CLIENT", {
+        hasResponse: !!response,
+        responseKeys: response && typeof response === "object" ? Object.keys(response) : "primitive"
+      });
       return response;
     } catch (error) {
-      logger.error(`Error handling ${config.name} request`, "MCP", error);
+      const duration = Date.now() - startTime;
+      logger.error(`\u274C Client Error: ${config.name} failed after ${duration}ms`, "CLIENT", {
+        error: error instanceof Error ? error.message : String(error),
+        requestId: request.id
+      });
       if (isAPIError(error) && context.transportType === "simple") {
         logger.debug(`Converting APIError to MCP error format for ${config.name} (simple transport)`, "MCP", {
           statusCode: error.statusCode,
@@ -38815,17 +39135,57 @@ async function WordPressProxy() {
     logger.warn("Error cleaning up expired tokens", "PROXY", error);
   }
   const sessionContext = createSessionContext();
-  const { initResult } = await detectTransportType(sessionContext);
   const server = new Server(
     {
-      name: initResult.serverInfo.name,
-      version: initResult.serverInfo.version
+      name: "WordPress MCP Remote Proxy",
+      version: MCP_WORDPRESS_REMOTE_VERSION
     },
     {
-      capabilities: initResult.capabilities
-      // Type assertion to fix linter error
+      capabilities: {
+        tools: {},
+        resources: {},
+        prompts: {},
+        logging: {},
+        completions: {}
+      }
     }
   );
+  server.setRequestHandler(InitializeRequestSchema, async (request) => {
+    logger.info("\u{1F4E9} Client Initialize Request received", "INIT");
+    logger.debug("Initialize request details:", "INIT", request);
+    try {
+      logger.info("\u{1F504} Initializing WordPress connection with client parameters", "INIT");
+      const { initResult } = await detectTransportType(sessionContext, request.params);
+      const wordpressInitResponse = {
+        protocolVersion: initResult.protocolVersion || "2025-06-18",
+        serverInfo: initResult.serverInfo,
+        capabilities: initResult.capabilities,
+        instructions: initResult.instructions || "MCP WordPress Remote Proxy Server"
+      };
+      logger.info("\u2705 Returning WordPress server initialize response", "INIT");
+      logger.debug("Initialize response:", "INIT", wordpressInitResponse);
+      return wordpressInitResponse;
+    } catch (error) {
+      logger.error("\u274C Failed to initialize WordPress connection with client parameters", "INIT", error);
+      const fallbackResponse = {
+        protocolVersion: "2025-06-18",
+        serverInfo: {
+          name: "WordPress MCP Remote Proxy",
+          version: MCP_WORDPRESS_REMOTE_VERSION
+        },
+        capabilities: {
+          tools: {},
+          resources: {},
+          prompts: {},
+          logging: {},
+          completions: {}
+        },
+        instructions: "MCP WordPress Remote Proxy Server (Connection Failed)"
+      };
+      logger.warn("\u26A0\uFE0F Using fallback initialize response", "INIT");
+      return fallbackResponse;
+    }
+  });
   server.setRequestHandler(ListToolsRequestSchema, createWrappedHandler(HANDLER_CONFIGS.listTools, sessionContext));
   server.setRequestHandler(CallToolRequestSchema, createWrappedHandler(HANDLER_CONFIGS.callTool, sessionContext));
   server.setRequestHandler(ListResourcesRequestSchema, createWrappedHandler(HANDLER_CONFIGS.listResources, sessionContext));
@@ -38839,6 +39199,25 @@ async function WordPressProxy() {
   server.setRequestHandler(CompleteRequestSchema, createWrappedHandler(HANDLER_CONFIGS.complete, sessionContext));
   server.setRequestHandler(ListRootsRequestSchema, createWrappedHandler(HANDLER_CONFIGS.listRoots, sessionContext));
   const transport = new StdioServerTransport();
+  transport.onmessage = (message) => {
+    const msg = message;
+    const method = typeof msg?.method === "string" ? msg.method : "unknown";
+    const id = msg?.id ?? "none";
+    const hasParams = Boolean(msg?.params && typeof msg.params === "object" && Object.keys(msg.params).length);
+    logger.info("\u{1F4E5} Raw client message received", "TRANSPORT", {
+      method,
+      id,
+      hasParams,
+      messageType: method === "unknown" ? "response/notification" : "request"
+    });
+    logger.debug("Complete raw message:", "TRANSPORT", message);
+  };
+  transport.onerror = (error) => {
+    logger.error("\u274C Transport error:", "TRANSPORT", error);
+  };
+  transport.onclose = () => {
+    logger.info("\u{1F50C} Transport connection closed", "TRANSPORT");
+  };
   server.connect(transport).then(() => {
     logger.info("MCP server connected to transport successfully", "PROXY");
   }).catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automattic/mcp-wordpress-remote",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "description": "MCP WordPress Remote proxy server",
   "engines": {
     "node": ">=18.0.0"
@@ -59,9 +59,13 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.8.0",
+    "@tootallnate/quickjs-emscripten": "^0.23.0",
     "express": "^4.18.2",
+    "https-proxy-agent": "^7.0.6",
     "node-fetch": "^3.3.2",
-    "open": "^10.0.0"
+    "open": "^10.0.0",
+    "pac-resolver": "^7.0.1",
+    "socks-proxy-agent": "^8.0.5"
   },
   "devDependencies": {
     "@playwright/test": "^1.54.2",
@@ -101,7 +105,11 @@
       "open"
     ],
     "external": [
-      "node:*"
+      "node:*",
+      "@tootallnate/quickjs-emscripten",
+      "pac-resolver",
+      "socks-proxy-agent",
+      "https-proxy-agent"
     ],
     "minify": false,
     "sourcemap": false,