myaidev-method 0.3.2 → 0.3.4

package/dist/mcp/wordpress-server.js

@@ -4,6 +4,8 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 import dotenv from "dotenv";
+import fs from "node:fs";
+import path from "node:path";
 import { GutenbergConverter } from "./gutenberg-converter.js";
 
 // Load environment variables
@@ -13,1260 +15,1635 @@ dotenv.config();
 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';
+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);
+	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);
-      }
-    }
-  }
+	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;
-  }
+	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"
+	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
-    });
-  }
+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,
+		});
+	}
+}
+
+// Helper for uploading files to WordPress media library via multipart/form-data
+async function wordpressUploadRequest(
+	filePath,
+	metadata = {},
+	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 fileBuffer = fs.readFileSync(filePath);
+	const fileName = path.basename(filePath);
+
+	const formData = new FormData();
+	formData.append("file", new Blob([fileBuffer]), fileName);
+	if (metadata.title) formData.append("title", metadata.title);
+	if (metadata.alt_text) formData.append("alt_text", metadata.alt_text);
+	if (metadata.caption) formData.append("caption", metadata.caption);
+	if (metadata.description)
+		formData.append("description", metadata.description);
+
+	const startTime = Date.now();
+
+	try {
+		const response = await fetch(`${baseUrl}${apiPath}/media`, {
+			method: "POST",
+			headers: {
+				Authorization: `Basic ${auth}`,
+				"User-Agent": "WordPress-MCP-Server/2.0.0",
+			},
+			body: formData,
+			timeout: 60000,
+		});
+
+		if (sessionId) {
+			sessionManager.logOperation(sessionId, {
+				type: "media_upload",
+				file: fileName,
+				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: `Media upload failed: ${response.status} - ${response.statusText}`,
+				details: errorBody,
+				endpoint: "/media",
+				method: "POST",
+			});
+		}
+
+		return await response.json();
+	} catch (error) {
+		if (sessionId) {
+			sessionManager.logOperation(sessionId, {
+				type: "media_upload_error",
+				file: fileName,
+				error: error.message,
+				duration: Date.now() - startTime,
+			});
+		}
+		if (error instanceof MCPError) throw error;
+		throw new MCPError({
+			code: "UPLOAD_ERROR",
+			message: `Media upload error: ${error.message}`,
+			details: error,
+			endpoint: "/media",
+			method: "POST",
+		});
+	}
+}
+
+// Upload local assets referenced in content and replace paths with WordPress URLs
+async function uploadAndReplaceAssets(content, basePath, sessionId = null) {
+	// Match both HTML <img> tags and markdown ![alt](path) image syntax
+	const patterns = [
+		/<img\s+[^>]*src=["'](assets\/[^"']+)["'][^>]*>/gi,
+		/!\[[^\]]*\]\((assets\/[^)]+)\)/gi,
+	];
+	const uploadedAssets = [];
+	let match;
+	const replacements = new Map();
+
+	for (const imgRegex of patterns) {
+		while ((match = imgRegex.exec(content)) !== null) {
+			const relativePath = match[1];
+			if (replacements.has(relativePath)) continue;
+
+			const absolutePath = path.resolve(basePath, relativePath);
+			if (!fs.existsSync(absolutePath)) {
+				uploadedAssets.push({
+					file: relativePath,
+					status: "skipped",
+					reason: "file not found",
+				});
+				continue;
+			}
+
+			try {
+				const fileName = path.basename(
+					relativePath,
+					path.extname(relativePath),
+				);
+				const title = fileName.replace(/[-_]/g, " ");
+				const media = await wordpressUploadRequest(
+					absolutePath,
+					{ title },
+					sessionId,
+				);
+				replacements.set(relativePath, media.source_url);
+				uploadedAssets.push({
+					file: relativePath,
+					status: "uploaded",
+					media_id: media.id,
+					source_url: media.source_url,
+				});
+			} catch (error) {
+				uploadedAssets.push({
+					file: relativePath,
+					status: "error",
+					error: error.message,
+				});
+			}
+		}
+	}
+
+	let updatedContent = content;
+	for (const [localPath, wpUrl] of replacements) {
+		updatedContent = updatedContent.replaceAll(localPath, wpUrl);
+	}
+
+	return { content: updatedContent, uploadedAssets };
 }
 
 // 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()
-      }
-    };
-  }
+	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)
-    }]
-  };
+	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);
-  }
+	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
-      }
-    });
-  });
-});
+server.registerTool(
+	"wp_session_create",
+	{
+		title: "Create WordPress Session",
+		description:
+			"Create a new session for tracking operations and maintaining context",
+		inputSchema: z.object({
+			session_id: z.string().optional().describe("Optional custom session ID"),
+			context: z
+				.object({})
+				.passthrough()
+				.optional()
+				.describe("Optional context data for the session"),
+		}),
+	},
+	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: z.object({
+			session_id: z
+				.string()
+				.optional()
+				.describe("Session ID to check status for"),
+		}),
+	},
+	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
-    });
-  });
-});
+server.registerTool(
+	"wp_memory_store",
+	{
+		title: "Store WordPress Memory",
+		description: "Store data in memory for persistence across operations",
+		inputSchema: z.object({
+			key: z.string().describe("Memory key to store data under"),
+			value: z.any().describe("Value to store (any type)"),
+			namespace: z
+				.string()
+				.optional()
+				.default("wordpress")
+				.describe("Namespace to organize data"),
+			ttl: z.number().optional().describe("Time-to-live in milliseconds"),
+		}),
+	},
+	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: z.object({
+			key: z.string().describe("Memory key to retrieve"),
+			namespace: z
+				.string()
+				.optional()
+				.default("wordpress")
+				.describe("Namespace to search in"),
+		}),
+	},
+	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: z.object({
+			namespace: z
+				.string()
+				.optional()
+				.default("wordpress")
+				.describe("Namespace to list data from"),
+		}),
+	},
+	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'
-    });
-  });
-});
+server.registerTool(
+	"wp_health_check",
+	{
+		title: "WordPress Health Check",
+		description: "Comprehensive health check of WordPress site and MCP server",
+		inputSchema: z.object({
+			detailed: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe("Include detailed health metrics"),
+		}),
+	},
+	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);
-  });
-});
+server.registerTool(
+	"wp_get_site_info",
+	{
+		title: "Get WordPress Site Information",
+		description:
+			"Get WordPress site statistics, version, and health information",
+		inputSchema: z.object({
+			include_health: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe("Include health metrics in response"),
+			cache_duration: z
+				.number()
+				.optional()
+				.default(300)
+				.describe("Cache duration in seconds"),
+		}),
+	},
+	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)
-      }]
-    };
-  }
-});
+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: false
-      },
-      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);
-  });
-});
+server.registerTool(
+	"wp_create_post",
+	{
+		title: "Create WordPress Post",
+		description:
+			"Create a new WordPress post or page with enhanced tracking and validation",
+		inputSchema: z.object({
+			title: z.string().min(1).describe("Post title (required)"),
+			content: z.string().min(1).describe("Post content (required)"),
+			status: z
+				.enum(["draft", "publish", "private", "pending"])
+				.optional()
+				.default("draft")
+				.describe("Post status"),
+			excerpt: z.string().optional().describe("Post excerpt"),
+			slug: z.string().optional().describe("Post slug/URL"),
+			categories: z
+				.array(z.number())
+				.optional()
+				.default([])
+				.describe("Category IDs"),
+			tags: z.array(z.number()).optional().default([]).describe("Tag IDs"),
+			use_gutenberg: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe("Use Gutenberg block format"),
+			store_in_memory: z
+				.boolean()
+				.optional()
+				.default(true)
+				.describe("Store post data in memory for tracking"),
+			content_base_path: z
+				.string()
+				.optional()
+				.describe(
+					"Base directory path to resolve relative asset references (e.g. assets/image.svg) in content. When provided, local assets are uploaded to the media library and URLs are replaced.",
+				),
+		}),
+	},
+	async (params) => {
+		return executeTool("wp_create_post", params, async (params, sessionId) => {
+			// Upload local assets if content_base_path is provided
+			let content = params.content;
+			let uploadedAssets = [];
+			if (params.content_base_path) {
+				const assetResult = await uploadAndReplaceAssets(
+					content,
+					params.content_base_path,
+					sessionId,
+				);
+				content = assetResult.content;
+				uploadedAssets = assetResult.uploadedAssets;
+			}
+
+			// Convert content to Gutenberg format if requested
+			const useGutenberg =
+				params.use_gutenberg || params.gutenberg || WORDPRESS_USE_GUTENBERG;
+
+			if (useGutenberg) {
+				try {
+					content = GutenbergConverter.toGutenberg(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,
+				uploaded_assets: uploadedAssets.length > 0 ? uploadedAssets : undefined,
+				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)
-      }]
-    };
-  }
-});
+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)
-      }]
-    };
-  }
-});
+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)
-      }]
-    };
-  }
-});
+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)
-      }]
-    };
-  }
-});
+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)
-      }]
-    };
-  }
-});
+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)
-      }]
-    };
-  }
-});
+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)
-      }]
-    };
-  }
-});
+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;
-        }
-
-        const postData = {
-          title: file.title || `Post from ${file.path}`,
-          content: `Content from ${file.path}`,
-          status: file.status,
-          categories: file.categories,
-          tags: file.tags,
-          use_gutenberg: params.use_gutenberg,
-          store_in_memory: true
-        };
-
-        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
-    });
-  });
-});
+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),
+			upload_assets: z
+				.boolean()
+				.optional()
+				.default(true)
+				.describe(
+					"Upload local assets referenced in content (e.g. assets/image.svg) to the media library",
+				),
+			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 actual file content
+						let fileContent;
+						try {
+							fileContent = fs.readFileSync(file.path, "utf-8");
+						} catch {
+							errors.push({
+								file: file.path,
+								error: `Could not read file: ${file.path}`,
+								status: "error",
+							});
+							continue;
+						}
+
+						// Upload local assets if enabled
+						let uploadedAssets = [];
+						if (params.upload_assets) {
+							const basePath = path.dirname(file.path);
+							const assetResult = await uploadAndReplaceAssets(
+								fileContent,
+								basePath,
+								sessionId,
+							);
+							fileContent = assetResult.content;
+							uploadedAssets = assetResult.uploadedAssets;
+						}
+
+						// Convert content to Gutenberg format if requested
+						const useGutenberg =
+							params.use_gutenberg || WORDPRESS_USE_GUTENBERG;
+						if (useGutenberg) {
+							try {
+								fileContent = GutenbergConverter.toGutenberg(fileContent);
+							} catch (gutenbergError) {
+								sessionManager.logOperation(sessionId, {
+									type: "warning",
+									message: `Gutenberg conversion failed for ${file.path}, using original content`,
+									error: gutenbergError.message,
+								});
+							}
+						}
+
+						const postData = {
+							title: file.title || `Post from ${file.path}`,
+							content: fileContent,
+							status: file.status,
+							categories: file.categories,
+							tags: file.tags,
+							store_in_memory: true,
+						};
+
+						const post = await wordpressRequest(
+							"/posts",
+							"POST",
+							postData,
+							sessionId,
+						);
+
+						results.push({
+							file: file.path,
+							post_id: post.id,
+							post_url: post.link,
+							status: "success",
+							uploaded_assets:
+								uploadedAssets.length > 0 ? uploadedAssets : undefined,
+							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...");
-    process.exit(0);
-  };
-
-  process.on('SIGINT', cleanup);
-  process.on('SIGTERM', cleanup);
-  process.on('SIGHUP', cleanup);
+	// Cleanup sessions every 10 minutes
+	setInterval(
+		() => {
+			sessionManager.cleanup();
+		},
+		10 * 60 * 1000,
+	);
+
+	// Handle graceful shutdown
+	const cleanup = () => {
+		console.error("WordPress MCP Server shutting down...");
+		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);
-  }
+	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);
+	console.error("Server startup error:", error);
+	process.exit(1);
 });