mcp-wordpress 1.1.2 → 1.1.7

package/src/index.ts

@@ -1,23 +1,23 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import dotenv from "dotenv";
-import * as fs from "fs";
-import * as path from "path";
-import { fileURLToPath } from "url";
-import { WordPressClient } from "./client/api.js";
-import { AuthMethod, WordPressClientConfig } from "./types/client.js";
-import * as Tools from "./tools/index.js";
-import { getErrorMessage } from "./utils/error.js";
-import { z } from "zod";
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import dotenv from 'dotenv';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { WordPressClient } from './client/api.js';
+import { AuthMethod, WordPressClientConfig } from './types/client.js';
+import * as Tools from './tools/index.js';
+import { getErrorMessage } from './utils/error.js';
+import { z } from 'zod';
 
 // --- Constants ---
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const rootDir = path.resolve(__dirname, "..");
-const envPath = path.resolve(rootDir, ".env");
+const rootDir = path.resolve(__dirname, '..');
+const envPath = path.resolve(rootDir, '.env');
 dotenv.config({ path: envPath });
 
-const SERVER_VERSION = "1.1.1"; // Updated version with test fixes
+const SERVER_VERSION = '1.1.7'; // Docker containerization and automated publishing
 
 // --- Main Server Class ---
 class MCPWordPressServer {
@@ -33,38 +33,42 @@ class MCPWordPressServer {
 
     if (this.wordpressClients.size === 0) {
       console.error(
-        "No WordPress sites were configured. Please create mcp-wordpress.config.json or set environment variables.",
+        'No WordPress sites were configured. Please create mcp-wordpress.config.json or set environment variables.'
       );
       process.exit(1);
     }
 
     this.server = new McpServer({
-      name: "mcp-wordpress",
-      version: SERVER_VERSION,
+      name: 'mcp-wordpress',
+      version: SERVER_VERSION
     });
 
     this.setupTools();
   }
 
   private loadConfiguration(mcpConfig?: any) {
-    const configPath = path.resolve(rootDir, "mcp-wordpress.config.json");
+    const configPath = path.resolve(rootDir, 'mcp-wordpress.config.json');
 
     if (fs.existsSync(configPath)) {
-      console.error(
-        "INFO: Found mcp-wordpress.config.json, loading multi-site configuration.",
-      );
+      if (process.env.NODE_ENV !== 'test') {
+        console.error(
+          'INFO: Found mcp-wordpress.config.json, loading multi-site configuration.'
+        );
+      }
       this.loadMultiSiteConfig(configPath);
     } else {
-      console.error(
-        "INFO: mcp-wordpress.config.json not found, falling back to environment variables for single-site mode.",
-      );
+      if (process.env.NODE_ENV !== 'test') {
+        console.error(
+          'INFO: mcp-wordpress.config.json not found, falling back to environment variables for single-site mode.'
+        );
+      }
       this.loadSingleSiteFromEnv(mcpConfig);
     }
   }
 
   private loadMultiSiteConfig(configPath: string) {
     try {
-      const configFile = fs.readFileSync(configPath, "utf-8");
+      const configFile = fs.readFileSync(configPath, 'utf-8');
       const config = JSON.parse(configFile);
 
       if (!config.sites || !Array.isArray(config.sites)) {
@@ -79,26 +83,28 @@ class MCPWordPressServer {
             auth: {
               method:
                 (site.config.WORDPRESS_AUTH_METHOD as AuthMethod) ||
-                "app-password",
+                'app-password',
               username: site.config.WORDPRESS_USERNAME,
-              appPassword: site.config.WORDPRESS_APP_PASSWORD,
-            },
+              appPassword: site.config.WORDPRESS_APP_PASSWORD
+            }
           };
           const client = new WordPressClient(clientConfig);
           this.wordpressClients.set(site.id, client);
-          console.error(
-            `INFO: Initialized client for site: ${site.name} (ID: ${site.id})`,
-          );
+          if (process.env.NODE_ENV !== 'test') {
+            console.error(
+              `INFO: Initialized client for site: ${site.name} (ID: ${site.id})`
+            );
+          }
         } else {
           console.warn(
-            "WARN: Skipping invalid site entry in config. Must have id, name, and config.",
-            site,
+            'WARN: Skipping invalid site entry in config. Must have id, name, and config.',
+            site
           );
         }
       }
     } catch (error) {
       console.error(
-        `FATAL: Error reading or parsing mcp-wordpress.config.json: ${getErrorMessage(error)}`,
+        `FATAL: Error reading or parsing mcp-wordpress.config.json: ${getErrorMessage(error)}`
       );
       process.exit(1);
     }
@@ -113,31 +119,31 @@ class MCPWordPressServer {
       mcpConfig?.wordpressAppPassword || process.env.WORDPRESS_APP_PASSWORD;
     const authMethod = (mcpConfig?.wordpressAuthMethod ||
       process.env.WORDPRESS_AUTH_METHOD ||
-      "app-password") as AuthMethod;
+      'app-password') as AuthMethod;
 
     if (!siteUrl || !username || !password) {
       console.error(
-        "ERROR: Missing required credentials for single-site mode.",
+        'ERROR: Missing required credentials for single-site mode.'
       );
       console.error(
-        "Please set WORDPRESS_SITE_URL, WORDPRESS_USERNAME, and WORDPRESS_APP_PASSWORD environment variables.",
+        'Please set WORDPRESS_SITE_URL, WORDPRESS_USERNAME, and WORDPRESS_APP_PASSWORD environment variables.'
       );
       return;
     }
 
     const singleSiteConfig: WordPressClientConfig = {
       baseUrl: siteUrl,
-      auth: { method: authMethod, username, appPassword: password },
+      auth: { method: authMethod, username, appPassword: password }
     };
     const client = new WordPressClient(singleSiteConfig);
-    this.wordpressClients.set("default", client);
+    this.wordpressClients.set('default', client);
     this.siteConfigs.push({
-      id: "default",
-      name: "Default Site",
-      config: singleSiteConfig,
+      id: 'default',
+      name: 'Default Site',
+      config: singleSiteConfig
     });
     console.error(
-      "INFO: Initialized client for default site in single-site mode.",
+      'INFO: Initialized client for default site in single-site mode.'
     );
   }
 
@@ -146,7 +152,7 @@ class MCPWordPressServer {
     Object.values(Tools).forEach((ToolClass) => {
       const toolInstance = new ToolClass();
       const tools = toolInstance.getTools();
-      
+
       tools.forEach((tool) => {
         this.registerTool(tool);
       });
@@ -156,50 +162,59 @@ class MCPWordPressServer {
   private registerTool(tool: any) {
     // Create base parameter schema with site parameter
     const baseSchema = {
-      site: z.string()
+      site: z
+        .string()
         .optional()
-        .describe("The ID of the WordPress site to target (from mcp-wordpress.config.json). Required if multiple sites are configured."),
+        .describe(
+          'The ID of the WordPress site to target (from mcp-wordpress.config.json). Required if multiple sites are configured.'
+        )
     };
 
     // Merge with tool-specific parameters
-    const parameterSchema = tool.parameters?.reduce((schema: any, param: any) => {
-      let zodType;
-      
-      switch (param.type) {
-        case 'string':
-          zodType = z.string();
-          break;
-        case 'number':
-          zodType = z.number();
-          break;
-        case 'boolean':
-          zodType = z.boolean();
-          break;
-        case 'array':
-          zodType = z.array(z.string());
-          break;
-        case 'object':
-          zodType = z.record(z.any());
-          break;
-        default:
-          zodType = z.string();
-      }
+    const parameterSchema =
+      tool.parameters?.reduce(
+        (schema: any, param: any) => {
+          let zodType;
+
+          switch (param.type) {
+          case 'string':
+            zodType = z.string();
+            break;
+          case 'number':
+            zodType = z.number();
+            break;
+          case 'boolean':
+            zodType = z.boolean();
+            break;
+          case 'array':
+            zodType = z.array(z.string());
+            break;
+          case 'object':
+            zodType = z.record(z.any());
+            break;
+          default:
+            zodType = z.string();
+          }
 
-      if (param.description) {
-        zodType = zodType.describe(param.description);
-      }
+          if (param.description) {
+            zodType = zodType.describe(param.description);
+          }
 
-      if (!param.required) {
-        zodType = zodType.optional();
-      }
+          if (!param.required) {
+            zodType = zodType.optional();
+          }
 
-      schema[param.name] = zodType;
-      return schema;
-    }, { ...baseSchema }) || baseSchema;
+          schema[param.name] = zodType;
+          return schema;
+        },
+        { ...baseSchema }
+      ) || baseSchema;
 
     // Make site parameter required if multiple sites are configured
     if (this.wordpressClients.size > 1) {
-      parameterSchema.site = parameterSchema.site.describe("The ID of the WordPress site to target (from mcp-wordpress.config.json). Required when multiple sites are configured.");
+      parameterSchema.site = parameterSchema.site.describe(
+        'The ID of the WordPress site to target (from mcp-wordpress.config.json). Required when multiple sites are configured.'
+      );
     }
 
     this.server.tool(
@@ -208,46 +223,58 @@ class MCPWordPressServer {
       parameterSchema,
       async (args: any) => {
         try {
-          const siteId = args.site || "default";
+          const siteId = args.site || 'default';
           const client = this.wordpressClients.get(siteId);
 
           if (!client) {
-            const availableSites = Array.from(this.wordpressClients.keys()).join(", ");
+            const availableSites = Array.from(
+              this.wordpressClients.keys()
+            ).join(', ');
             return {
-              content: [{
-                type: "text" as const,
-                text: `Error: Site with ID '${siteId}' not found. Available sites: ${availableSites}`
-              }],
+              content: [
+                {
+                  type: 'text' as const,
+                  text: `Error: Site with ID '${siteId}' not found. Available sites: ${availableSites}`
+                }
+              ],
               isError: true
             };
           }
 
           // Call the tool handler with the client and parameters
           const result = await tool.handler(client, args);
-          
+
           return {
-            content: [{
-              type: "text" as const,
-              text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
-            }]
+            content: [
+              {
+                type: 'text' as const,
+                text:
+                  typeof result === 'string'
+                    ? result
+                    : JSON.stringify(result, null, 2)
+              }
+            ]
           };
-
         } catch (error) {
           if (this.isAuthenticationError(error)) {
             return {
-              content: [{
-                type: "text" as const,
-                text: `Authentication failed for site '${args.site || "default"}'. Please check your credentials.`
-              }],
+              content: [
+                {
+                  type: 'text' as const,
+                  text: `Authentication failed for site '${args.site || 'default'}'. Please check your credentials.`
+                }
+              ],
               isError: true
             };
           }
-          
+
           return {
-            content: [{
-              type: "text" as const,
-              text: `Error: ${getErrorMessage(error)}`
-            }],
+            content: [
+              {
+                type: 'text' as const,
+                text: `Error: ${getErrorMessage(error)}`
+              }
+            ],
             isError: true
           };
         }
@@ -257,7 +284,7 @@ class MCPWordPressServer {
 
   private async testClientConnections(): Promise<void> {
     console.error(
-      "INFO: Testing connections to all configured WordPress sites...",
+      'INFO: Testing connections to all configured WordPress sites...'
     );
     const connectionPromises = Array.from(this.wordpressClients.entries()).map(
       async ([siteId, client]) => {
@@ -266,47 +293,47 @@ class MCPWordPressServer {
           console.error(`SUCCESS: Connection to site '${siteId}' successful.`);
         } catch (error) {
           console.error(
-            `ERROR: Failed to connect to site '${siteId}': ${getErrorMessage(error)}`,
+            `ERROR: Failed to connect to site '${siteId}': ${getErrorMessage(error)}`
           );
           if (this.isAuthenticationError(error)) {
             console.error(
-              `Authentication may have failed for site '${siteId}'. Please check credentials.`,
+              `Authentication may have failed for site '${siteId}'. Please check credentials.`
             );
           }
         }
-      },
+      }
     );
     await Promise.all(connectionPromises);
     this.initialized = true;
-    console.error("INFO: Connection tests complete.");
+    console.error('INFO: Connection tests complete.');
   }
 
   private isAuthenticationError(error: any): boolean {
     if (error?.response?.status && [401, 403].includes(error.response.status)) {
       return true;
     }
-    return error?.code === "WORDPRESS_AUTH_ERROR";
+    return error?.code === 'WORDPRESS_AUTH_ERROR';
   }
 
   async run() {
     if (!this.initialized) {
       await this.testClientConnections();
     }
-    console.error("INFO: Starting MCP WordPress Server...");
-    
+    console.error('INFO: Starting MCP WordPress Server...');
+
     // Connect to stdio transport
     const transport = new StdioServerTransport();
     await this.server.connect(transport);
-    
+
     console.error(
-      `INFO: Server started and connected. Tools available for ${this.wordpressClients.size} site(s).`,
+      `INFO: Server started and connected. Tools available for ${this.wordpressClients.size} site(s).`
     );
   }
 
   async shutdown() {
-    console.error("INFO: Shutting down MCP WordPress Server...");
+    console.error('INFO: Shutting down MCP WordPress Server...');
     await this.server.close();
-    console.error("INFO: Server stopped.");
+    console.error('INFO: Server stopped.');
   }
 }
 
@@ -321,8 +348,8 @@ async function main() {
       process.exit(0);
     };
 
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
   } catch (error) {
     console.error(`FATAL: Failed to start server: ${getErrorMessage(error)}`);
     process.exit(1);
@@ -334,4 +361,4 @@ if (process.argv[1] === fileURLToPath(import.meta.url)) {
 }
 
 export default MCPWordPressServer;
-export { MCPWordPressServer };
+export { MCPWordPressServer };

package/src/server.ts

@@ -4,4 +4,4 @@
  */
 
 export { default as MCPWordPressServer } from './index.js';
-export { default } from './index.js';
+export { default } from './index.js';

package/src/tools/auth.ts

@@ -1,6 +1,6 @@
-import { WordPressClient } from "../client/api.js";
-import { AuthMethod } from "../types/client.js";
-import { getErrorMessage } from "../utils/error.js";
+import { WordPressClient } from '../client/api.js';
+import { AuthMethod } from '../types/client.js';
+import { getErrorMessage } from '../utils/error.js';
 
 /**
  * Provides authentication-related tools for WordPress sites.
@@ -14,51 +14,51 @@ export class AuthTools {
   public getTools(): any[] {
     return [
       {
-        name: "wp_test_auth",
+        name: 'wp_test_auth',
         description:
-          "Tests the authentication and connectivity for a configured WordPress site.",
+          'Tests the authentication and connectivity for a configured WordPress site.',
         parameters: [], // The 'site' parameter is added dynamically by the server
-        handler: this.handleTestAuth.bind(this),
+        handler: this.handleTestAuth.bind(this)
       },
       {
-        name: "wp_get_auth_status",
+        name: 'wp_get_auth_status',
         description:
-          "Gets the current authentication status for a configured WordPress site.",
+          'Gets the current authentication status for a configured WordPress site.',
         parameters: [],
-        handler: this.handleGetAuthStatus.bind(this),
+        handler: this.handleGetAuthStatus.bind(this)
       },
       {
-        name: "wp_switch_auth_method",
+        name: 'wp_switch_auth_method',
         description:
-          "Switches the authentication method for a site for the current session.",
+          'Switches the authentication method for a site for the current session.',
         parameters: [
           {
-            name: "method",
-            type: "string",
+            name: 'method',
+            type: 'string',
             required: true,
-            description: "The new authentication method to use.",
-            enum: ["app-password", "jwt", "basic", "api-key", "cookie"],
+            description: 'The new authentication method to use.',
+            enum: ['app-password', 'jwt', 'basic', 'api-key', 'cookie']
           },
           {
-            name: "username",
-            type: "string",
+            name: 'username',
+            type: 'string',
             description:
-              "The username for 'app-password' or 'basic' authentication.",
+              'The username for \'app-password\' or \'basic\' authentication.'
           },
           {
-            name: "password",
-            type: "string",
+            name: 'password',
+            type: 'string',
             description:
-              "The Application Password for 'app-password' or password for 'basic' auth.",
+              'The Application Password for \'app-password\' or password for \'basic\' auth.'
           },
           {
-            name: "jwt_token",
-            type: "string",
-            description: "The token for 'jwt' authentication.",
-          },
+            name: 'jwt_token',
+            type: 'string',
+            description: 'The token for \'jwt\' authentication.'
+          }
         ],
-        handler: this.handleSwitchAuthMethod.bind(this),
-      },
+        handler: this.handleSwitchAuthMethod.bind(this)
+      }
     ];
   }
 
@@ -71,7 +71,7 @@ export class AuthTools {
    */
   public async handleTestAuth(
     client: WordPressClient,
-    params: any,
+    params: any
   ): Promise<any> {
     try {
       await client.ping();
@@ -79,12 +79,12 @@ export class AuthTools {
       const siteConfig = client.config;
 
       const content =
-        `✅ **Authentication successful!**\n\n` +
+        '✅ **Authentication successful!**\n\n' +
         `**Site:** ${siteConfig.baseUrl}\n` +
         `**Method:** ${siteConfig.auth.method}\n` +
         `**User:** ${user.name} (@${user.slug})\n` +
-        `**Roles:** ${user.roles?.join(", ") || "N/A"}\n\n` +
-        `Your WordPress connection is working properly.`;
+        `**Roles:** ${user.roles?.join(', ') || 'N/A'}\n\n` +
+        'Your WordPress connection is working properly.';
 
       return content;
     } catch (error) {
@@ -101,21 +101,21 @@ export class AuthTools {
    */
   public async handleGetAuthStatus(
     client: WordPressClient,
-    params: any,
+    params: any
   ): Promise<any> {
     try {
       const isAuthenticated = client.isAuthenticated;
       const config = client.config;
       let content =
         `**Authentication Status for ${config.baseUrl}**\n\n` +
-        `**Authenticated:** ${isAuthenticated ? "✅ Yes" : "❌ No"}\n` +
+        `**Authenticated:** ${isAuthenticated ? '✅ Yes' : '❌ No'}\n` +
         `**Method:** ${config.auth.method}\n`;
 
       if (isAuthenticated) {
         const user = await client.getCurrentUser();
         content += `**User:** ${user.name} (@${user.slug})\n`;
       } else {
-        content += `**Status:** Not connected. Use 'wp_test_auth' to connect and verify credentials.`;
+        content += '**Status:** Not connected. Use \'wp_test_auth\' to connect and verify credentials.';
       }
 
       return content;
@@ -138,12 +138,12 @@ export class AuthTools {
       username?: string;
       password?: string;
       jwt_token?: string;
-    },
+    }
   ): Promise<any> {
     try {
       // This functionality is not currently supported as the client
       // doesn't have an updateAuthConfig method
-      throw new Error("Dynamic authentication method switching is not currently supported. Please update your configuration file and restart the server.");
+      throw new Error('Dynamic authentication method switching is not currently supported. Please update your configuration file and restart the server.');
     } catch (error) {
       throw new Error(`Failed to switch auth method: ${getErrorMessage(error)}`);
     }