myaidev-method 0.2.19 → 0.2.23

package/.claude/mcp/wordpress-server.js

@@ -1,1277 +0,0 @@
-#!/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);
-});