@automattic/mcp-wordpress-remote 0.2.17 → 0.2.18

package/dist/lib.d.ts

@@ -12,7 +12,7 @@ interface WordPressResponse {
     [key: string]: any;
 }
 
-declare const MCP_WORDPRESS_REMOTE_VERSION = "0.2.17";
+declare const MCP_WORDPRESS_REMOTE_VERSION = "0.2.18";
 /**
  * Centralized configuration for MCP WordPress Remote
  * All default values are defined here and can be overridden via environment variables

package/dist/lib.js

@@ -28867,7 +28867,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.18";
 var CONFIG = {
   // API Configuration
   WP_API_URL: process.env.WP_API_URL || "https://example.com",
@@ -29093,7 +29093,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);
   }

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.18";
 var CONFIG = {
   // API Configuration
   WP_API_URL: process.env.WP_API_URL || "https://example.com",
@@ -36218,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);
   }
@@ -38578,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");
     }
   }
@@ -38621,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) {
@@ -38680,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,
@@ -38815,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));
@@ -38839,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.17",
+  "version": "0.2.18",
   "description": "MCP WordPress Remote proxy server",
   "engines": {
     "node": ">=18.0.0"