@automattic/mcp-wordpress-remote 0.2.16 → 0.2.18

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.16";
+var MCP_WORDPRESS_REMOTE_VERSION = "0.2.18";
 var CONFIG = {
   // API Configuration
   WP_API_URL: process.env.WP_API_URL || "https://example.com",
@@ -36082,6 +36082,9 @@ var CONFIG = {
   JWT_TOKEN: process.env.JWT_TOKEN,
   WOO_CUSTOMER_KEY: process.env.WOO_CUSTOMER_KEY,
   WOO_CUSTOMER_SECRET: process.env.WOO_CUSTOMER_SECRET,
+  // Custom Headers Configuration
+  CUSTOM_HEADERS: process.env.CUSTOM_HEADERS || "",
+  // JSON string or comma-separated header:value pairs
   // Environment
   NODE_ENV: process.env.NODE_ENV || "development"
 };
@@ -36095,17 +36098,54 @@ function getDefaultOAuthScopes() {
   const defaultScopes = ["read", "write"];
   return parseOAuthScopes(CONFIG.OAUTH_SCOPES, defaultScopes);
 }
+function parseCustomHeaders(customHeadersString) {
+  if (!customHeadersString || customHeadersString.trim() === "") {
+    return {};
+  }
+  try {
+    if (customHeadersString.trim().startsWith("{")) {
+      return JSON.parse(customHeadersString);
+    }
+    const headers = {};
+    const pairs = customHeadersString.split(",");
+    for (const pair of pairs) {
+      const colonIndex = pair.indexOf(":");
+      if (colonIndex > 0) {
+        const key = pair.substring(0, colonIndex).trim();
+        const value = pair.substring(colonIndex + 1).trim();
+        if (key && value) {
+          headers[key] = value;
+        }
+      }
+    }
+    return headers;
+  } catch (error) {
+    logger.error("Error parsing custom headers", "CONFIG", error);
+    return {};
+  }
+}
+function getCustomHeaders() {
+  const customHeadersEnv = process.env.CUSTOM_HEADERS || "";
+  return parseCustomHeaders(customHeadersEnv);
+}
 function validateConfig() {
   const errors = [];
-  const hasJWT = !!CONFIG.JWT_TOKEN;
-  const hasBasicAuth = !!(CONFIG.WP_API_USERNAME && CONFIG.WP_API_PASSWORD);
-  const hasOAuth = CONFIG.OAUTH_ENABLED;
-  if (!hasJWT && !hasBasicAuth && !hasOAuth) {
+  const currentApiUrl = process.env.WP_API_URL || CONFIG.WP_API_URL;
+  const currentCustomHeaders = process.env.CUSTOM_HEADERS || CONFIG.CUSTOM_HEADERS;
+  const currentJwtToken = process.env.JWT_TOKEN || CONFIG.JWT_TOKEN;
+  const currentUsername = process.env.WP_API_USERNAME || CONFIG.WP_API_USERNAME;
+  const currentPassword = process.env.WP_API_PASSWORD || CONFIG.WP_API_PASSWORD;
+  const currentOAuthEnabled = process.env.OAUTH_ENABLED === "true" || CONFIG.OAUTH_ENABLED;
+  const hasJWT = !!currentJwtToken;
+  const hasBasicAuth = !!(currentUsername && currentPassword);
+  const hasOAuth = currentOAuthEnabled;
+  const hasCustomHeaders = !!currentCustomHeaders && currentCustomHeaders.trim() !== "";
+  if (!hasJWT && !hasBasicAuth && !hasOAuth && !hasCustomHeaders) {
     errors.push(
-      "No authentication method configured. Please set one of: JWT_TOKEN, WP_API_USERNAME+WP_API_PASSWORD, or enable OAuth"
+      "No authentication method configured. Please set one of: JWT_TOKEN, WP_API_USERNAME+WP_API_PASSWORD, enable OAuth, or set CUSTOM_HEADERS"
     );
   }
-  if (!CONFIG.WP_API_URL || CONFIG.WP_API_URL === "https://example.com") {
+  if (!currentApiUrl || currentApiUrl === "https://example.com") {
     errors.push("WP_API_URL must be set to your WordPress site URL");
   }
   if (CONFIG.OAUTH_ENABLED) {
@@ -36139,7 +36179,8 @@ function formatConfigError(error) {
     return `${error}. Configure one of these options:
     \u2022 JWT_TOKEN=your_jwt_token (preferred for APIs)
     \u2022 WP_API_USERNAME=username and WP_API_PASSWORD=app_password (for application passwords)
-    \u2022 Set OAUTH_ENABLED=true and WP_OAUTH_CLIENT_ID=your_client_id (for OAuth 2.1)`;
+    \u2022 Set OAUTH_ENABLED=true and WP_OAUTH_CLIENT_ID=your_client_id (for OAuth 2.1)
+    \u2022 CUSTOM_HEADERS='{"X-API-Key": "your_api_key"}' (for custom header authentication)`;
   }
   if (error.includes("OAUTH_CALLBACK_PORT")) {
     return `${error}. The port must be available for the OAuth callback server. Try a different port like 7777, 7890, or other ports in the safe 7000-7999 range.`;
@@ -36177,7 +36218,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);
   }
@@ -36739,7 +36782,13 @@ async function discoverAuthorizationServerMetadata(authorizationServerUrl) {
   try {
     const metadataUrl = new URL("/.well-known/oauth-authorization-server", authorizationServerUrl);
     logger.oauth(`Discovering authorization server metadata: ${metadataUrl}`);
-    const response = await fetch(metadataUrl.toString());
+    const customHeaders = getCustomHeaders();
+    const response = await fetch(metadataUrl.toString(), {
+      headers: {
+        "Accept": "application/json",
+        ...customHeaders
+      }
+    });
     if (!response.ok) {
       throw new OAuthError(
         `Failed to fetch authorization server metadata: ${response.status}`,
@@ -36770,7 +36819,13 @@ async function discoverProtectedResourceMetadata(resourceUrl) {
     const url = new URL(resourceUrl);
     const metadataUrl = new URL("/.well-known/oauth-protected-resource", url.origin);
     logger.oauth(`Discovering protected resource metadata: ${metadataUrl}`);
-    const response = await fetch(metadataUrl.toString());
+    const customHeaders = getCustomHeaders();
+    const response = await fetch(metadataUrl.toString(), {
+      headers: {
+        "Accept": "application/json",
+        ...customHeaders
+      }
+    });
     if (!response.ok) {
       throw new OAuthError(
         `Failed to fetch protected resource metadata: ${response.status}`,
@@ -36830,10 +36885,12 @@ function parseWWWAuthenticateHeader(headerValue) {
 async function registerDynamicClient(registrationEndpoint, registrationRequest) {
   try {
     logger.oauth(`Attempting dynamic client registration: ${registrationEndpoint}`);
+    const customHeaders = getCustomHeaders();
     const response = await fetch(registrationEndpoint, {
       method: "POST",
       headers: {
-        "Content-Type": "application/json"
+        "Content-Type": "application/json",
+        ...customHeaders
       },
       body: JSON.stringify(registrationRequest)
     });
@@ -36880,10 +36937,12 @@ async function exchangeAuthorizationCode(tokenEndpoint, code, redirectUri, clien
     if (resource) {
       params.set("resource", resource);
     }
+    const customHeaders = getCustomHeaders();
     const response = await fetch(tokenEndpoint, {
       method: "POST",
       headers: {
-        "Content-Type": "application/x-www-form-urlencoded"
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...customHeaders
       },
       body: params.toString()
     });
@@ -37346,9 +37405,11 @@ var MCPOAuthProvider = class {
   async discoverVia401Response() {
     try {
       logger.oauth("Attempting discovery via 401 response method");
+      const customHeaders = getCustomHeaders();
       const response = await fetch(this.config.serverUrl, {
         headers: {
-          Accept: "application/json"
+          Accept: "application/json",
+          ...customHeaders
         }
       });
       if (response.status === 401) {
@@ -37357,7 +37418,12 @@ 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 fetch(authInfo.resource_metadata_url, {
+              headers: {
+                "Accept": "application/json",
+                ...customHeaders
+              }
+            });
             if (metadataResponse.ok) {
               this.resourceMetadata = await metadataResponse.json();
               logger.oauth("Protected resource metadata obtained via 401 response");
@@ -38381,25 +38447,43 @@ async function wpRequest(requestData, useJsonRpc = true) {
     authHeader = `Basic ${auth2}`;
     logger.debug(`Auth header length: ${auth2.length}`, "AUTH");
   }
-  if (!authHeader) {
+  const customHeaders = getCustomHeaders();
+  const hasCustomHeaders = Object.keys(customHeaders).length > 0;
+  if (!authHeader && !hasCustomHeaders) {
     throw new AuthError(
-      "No authentication method available. Please configure JWT_TOKEN, OAuth, or Basic Auth (WP_API_USERNAME+WP_API_PASSWORD).",
+      "No authentication method available. Please configure JWT_TOKEN, OAuth, Basic Auth (WP_API_USERNAME+WP_API_PASSWORD), or CUSTOM_HEADERS.",
       "NO_AUTH_METHOD"
     );
   }
+  const currentApiUrl = process.env.WP_API_URL || CONFIG.WP_API_URL;
   logger.debug(`Environment: ${CONFIG.NODE_ENV}`, "API");
-  logger.debug(`Base API URL: ${CONFIG.WP_API_URL}`, "API");
-  const url = constructApiUrl(CONFIG.WP_API_URL, endpoint);
+  logger.debug(`Base API URL: ${currentApiUrl}`, "API");
+  const url = constructApiUrl(currentApiUrl, endpoint);
   logger.debug(`Final requesting URL: ${url}`, "API");
   const headers = {
-    Authorization: authHeader,
     "Content-Type": "application/json",
-    "MCP-Protocol-Version": "2025-06-18"
+    "MCP-Protocol-Version": "2025-06-18",
     // MCP protocol version
+    ...customHeaders
+    // Merge custom headers
   };
+  if (authHeader) {
+    headers.Authorization = authHeader;
+  }
   if (globalSessionId) {
     headers["Mcp-Session-Id"] = globalSessionId;
   }
+  if (authHeader) {
+    logger.debug("Using Authorization header for authentication", "API");
+  } else if (hasCustomHeaders) {
+    logger.auth("Using custom headers for authentication (no Authorization header)");
+  }
+  if (hasCustomHeaders) {
+    logger.debug(`Custom headers added: ${Object.keys(customHeaders).join(", ")}`, "API");
+    for (const [key, value] of Object.entries(customHeaders)) {
+      logger.debug(`Header ${key}: ${value.length} characters`, "API");
+    }
+  }
   const fetchOptions = {
     method,
     headers,
@@ -38496,28 +38580,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");
     }
   }
@@ -38539,36 +38678,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) {
@@ -38598,17 +38755,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,
@@ -38733,17 +38911,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: "0.2.17"
     },
     {
-      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: "0.2.17"
+        },
+        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));
@@ -38757,6 +38975,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.16",
+  "version": "0.2.18",
   "description": "MCP WordPress Remote proxy server",
   "engines": {
     "node": ">=18.0.0"