myaidev-method 0.0.7 → 0.0.8

package/dist/mcp/wordpress-server.js

@@ -0,0 +1,1277 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import fetch from "node-fetch";
+import dotenv from "dotenv";
+import { GutenbergConverter } from "./gutenberg-converter.js";
+
+// Load environment variables
+dotenv.config();
+
+// WordPress API configuration from environment
+const WORDPRESS_URL = process.env.WORDPRESS_URL;
+const WORDPRESS_USERNAME = process.env.WORDPRESS_USERNAME;
+const WORDPRESS_APP_PASSWORD = process.env.WORDPRESS_APP_PASSWORD;
+const WORDPRESS_USE_GUTENBERG = process.env.WORDPRESS_USE_GUTENBERG === 'true';
+
+// Validate environment variables
+if (!WORDPRESS_URL || !WORDPRESS_USERNAME || !WORDPRESS_APP_PASSWORD) {
+  console.error("Missing required environment variables: WORDPRESS_URL, WORDPRESS_USERNAME, WORDPRESS_APP_PASSWORD");
+  process.exit(1);
+}
+
+// Session management
+class SessionManager {
+  constructor() {
+    this.sessions = new Map();
+    this.activeSession = null;
+    this.sessionTimeout = 30 * 60 * 1000; // 30 minutes
+  }
+
+  createSession(id = null) {
+    const sessionId = id || `wp_session_${Date.now()}`;
+    const session = {
+      id: sessionId,
+      created: Date.now(),
+      lastActivity: Date.now(),
+      operations: [],
+      context: {}
+    };
+    
+    this.sessions.set(sessionId, session);
+    this.activeSession = sessionId;
+    return sessionId;
+  }
+
+  getSession(id) {
+    return this.sessions.get(id);
+  }
+
+  updateActivity(id) {
+    const session = this.sessions.get(id);
+    if (session) {
+      session.lastActivity = Date.now();
+    }
+  }
+
+  logOperation(sessionId, operation) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.operations.push({
+        ...operation,
+        timestamp: Date.now()
+      });
+    }
+  }
+
+  cleanup() {
+    const now = Date.now();
+    for (const [id, session] of this.sessions) {
+      if (now - session.lastActivity > this.sessionTimeout) {
+        this.sessions.delete(id);
+      }
+    }
+  }
+}
+
+const sessionManager = new SessionManager();
+
+// Memory manager for persistence (simple implementation)
+class MemoryManager {
+  constructor() {
+    this.memory = new Map();
+    this.namespaces = new Map();
+  }
+
+  store(key, value, namespace = 'default', ttl = null) {
+    const nsMap = this.namespaces.get(namespace) || new Map();
+    const entry = {
+      value,
+      timestamp: Date.now(),
+      ttl: ttl ? Date.now() + ttl : null
+    };
+    nsMap.set(key, entry);
+    this.namespaces.set(namespace, nsMap);
+    return true;
+  }
+
+  retrieve(key, namespace = 'default') {
+    const nsMap = this.namespaces.get(namespace);
+    if (!nsMap) return null;
+    
+    const entry = nsMap.get(key);
+    if (!entry) return null;
+    
+    if (entry.ttl && Date.now() > entry.ttl) {
+      nsMap.delete(key);
+      return null;
+    }
+    
+    return entry.value;
+  }
+
+  delete(key, namespace = 'default') {
+    const nsMap = this.namespaces.get(namespace);
+    if (nsMap) {
+      return nsMap.delete(key);
+    }
+    return false;
+  }
+
+  list(namespace = 'default') {
+    const nsMap = this.namespaces.get(namespace);
+    if (!nsMap) return [];
+    
+    const now = Date.now();
+    const results = [];
+    
+    for (const [key, entry] of nsMap) {
+      if (entry.ttl && now > entry.ttl) {
+        nsMap.delete(key);
+        continue;
+      }
+      results.push({ key, value: entry.value, timestamp: entry.timestamp });
+    }
+    
+    return results;
+  }
+}
+
+const memoryManager = new MemoryManager();
+
+// Create MCP server with enhanced configuration
+const server = new McpServer({
+  name: "wordpress-mcp-server",
+  version: "2.0.0",
+  description: "Enhanced WordPress MCP Server with session management and memory persistence"
+});
+
+// Enhanced helper function for WordPress API requests with better error handling
+async function wordpressRequest(endpoint, method = 'GET', data = null, sessionId = null) {
+  const baseUrl = WORDPRESS_URL.replace(/\/$/, '');
+  const apiPath = '/wp-json/wp/v2';
+  const auth = Buffer.from(`${WORDPRESS_USERNAME}:${WORDPRESS_APP_PASSWORD}`).toString('base64');
+  
+  const options = {
+    method,
+    headers: {
+      'Authorization': `Basic ${auth}`,
+      'Content-Type': 'application/json',
+      'User-Agent': 'WordPress-MCP-Server/2.0.0'
+    },
+    timeout: 30000 // 30 second timeout
+  };
+
+  if (data && method !== 'GET') {
+    options.body = JSON.stringify(data);
+  }
+
+  const startTime = Date.now();
+  let response;
+  
+  try {
+    response = await fetch(`${baseUrl}${apiPath}${endpoint}`, options);
+    
+    // Log operation if session provided
+    if (sessionId) {
+      sessionManager.logOperation(sessionId, {
+        type: 'api_request',
+        method,
+        endpoint,
+        status: response.status,
+        duration: Date.now() - startTime
+      });
+      sessionManager.updateActivity(sessionId);
+    }
+    
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = await response.text();
+      }
+      
+      throw new MCPError({
+        code: response.status,
+        message: `WordPress API Error: ${response.status} - ${response.statusText}`,
+        details: errorBody,
+        endpoint,
+        method
+      });
+    }
+
+    return await response.json();
+    
+  } catch (error) {
+    // Log error operation
+    if (sessionId) {
+      sessionManager.logOperation(sessionId, {
+        type: 'api_error',
+        method,
+        endpoint,
+        error: error.message,
+        duration: Date.now() - startTime
+      });
+    }
+    
+    if (error instanceof MCPError) {
+      throw error;
+    }
+    
+    throw new MCPError({
+      code: 'NETWORK_ERROR',
+      message: `Network error: ${error.message}`,
+      details: error,
+      endpoint,
+      method
+    });
+  }
+}
+
+// Custom error class for better error handling
+class MCPError extends Error {
+  constructor({ code, message, details, endpoint, method }) {
+    super(message);
+    this.name = 'MCPError';
+    this.code = code;
+    this.details = details;
+    this.endpoint = endpoint;
+    this.method = method;
+  }
+
+  toJSON() {
+    return {
+      success: false,
+      error: {
+        code: this.code,
+        message: this.message,
+        details: this.details,
+        endpoint: this.endpoint,
+        method: this.method,
+        timestamp: Date.now()
+      }
+    };
+  }
+}
+
+// Enhanced response formatter
+function formatMCPResponse(data, success = true) {
+  const response = {
+    success,
+    timestamp: Date.now(),
+    server_version: "2.0.0"
+  };
+
+  if (success) {
+    response.data = data;
+  } else {
+    response.error = data;
+  }
+
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(response, null, 2)
+    }]
+  };
+}
+
+// Tool execution wrapper with enhanced error handling
+async function executeTool(toolName, params, handler) {
+  const sessionId = sessionManager.activeSession || sessionManager.createSession();
+  
+  try {
+    sessionManager.updateActivity(sessionId);
+    
+    const startTime = Date.now();
+    const result = await handler(params, sessionId);
+    const duration = Date.now() - startTime;
+    
+    // Log successful operation
+    sessionManager.logOperation(sessionId, {
+      type: 'tool_execution',
+      tool: toolName,
+      status: 'success',
+      duration,
+      params: Object.keys(params || {})
+    });
+    
+    return result;
+    
+  } catch (error) {
+    // Log failed operation
+    sessionManager.logOperation(sessionId, {
+      type: 'tool_execution',
+      tool: toolName,
+      status: 'error',
+      error: error.message,
+      params: Object.keys(params || {})
+    });
+    
+    if (error instanceof MCPError) {
+      return formatMCPResponse(error.toJSON().error, false);
+    }
+    
+    return formatMCPResponse({
+      code: 'TOOL_ERROR',
+      message: error.message,
+      tool: toolName,
+      timestamp: Date.now()
+    }, false);
+  }
+}
+
+// Register enhanced WordPress MCP Tools
+
+// Session Management Tools
+server.registerTool("wp_session_create", {
+  title: "Create WordPress Session",
+  description: "Create a new session for tracking operations and maintaining context",
+  inputSchema: {
+    type: "object",
+    properties: {
+      session_id: {
+        type: "string",
+        description: "Optional custom session ID"
+      },
+      context: {
+        type: "object",
+        description: "Optional context data for the session"
+      }
+    },
+    additionalProperties: false
+  }
+}, async (params) => {
+  return executeTool('wp_session_create', params, async (params) => {
+    const sessionId = sessionManager.createSession(params.session_id);
+    if (params.context) {
+      const session = sessionManager.getSession(sessionId);
+      session.context = { ...session.context, ...params.context };
+    }
+    
+    return formatMCPResponse({
+      session_id: sessionId,
+      created: true,
+      message: "Session created successfully"
+    });
+  });
+});
+
+server.registerTool("wp_session_status", {
+  title: "Get WordPress Session Status",
+  description: "Get current session information and operation history",
+  inputSchema: {
+    type: "object",
+    properties: {
+      session_id: {
+        type: "string",
+        description: "Session ID to check status for"
+      }
+    },
+    additionalProperties: false
+  }
+}, async (params) => {
+  return executeTool('wp_session_status', params, async (params) => {
+    const sessionId = params.session_id || sessionManager.activeSession;
+    if (!sessionId) {
+      throw new MCPError({
+        code: 'NO_SESSION',
+        message: 'No active session found'
+      });
+    }
+    
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      throw new MCPError({
+        code: 'SESSION_NOT_FOUND',
+        message: `Session ${sessionId} not found`
+      });
+    }
+    
+    return formatMCPResponse({
+      session: {
+        id: session.id,
+        created: new Date(session.created).toISOString(),
+        last_activity: new Date(session.lastActivity).toISOString(),
+        operations_count: session.operations.length,
+        recent_operations: session.operations.slice(-5),
+        context: session.context
+      }
+    });
+  });
+});
+
+// Memory Management Tools
+server.registerTool("wp_memory_store", {
+  title: "Store WordPress Memory",
+  description: "Store data in memory for persistence across operations",
+  inputSchema: {
+    type: "object",
+    properties: {
+      key: {
+        type: "string",
+        description: "Memory key to store data under"
+      },
+      value: {
+        description: "Value to store (any type)"
+      },
+      namespace: {
+        type: "string",
+        description: "Namespace to organize data",
+        default: "wordpress"
+      },
+      ttl: {
+        type: "number",
+        description: "Time-to-live in milliseconds"
+      }
+    },
+    required: ["key", "value"],
+    additionalProperties: false
+  }
+}, async (params) => {
+  return executeTool('wp_memory_store', params, async (params) => {
+    const stored = memoryManager.store(
+      params.key,
+      params.value,
+      params.namespace,
+      params.ttl
+    );
+    
+    return formatMCPResponse({
+      stored: stored,
+      key: params.key,
+      namespace: params.namespace,
+      ttl: params.ttl,
+      message: "Data stored successfully"
+    });
+  });
+});
+
+server.registerTool("wp_memory_retrieve", {
+  title: "Retrieve WordPress Memory",
+  description: "Retrieve stored data from memory",
+  inputSchema: {
+    type: "object",
+    properties: {
+      key: {
+        type: "string",
+        description: "Memory key to retrieve"
+      },
+      namespace: {
+        type: "string",
+        description: "Namespace to search in",
+        default: "wordpress"
+      }
+    },
+    required: ["key"],
+    additionalProperties: false
+  }
+}, async (params) => {
+  return executeTool('wp_memory_retrieve', params, async (params) => {
+    const value = memoryManager.retrieve(params.key, params.namespace);
+    
+    return formatMCPResponse({
+      key: params.key,
+      namespace: params.namespace,
+      value: value,
+      found: value !== null
+    });
+  });
+});
+
+server.registerTool("wp_memory_list", {
+  title: "List WordPress Memory",
+  description: "List all stored data in a namespace",
+  inputSchema: {
+    type: "object",
+    properties: {
+      namespace: {
+        type: "string",
+        description: "Namespace to list data from",
+        default: "wordpress"
+      }
+    },
+    additionalProperties: false
+  }
+}, async (params) => {
+  return executeTool('wp_memory_list', params, async (params) => {
+    const entries = memoryManager.list(params.namespace);
+    
+    return formatMCPResponse({
+      namespace: params.namespace,
+      entries: entries,
+      count: entries.length
+    });
+  });
+});
+
+// Health and System Tools
+server.registerTool("wp_health_check", {
+  title: "WordPress Health Check",
+  description: "Comprehensive health check of WordPress site and MCP server",
+  inputSchema: {
+    type: "object",
+    properties: {
+      detailed: {
+        type: "boolean",
+        description: "Include detailed health metrics",
+        default: false
+      }
+    },
+    additionalProperties: false
+  }
+}, async (params) => {
+  return executeTool('wp_health_check', params, async (params, sessionId) => {
+    const checks = [];
+    
+    try {
+      // Test WordPress API connectivity
+      const startTime = Date.now();
+      const response = await wordpressRequest('/', 'GET', null, sessionId);
+      checks.push({
+        name: 'WordPress API Connectivity',
+        status: 'passed',
+        response_time: Date.now() - startTime,
+        message: 'API is responding'
+      });
+    } catch (error) {
+      checks.push({
+        name: 'WordPress API Connectivity',
+        status: 'failed',
+        error: error.message
+      });
+    }
+    
+    // Check authentication
+    try {
+      await wordpressRequest('/users/me', 'GET', null, sessionId);
+      checks.push({
+        name: 'Authentication',
+        status: 'passed',
+        message: 'Authentication working'
+      });
+    } catch (error) {
+      checks.push({
+        name: 'Authentication',
+        status: 'failed',
+        error: error.message
+      });
+    }
+    
+    // Session status
+    const activeSessionCount = sessionManager.sessions.size;
+    checks.push({
+      name: 'Session Management',
+      status: 'passed',
+      active_sessions: activeSessionCount,
+      current_session: sessionId
+    });
+    
+    // Memory status
+    const memoryEntries = memoryManager.list('wordpress');
+    checks.push({
+      name: 'Memory Management',
+      status: 'passed',
+      stored_entries: memoryEntries.length
+    });
+    
+    const overall = checks.every(check => check.status === 'passed');
+    
+    return formatMCPResponse({
+      overall_status: overall ? 'healthy' : 'unhealthy',
+      checks: checks,
+      timestamp: Date.now(),
+      server_version: '2.0.0'
+    });
+  });
+});
+
+// Get site information
+server.registerTool("wp_get_site_info", {
+  title: "Get WordPress Site Information", 
+  description: "Get WordPress site statistics, version, and health information",
+  inputSchema: {
+    type: "object",
+    properties: {
+      include_health: {
+        type: "boolean",
+        description: "Include health metrics in response",
+        default: false
+      },
+      cache_duration: {
+        type: "number",
+        description: "Cache duration in seconds",
+        default: 300
+      }
+    },
+    additionalProperties: false
+  }
+}, async (params) => {
+  return executeTool('wp_get_site_info', params, async (params, sessionId) => {
+    // Check cache first
+    const cacheKey = `site_info_${WORDPRESS_URL}`;
+    const cached = memoryManager.retrieve(cacheKey, 'cache');
+    if (cached && Date.now() - cached.timestamp < params.cache_duration * 1000) {
+      return formatMCPResponse({
+        ...cached.data,
+        cached: true,
+        cache_age: Math.floor((Date.now() - cached.timestamp) / 1000)
+      });
+    }
+
+    // Get site info from multiple endpoints
+    const [users, posts, plugins] = await Promise.all([
+      wordpressRequest('/users', 'GET', null, sessionId),
+      wordpressRequest('/posts?per_page=1', 'GET', null, sessionId),
+      wordpressRequest('/plugins', 'GET', null, sessionId).catch(() => []) // Plugins endpoint might not be available
+    ]);
+
+    const siteInfo = {
+      site_url: WORDPRESS_URL,
+      total_users: users.length,
+      total_posts: posts.length,
+      total_plugins: plugins.length,
+      wordpress_version: "Available via REST API",
+      server_version: "2.0.0",
+      last_updated: new Date().toISOString(),
+      message: "Site information retrieved successfully"
+    };
+
+    // Store in cache
+    memoryManager.store(cacheKey, {
+      data: siteInfo,
+      timestamp: Date.now()
+    }, 'cache', params.cache_duration * 1000);
+
+    if (params.include_health) {
+      // Include basic health metrics
+      siteInfo.health_metrics = {
+        api_responsive: true,
+        authenticated: true,
+        last_check: Date.now()
+      };
+    }
+
+    return formatMCPResponse(siteInfo);
+  });
+});
+
+// List posts
+server.registerTool("wp_list_posts", {
+  title: "List WordPress Posts",
+  description: "Get posts with filtering options",
+  inputSchema: z.object({
+    per_page: z.number().optional().default(10),
+    page: z.number().optional().default(1),
+    status: z.string().optional().default("publish"),
+    search: z.string().optional(),
+    categories: z.array(z.number()).optional(),
+    tags: z.array(z.number()).optional()
+  })
+}, async (params) => {
+  try {
+    const queryParams = new URLSearchParams();
+    
+    queryParams.append('per_page', params.per_page.toString());
+    queryParams.append('page', params.page.toString());
+    queryParams.append('status', params.status);
+    
+    if (params.search) queryParams.append('search', params.search);
+    if (params.categories) queryParams.append('categories', params.categories.join(','));
+    if (params.tags) queryParams.append('tags', params.tags.join(','));
+
+    const posts = await wordpressRequest(`/posts?${queryParams.toString()}`);
+    
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          posts: posts.map(post => ({
+            id: post.id,
+            title: post.title.rendered,
+            status: post.status,
+            date: post.date,
+            link: post.link,
+            excerpt: post.excerpt.rendered.replace(/<[^>]*>/g, '').trim()
+          })),
+          total: posts.length
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: error.message
+        }, null, 2)
+      }]
+    };
+  }
+});
+
+// Create post
+server.registerTool("wp_create_post", {
+  title: "Create WordPress Post",
+  description: "Create a new WordPress post or page with enhanced tracking and validation",
+  inputSchema: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "Post title (required)",
+        minLength: 1
+      },
+      content: {
+        type: "string",
+        description: "Post content (required)",
+        minLength: 1
+      },
+      status: {
+        type: "string",
+        enum: ["draft", "publish", "private", "pending"],
+        description: "Post status",
+        default: "draft"
+      },
+      excerpt: {
+        type: "string",
+        description: "Post excerpt"
+      },
+      slug: {
+        type: "string",
+        description: "Post slug/URL"
+      },
+      categories: {
+        type: "array",
+        items: { type: "number" },
+        description: "Category IDs",
+        default: []
+      },
+      tags: {
+        type: "array",
+        items: { type: "number" },
+        description: "Tag IDs",
+        default: []
+      },
+      use_gutenberg: {
+        type: "boolean",
+        description: "Use Gutenberg block format",
+        default: WORDPRESS_USE_GUTENBERG
+      },
+      store_in_memory: {
+        type: "boolean",
+        description: "Store post data in memory for tracking",
+        default: true
+      }
+    },
+    required: ["title", "content"],
+    additionalProperties: false
+  }
+}, async (params) => {
+  return executeTool('wp_create_post', params, async (params, sessionId) => {
+    // Convert content to Gutenberg format if requested
+    let content = params.content;
+    const useGutenberg = params.use_gutenberg || params.gutenberg || WORDPRESS_USE_GUTENBERG;
+    
+    if (useGutenberg) {
+      try {
+        content = GutenbergConverter.htmlToGutenberg(params.content);
+      } catch (gutenbergError) {
+        // If Gutenberg conversion fails, log warning but continue with original content
+        sessionManager.logOperation(sessionId, {
+          type: 'warning',
+          message: 'Gutenberg conversion failed, using original content',
+          error: gutenbergError.message
+        });
+      }
+    }
+    
+    const postData = {
+      title: params.title,
+      content: content,
+      status: params.status,
+      categories: params.categories,
+      tags: params.tags
+    };
+
+    // Add optional fields
+    if (params.excerpt) postData.excerpt = params.excerpt;
+    if (params.slug) postData.slug = params.slug;
+    if (params.meta) postData.meta = params.meta;
+    if (params.featured_media) postData.featured_media = params.featured_media;
+    if (params.author) postData.author = params.author;
+    if (params.comment_status) postData.comment_status = params.comment_status;
+    if (params.ping_status) postData.ping_status = params.ping_status;
+
+    const post = await wordpressRequest('/posts', 'POST', postData, sessionId);
+    
+    const result = {
+      post_id: post.id,
+      post_url: post.link,
+      edit_url: `${WORDPRESS_URL.replace(/\/$/, '')}/wp-admin/post.php?post=${post.id}&action=edit`,
+      title: post.title.rendered,
+      status: post.status,
+      date: post.date,
+      modified: post.modified,
+      gutenberg_used: useGutenberg,
+      categories: post.categories,
+      tags: post.tags,
+      message: `Post created successfully with ${useGutenberg ? 'Gutenberg' : 'Classic'} editor format`
+    };
+
+    // Store post reference in memory if requested
+    if (params.store_in_memory) {
+      memoryManager.store(`created_post_${post.id}`, {
+        ...result,
+        original_params: params,
+        created_at: Date.now()
+      }, 'posts', 3600000); // 1 hour TTL
+    }
+    
+    return formatMCPResponse(result);
+  });
+});
+
+// Update post
+server.registerTool("wp_update_post", {
+  title: "Update WordPress Post",
+  description: "Update an existing WordPress post",
+  inputSchema: z.object({
+    id: z.number(),
+    title: z.string().optional(),
+    content: z.string().optional(),
+    status: z.string().optional(),
+    excerpt: z.string().optional(),
+    slug: z.string().optional(),
+    categories: z.array(z.number()).optional(),
+    tags: z.array(z.number()).optional()
+  })
+}, async (params) => {
+  try {
+    const { id, ...updateData } = params;
+    const filteredData = Object.fromEntries(
+      Object.entries(updateData).filter(([_, value]) => value !== undefined)
+    );
+
+    const post = await wordpressRequest(`/posts/${id}`, 'POST', filteredData);
+    
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          post_id: post.id,
+          post_url: post.link,
+          message: "Post updated successfully"
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: error.message
+        }, null, 2)
+      }]
+    };
+  }
+});
+
+// Delete post
+server.registerTool("wp_delete_post", {
+  title: "Delete WordPress Post",
+  description: "Delete a WordPress post (move to trash)",
+  inputSchema: z.object({
+    id: z.number()
+  })
+}, async (params) => {
+  try {
+    const post = await wordpressRequest(`/posts/${params.id}`, 'DELETE');
+    
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          post_id: post.id,
+          message: "Post deleted successfully"
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: error.message
+        }, null, 2)
+      }]
+    };
+  }
+});
+
+// List users
+server.registerTool("wp_list_users", {
+  title: "List WordPress Users",
+  description: "Get WordPress user accounts and roles",
+  inputSchema: z.object({
+    per_page: z.number().optional().default(100),
+    role: z.string().optional()
+  })
+}, async (params) => {
+  try {
+    const queryParams = new URLSearchParams();
+    queryParams.append('per_page', params.per_page.toString());
+    if (params.role) queryParams.append('role', params.role);
+
+    const users = await wordpressRequest(`/users?${queryParams.toString()}`);
+    
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          users: users.map(user => ({
+            id: user.id,
+            username: user.username,
+            name: user.name,
+            email: user.email,
+            roles: user.roles,
+            registered_date: user.registered_date
+          })),
+          total: users.length
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: error.message
+        }, null, 2)
+      }]
+    };
+  }
+});
+
+// Create user
+server.registerTool("wp_create_user", {
+  title: "Create WordPress User",
+  description: "Add a new WordPress user account",
+  inputSchema: z.object({
+    username: z.string(),
+    email: z.string().email(),
+    password: z.string(),
+    roles: z.array(z.string()).optional().default(["subscriber"])
+  })
+}, async (params) => {
+  try {
+    const userData = {
+      username: params.username,
+      email: params.email,
+      password: params.password,
+      roles: params.roles
+    };
+
+    const user = await wordpressRequest('/users', 'POST', userData);
+    
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          user_id: user.id,
+          username: user.username,
+          email: user.email,
+          roles: user.roles,
+          message: "User created successfully"
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: error.message
+        }, null, 2)
+      }]
+    };
+  }
+});
+
+// Update user
+server.registerTool("wp_update_user", {
+  title: "Update WordPress User",
+  description: "Modify WordPress user settings",
+  inputSchema: z.object({
+    id: z.number(),
+    email: z.string().email().optional(),
+    roles: z.array(z.string()).optional(),
+    password: z.string().optional()
+  })
+}, async (params) => {
+  try {
+    const { id, ...updateData } = params;
+    const filteredData = Object.fromEntries(
+      Object.entries(updateData).filter(([_, value]) => value !== undefined)
+    );
+
+    const user = await wordpressRequest(`/users/${id}`, 'POST', filteredData);
+    
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          user_id: user.id,
+          username: user.username,
+          email: user.email,
+          roles: user.roles,
+          message: "User updated successfully"
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: error.message
+        }, null, 2)
+      }]
+    };
+  }
+});
+
+// List plugins (if available)
+server.registerTool("wp_list_plugins", {
+  title: "List WordPress Plugins",
+  description: "Get installed WordPress plugins",
+  inputSchema: z.object({})
+}, async () => {
+  try {
+    const plugins = await wordpressRequest('/plugins');
+    
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          plugins: plugins.map(plugin => ({
+            name: plugin.name,
+            plugin: plugin.plugin,
+            status: plugin.status,
+            version: plugin.version
+          })),
+          total: plugins.length
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: error.message,
+          note: "Plugins endpoint may not be available on all WordPress installations"
+        }, null, 2)
+      }]
+    };
+  }
+});
+
+// Get media
+server.registerTool("wp_get_media", {
+  title: "Get WordPress Media",
+  description: "Access WordPress media library",
+  inputSchema: z.object({
+    per_page: z.number().optional().default(10),
+    media_type: z.string().optional()
+  })
+}, async (params) => {
+  try {
+    const queryParams = new URLSearchParams();
+    queryParams.append('per_page', params.per_page.toString());
+    if (params.media_type) queryParams.append('media_type', params.media_type);
+
+    const media = await wordpressRequest(`/media?${queryParams.toString()}`);
+    
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: true,
+          media: media.map(item => ({
+            id: item.id,
+            title: item.title.rendered,
+            source_url: item.source_url,
+            media_type: item.media_type,
+            mime_type: item.mime_type,
+            date: item.date
+          })),
+          total: media.length
+        }, null, 2)
+      }]
+    };
+  } catch (error) {
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: error.message
+        }, null, 2)
+      }]
+    };
+  }
+});
+
+// Batch operations tool
+server.registerTool("wp_batch_publish", {
+  title: "WordPress Batch Publish",
+  description: "Publish multiple posts from markdown files with enhanced tracking",
+  inputSchema: z.object({
+    files: z.array(z.object({
+      path: z.string(),
+      title: z.string().optional(),
+      status: z.enum(["draft", "publish", "private", "pending"]).optional().default("draft"),
+      categories: z.array(z.number()).optional().default([]),
+      tags: z.array(z.number()).optional().default([])
+    })),
+    use_gutenberg: z.boolean().optional().default(WORDPRESS_USE_GUTENBERG),
+    dry_run: z.boolean().optional().default(false)
+  })
+}, async (params) => {
+  return executeTool('wp_batch_publish', params, async (params, sessionId) => {
+    const results = [];
+    const errors = [];
+    
+    for (const file of params.files) {
+      try {
+        if (params.dry_run) {
+          results.push({
+            file: file.path,
+            status: 'dry_run',
+            message: 'Would process this file'
+          });
+          continue;
+        }
+        
+        // Read file content (this would need file system access in real implementation)
+        // For now, simulate with the provided data
+        const postData = {
+          title: file.title || `Post from ${file.path}`,
+          content: `Content from ${file.path}`, // Would read actual content
+          status: file.status,
+          categories: file.categories,
+          tags: file.tags,
+          use_gutenberg: params.use_gutenberg,
+          store_in_memory: true
+        };
+        
+        // Use the existing create_post functionality
+        const post = await wordpressRequest('/posts', 'POST', postData, sessionId);
+        
+        results.push({
+          file: file.path,
+          post_id: post.id,
+          post_url: post.link,
+          status: 'success',
+          message: 'Published successfully'
+        });
+        
+      } catch (error) {
+        errors.push({
+          file: file.path,
+          error: error.message,
+          status: 'error'
+        });
+      }
+    }
+    
+    // Store batch operation result in memory
+    const batchId = `batch_${Date.now()}`;
+    memoryManager.store(batchId, {
+      operation: 'batch_publish',
+      results,
+      errors,
+      total_files: params.files.length,
+      successful: results.filter(r => r.status === 'success').length,
+      failed: errors.length,
+      completed_at: Date.now()
+    }, 'batch_operations', 3600000); // 1 hour TTL
+    
+    return formatMCPResponse({
+      batch_id: batchId,
+      summary: {
+        total_files: params.files.length,
+        successful: results.filter(r => r.status === 'success').length,
+        failed: errors.length,
+        dry_run: params.dry_run
+      },
+      results,
+      errors
+    });
+  });
+});
+
+// Resource cleanup and server lifecycle management
+function setupCleanupHandlers() {
+  // Cleanup sessions every 10 minutes
+  setInterval(() => {
+    sessionManager.cleanup();
+  }, 10 * 60 * 1000);
+  
+  // Handle graceful shutdown
+  const cleanup = () => {
+    console.error("WordPress MCP Server shutting down...");
+    // Could add more cleanup logic here
+    process.exit(0);
+  };
+  
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+  process.on('SIGHUP', cleanup);
+}
+
+// Start the enhanced MCP server
+async function main() {
+  try {
+    // Initialize session manager
+    sessionManager.createSession('default_session');
+    
+    // Setup cleanup handlers
+    setupCleanupHandlers();
+    
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    
+    console.error("Enhanced WordPress MCP Server v2.0.0 running...");
+    console.error(`Connected to WordPress site: ${WORDPRESS_URL}`);
+    console.error(`Active session: ${sessionManager.activeSession}`);
+    console.error("Available tools: session management, memory management, health checks, WordPress operations, batch publishing");
+    
+  } catch (error) {
+    console.error("Failed to start server:", error.message);
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error("Server startup error:", error);
+  process.exit(1);
+});