mcp-wordpress 1.2.2 → 1.3.0

package/src/client/api.ts

@@ -3,10 +3,10 @@
  * Handles all REST API communication with WordPress
  */
 
-import fetch from 'node-fetch';
-import FormData from 'form-data';
-import * as fs from 'fs';
-import * as path from 'path';
+import fetch from "node-fetch";
+import FormData from "form-data";
+import * as fs from "fs";
+import * as path from "path";
 import type {
   IWordPressClient,
   WordPressClientConfig,
@@ -14,13 +14,13 @@ import type {
   AuthMethod,
   HTTPMethod,
   RequestOptions,
-  ClientStats
-} from '../types/client.js';
+  ClientStats,
+} from "../types/client.js";
 import {
   WordPressAPIError,
   AuthenticationError,
-  RateLimitError
-} from '../types/client.js';
+  RateLimitError,
+} from "../types/client.js";
 import type {
   WordPressPost,
   WordPressPage,
@@ -48,9 +48,9 @@ import type {
   CreateTagRequest,
   UpdateTagRequest,
   UploadMediaRequest,
-  UpdateMediaRequest
-} from '../types/wordpress.js';
-import { debug, logError, startTimer } from '../utils/debug.js';
+  UpdateMediaRequest,
+} from "../types/wordpress.js";
+import { debug, logError, startTimer } from "../utils/debug.js";
 
 export class WordPressClient implements IWordPressClient {
   private baseUrl: string;
@@ -66,18 +66,18 @@ export class WordPressClient implements IWordPressClient {
   private _stats: ClientStats;
 
   constructor(options: Partial<WordPressClientConfig> = {}) {
-    this.baseUrl = options.baseUrl || process.env.WORDPRESS_SITE_URL || '';
-    this.apiUrl = '';
+    this.baseUrl = options.baseUrl || process.env.WORDPRESS_SITE_URL || "";
+    this.apiUrl = "";
     this.timeout =
-      options.timeout || parseInt(process.env.WORDPRESS_TIMEOUT || '30000');
+      options.timeout || parseInt(process.env.WORDPRESS_TIMEOUT || "30000");
     this.maxRetries =
-      options.maxRetries || parseInt(process.env.WORDPRESS_MAX_RETRIES || '3');
+      options.maxRetries || parseInt(process.env.WORDPRESS_MAX_RETRIES || "3");
 
     // Authentication configuration
     this.auth = options.auth || this.getAuthFromEnv();
 
     // Rate limiting
-    this.requestInterval = 60000 / parseInt(process.env.RATE_LIMIT || '60');
+    this.requestInterval = 60000 / parseInt(process.env.RATE_LIMIT || "60");
 
     // Initialize stats
     this._stats = {
@@ -86,7 +86,7 @@ export class WordPressClient implements IWordPressClient {
       failedRequests: 0,
       averageResponseTime: 0,
       rateLimitHits: 0,
-      authFailures: 0
+      authFailures: 0,
     };
 
     // Validate configuration
@@ -98,7 +98,7 @@ export class WordPressClient implements IWordPressClient {
       baseUrl: this.baseUrl,
       auth: this.auth,
       timeout: this.timeout,
-      maxRetries: this.maxRetries
+      maxRetries: this.maxRetries,
     };
   }
 
@@ -115,23 +115,23 @@ export class WordPressClient implements IWordPressClient {
 
     // Use explicit auth method if set
     if (
-      authMethod === 'app-password' &&
+      authMethod === "app-password" &&
       process.env.WORDPRESS_USERNAME &&
       process.env.WORDPRESS_APP_PASSWORD
     ) {
       return {
-        method: 'app-password',
+        method: "app-password",
         username: process.env.WORDPRESS_USERNAME,
-        appPassword: process.env.WORDPRESS_APP_PASSWORD
+        appPassword: process.env.WORDPRESS_APP_PASSWORD,
       };
     }
 
     // Try Application Password first (fallback)
     if (process.env.WORDPRESS_USERNAME && process.env.WORDPRESS_APP_PASSWORD) {
       return {
-        method: 'app-password',
+        method: "app-password",
         username: process.env.WORDPRESS_USERNAME,
-        appPassword: process.env.WORDPRESS_APP_PASSWORD
+        appPassword: process.env.WORDPRESS_APP_PASSWORD,
       };
     }
 
@@ -142,49 +142,49 @@ export class WordPressClient implements IWordPressClient {
       process.env.WORDPRESS_PASSWORD
     ) {
       return {
-        method: 'jwt',
+        method: "jwt",
         secret: process.env.WORDPRESS_JWT_SECRET,
         username: process.env.WORDPRESS_USERNAME,
-        password: process.env.WORDPRESS_PASSWORD
+        password: process.env.WORDPRESS_PASSWORD,
       };
     }
 
     // Try API Key
     if (process.env.WORDPRESS_API_KEY) {
       return {
-        method: 'api-key',
-        apiKey: process.env.WORDPRESS_API_KEY
+        method: "api-key",
+        apiKey: process.env.WORDPRESS_API_KEY,
       };
     }
 
     // Try Cookie
     if (process.env.WORDPRESS_COOKIE_NONCE) {
       return {
-        method: 'cookie',
-        nonce: process.env.WORDPRESS_COOKIE_NONCE
+        method: "cookie",
+        nonce: process.env.WORDPRESS_COOKIE_NONCE,
       };
     }
 
     // Default to basic authentication
     return {
-      method: 'basic',
-      username: process.env.WORDPRESS_USERNAME || '',
+      method: "basic",
+      username: process.env.WORDPRESS_USERNAME || "",
       password:
         process.env.WORDPRESS_PASSWORD ||
         process.env.WORDPRESS_APP_PASSWORD ||
-        ''
+        "",
     };
   }
 
   private validateConfig(): void {
     if (!this.baseUrl) {
       throw new Error(
-        'WordPress configuration is incomplete: baseUrl is required'
+        "WordPress configuration is incomplete: baseUrl is required",
       );
     }
 
     // Ensure URL doesn't end with slash and add API path
-    this.baseUrl = this.baseUrl.replace(/\/$/, '');
+    this.baseUrl = this.baseUrl.replace(/\/$/, "");
     this.apiUrl = `${this.baseUrl}/wp-json/wp/v2`;
 
     debug.log(`WordPress API Client initialized for: ${this.apiUrl}`);
@@ -197,7 +197,7 @@ export class WordPressClient implements IWordPressClient {
   async disconnect(): Promise<void> {
     this.authenticated = false;
     this.jwtToken = null;
-    debug.log('WordPress client disconnected');
+    debug.log("WordPress client disconnected");
   }
 
   /**
@@ -207,38 +207,38 @@ export class WordPressClient implements IWordPressClient {
     const method = this.auth.method?.toLowerCase() as AuthMethod;
 
     switch (method) {
-    case 'app-password':
+    case "app-password":
       if (this.auth.username && this.auth.appPassword) {
         const credentials = Buffer.from(
-          `${this.auth.username}:${this.auth.appPassword}`
-        ).toString('base64');
-        headers['Authorization'] = `Basic ${credentials}`;
+          `${this.auth.username}:${this.auth.appPassword}`,
+        ).toString("base64");
+        headers["Authorization"] = `Basic ${credentials}`;
       }
       break;
-    case 'basic':
+    case "basic":
       if (this.auth.username && this.auth.password) {
         const credentials = Buffer.from(
-          `${this.auth.username}:${this.auth.password}`
-        ).toString('base64');
-        headers['Authorization'] = `Basic ${credentials}`;
+          `${this.auth.username}:${this.auth.password}`,
+        ).toString("base64");
+        headers["Authorization"] = `Basic ${credentials}`;
       }
       break;
 
-    case 'jwt':
+    case "jwt":
       if (this.jwtToken) {
-        headers['Authorization'] = `Bearer ${this.jwtToken}`;
+        headers["Authorization"] = `Bearer ${this.jwtToken}`;
       }
       break;
 
-    case 'api-key':
+    case "api-key":
       if (this.auth.apiKey) {
-        headers['X-API-Key'] = this.auth.apiKey;
+        headers["X-API-Key"] = this.auth.apiKey;
       }
       break;
 
-    case 'cookie':
+    case "cookie":
       if (this.auth.nonce) {
-        headers['X-WP-Nonce'] = this.auth.nonce;
+        headers["X-WP-Nonce"] = this.auth.nonce;
       }
       break;
     }
@@ -271,14 +271,14 @@ export class WordPressClient implements IWordPressClient {
 
     try {
       switch (method) {
-      case 'app-password':
-      case 'basic':
+      case "app-password":
+      case "basic":
         return await this.authenticateWithBasic();
-      case 'jwt':
+      case "jwt":
         return await this.authenticateWithJWT();
-      case 'cookie':
+      case "cookie":
         return await this.authenticateWithCookie();
-      case 'api-key':
+      case "api-key":
         // API key auth doesn't require separate authentication step
         this.authenticated = true;
         return true;
@@ -298,31 +298,31 @@ export class WordPressClient implements IWordPressClient {
   private async authenticateWithBasic(): Promise<boolean> {
     const hasCredentials =
       this.auth.username &&
-      (this.auth.method === 'app-password'
+      (this.auth.method === "app-password"
         ? this.auth.appPassword
         : this.auth.password);
 
     if (!hasCredentials) {
       const methodName =
-        this.auth.method === 'app-password' ? 'Application Password' : 'Basic';
+        this.auth.method === "app-password" ? "Application Password" : "Basic";
       const passwordField =
-        this.auth.method === 'app-password' ? 'app password' : 'password';
+        this.auth.method === "app-password" ? "app password" : "password";
       throw new AuthenticationError(
         `Username and ${passwordField} are required for ${methodName} authentication`,
-        this.auth.method
+        this.auth.method,
       );
     }
 
     try {
       // Test authentication by getting current user
-      await this.request<WordPressUser>('GET', 'users/me');
+      await this.request<WordPressUser>("GET", "users/me");
       this.authenticated = true;
-      debug.log('Basic/Application Password authentication successful');
+      debug.log("Basic/Application Password authentication successful");
       return true;
     } catch (error) {
       throw new AuthenticationError(
         `Basic authentication failed: ${(error as Error).message}`,
-        this.auth.method
+        this.auth.method,
       );
     }
   }
@@ -333,8 +333,8 @@ export class WordPressClient implements IWordPressClient {
   private async authenticateWithJWT(): Promise<boolean> {
     if (!this.auth.secret || !this.auth.username || !this.auth.password) {
       throw new AuthenticationError(
-        'JWT secret, username, and password are required for JWT authentication',
-        this.auth.method
+        "JWT secret, username, and password are required for JWT authentication",
+        this.auth.method,
       );
     }
 
@@ -342,15 +342,15 @@ export class WordPressClient implements IWordPressClient {
       const response = await fetch(
         `${this.baseUrl}/wp-json/jwt-auth/v1/token`,
         {
-          method: 'POST',
+          method: "POST",
           headers: {
-            'Content-Type': 'application/json'
+            "Content-Type": "application/json",
           },
           body: JSON.stringify({
             username: this.auth.username,
-            password: this.auth.password
-          })
-        }
+            password: this.auth.password,
+          }),
+        },
       );
 
       if (!response.ok) {
@@ -360,12 +360,12 @@ export class WordPressClient implements IWordPressClient {
       const data = (await response.json()) as { token: string };
       this.jwtToken = data.token;
       this.authenticated = true;
-      debug.log('JWT authentication successful');
+      debug.log("JWT authentication successful");
       return true;
     } catch (error) {
       throw new AuthenticationError(
         `JWT authentication failed: ${(error as Error).message}`,
-        this.auth.method
+        this.auth.method,
       );
     }
   }
@@ -376,12 +376,12 @@ export class WordPressClient implements IWordPressClient {
   private async authenticateWithCookie(): Promise<boolean> {
     if (!this.auth.nonce) {
       throw new AuthenticationError(
-        'Nonce is required for cookie authentication',
-        this.auth.method
+        "Nonce is required for cookie authentication",
+        this.auth.method,
       );
     }
     this.authenticated = true;
-    debug.log('Cookie authentication configured');
+    debug.log("Cookie authentication configured");
     return true;
   }
 
@@ -392,21 +392,21 @@ export class WordPressClient implements IWordPressClient {
     method: HTTPMethod,
     endpoint: string,
     data: any = null,
-    options: RequestOptions = {}
+    options: RequestOptions = {},
   ): Promise<T> {
     const timer = startTimer();
     this._stats.totalRequests++;
 
     // Handle endpoint properly - remove leading slash if present to avoid double slashes
-    const cleanEndpoint = endpoint.replace(/^\/+/, '');
-    const url = endpoint.startsWith('http')
+    const cleanEndpoint = endpoint.replace(/^\/+/, "");
+    const url = endpoint.startsWith("http")
       ? endpoint
       : `${this.apiUrl}/${cleanEndpoint}`;
 
     const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      'User-Agent': 'MCP-WordPress/1.0.0',
-      ...options.headers
+      "Content-Type": "application/json",
+      "User-Agent": "MCP-WordPress/1.0.0",
+      ...options.headers,
     };
 
     // Add authentication headers
@@ -418,25 +418,25 @@ export class WordPressClient implements IWordPressClient {
     const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
 
     const fetchOptions: any = {
+      ...options, // Spread options first
       method,
-      headers,
+      headers, // Headers come after to ensure auth headers aren't overridden
       signal: controller.signal,
-      ...options
     };
 
     // Add body for POST/PUT/PATCH requests
-    if (data && ['POST', 'PUT', 'PATCH'].includes(method)) {
+    if (data && ["POST", "PUT", "PATCH"].includes(method)) {
       if (
         data instanceof FormData ||
-        (data && typeof data.append === 'function')
+        (data && typeof data.append === "function")
       ) {
         // For FormData, don't set Content-Type (let fetch set it with boundary)
-        delete headers['Content-Type'];
+        delete headers["Content-Type"];
         fetchOptions.body = data;
       } else if (Buffer.isBuffer(data)) {
         // For Buffer data (manual multipart), keep Content-Type from headers
         fetchOptions.body = data;
-      } else if (typeof data === 'string') {
+      } else if (typeof data === "string") {
         fetchOptions.body = data;
       } else {
         fetchOptions.body = JSON.stringify(data);
@@ -446,11 +446,11 @@ export class WordPressClient implements IWordPressClient {
     // Rate limiting
     await this.rateLimit();
 
-    let lastError: Error = new Error('Unknown error');
+    let lastError: Error = new Error("Unknown error");
     for (let attempt = 0; attempt < this.maxRetries; attempt++) {
       try {
         debug.log(
-          `API Request: ${method} ${url}${attempt > 0 ? ` (attempt ${attempt + 1})` : ''}`
+          `API Request: ${method} ${url}${attempt > 0 ? ` (attempt ${attempt + 1})` : ""}`,
         );
 
         const response = await fetch(url, fetchOptions);
@@ -479,29 +479,29 @@ export class WordPressClient implements IWordPressClient {
           // Handle permission errors specifically for uploads
           if (
             response.status === 403 &&
-            endpoint.includes('media') &&
-            method === 'POST'
+            endpoint.includes("media") &&
+            method === "POST"
           ) {
             throw new AuthenticationError(
-              'Media upload blocked: WordPress REST API media uploads appear to be disabled or restricted by a plugin/security policy. ' +
+              "Media upload blocked: WordPress REST API media uploads appear to be disabled or restricted by a plugin/security policy. " +
                 `Error: ${errorMessage}. ` +
-                'Common causes: W3 Total Cache, security plugins, or custom REST API restrictions. ' +
-                'Please check WordPress admin settings or contact your system administrator.',
-              this.auth.method
+                "Common causes: W3 Total Cache, security plugins, or custom REST API restrictions. " +
+                "Please check WordPress admin settings or contact your system administrator.",
+              this.auth.method,
             );
           }
 
           // Handle general upload permission errors
           if (
-            errorMessage.includes('Beiträge zu erstellen') &&
-            endpoint.includes('media')
+            errorMessage.includes("Beiträge zu erstellen") &&
+            endpoint.includes("media")
           ) {
             throw new AuthenticationError(
               `WordPress REST API media upload restriction detected: ${errorMessage}. ` +
-                'This typically indicates that media uploads via REST API are disabled by WordPress configuration, ' +
-                'a security plugin (like W3 Total Cache, Borlabs Cookie), or server policy. ' +
-                'User has sufficient permissions but WordPress/plugins are blocking the upload.',
-              this.auth.method
+                "This typically indicates that media uploads via REST API are disabled by WordPress configuration, " +
+                "a security plugin (like W3 Total Cache, Borlabs Cookie), or server policy. " +
+                "User has sufficient permissions but WordPress/plugins are blocking the upload.",
+              this.auth.method,
             );
           }
 
@@ -525,9 +525,9 @@ export class WordPressClient implements IWordPressClient {
           return result as T;
         } catch (parseError) {
           // For authentication requests, malformed JSON should be an error
-          if (endpoint.includes('users/me') || endpoint.includes('jwt-auth')) {
+          if (endpoint.includes("users/me") || endpoint.includes("jwt-auth")) {
             throw new WordPressAPIError(
-              `Invalid JSON response: ${(parseError as Error).message}`
+              `Invalid JSON response: ${(parseError as Error).message}`,
             );
           }
           this._stats.successfulRequests++;
@@ -540,30 +540,30 @@ export class WordPressClient implements IWordPressClient {
         lastError = error as Error;
 
         // Handle timeout errors
-        if ((error as any).name === 'AbortError') {
+        if ((error as any).name === "AbortError") {
           lastError = new Error(`Request timeout after ${requestTimeout}ms`);
         }
 
         // Handle network errors
         if (
-          lastError.message.includes('socket hang up') ||
-          lastError.message.includes('ECONNRESET')
+          lastError.message.includes("socket hang up") ||
+          lastError.message.includes("ECONNRESET")
         ) {
           lastError = new Error(
-            `Network connection lost during upload: ${lastError.message}`
+            `Network connection lost during upload: ${lastError.message}`,
           );
         }
 
         debug.log(
-          `Request failed (attempt ${attempt + 1}): ${lastError.message}`
+          `Request failed (attempt ${attempt + 1}): ${lastError.message}`,
         );
 
         // Don't retry on authentication errors, timeouts, or critical network errors
         if (
-          lastError.message.includes('401') ||
-          lastError.message.includes('403') ||
-          lastError.message.includes('timeout') ||
-          lastError.message.includes('Network connection lost')
+          lastError.message.includes("401") ||
+          lastError.message.includes("403") ||
+          lastError.message.includes("timeout") ||
+          lastError.message.includes("Network connection lost")
         ) {
           break;
         }
@@ -577,7 +577,7 @@ export class WordPressClient implements IWordPressClient {
     this._stats.failedRequests++;
     timer.end();
     throw new WordPressAPIError(
-      `Request failed after ${this.maxRetries} attempts: ${lastError.message}`
+      `Request failed after ${this.maxRetries} attempts: ${lastError.message}`,
     );
   }
 
@@ -591,38 +591,38 @@ export class WordPressClient implements IWordPressClient {
 
   // HTTP method helpers
   async get<T = any>(endpoint: string, options?: RequestOptions): Promise<T> {
-    return this.request<T>('GET', endpoint, null, options);
+    return this.request<T>("GET", endpoint, null, options);
   }
 
   async post<T = any>(
     endpoint: string,
     data?: any,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<T> {
-    return this.request<T>('POST', endpoint, data, options);
+    return this.request<T>("POST", endpoint, data, options);
   }
 
   async put<T = any>(
     endpoint: string,
     data?: any,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<T> {
-    return this.request<T>('PUT', endpoint, data, options);
+    return this.request<T>("PUT", endpoint, data, options);
   }
 
   async patch<T = any>(
     endpoint: string,
     data?: any,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<T> {
-    return this.request<T>('PATCH', endpoint, data, options);
+    return this.request<T>("PATCH", endpoint, data, options);
   }
 
   async delete<T = any>(
     endpoint: string,
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<T> {
-    return this.request<T>('DELETE', endpoint, null, options);
+    return this.request<T>("DELETE", endpoint, null, options);
   }
 
   // WordPress API Methods
@@ -630,20 +630,20 @@ export class WordPressClient implements IWordPressClient {
   // Posts
   async getPosts(params?: PostQueryParams): Promise<WordPressPost[]> {
     const queryString = params
-      ? '?' + new URLSearchParams(params as any).toString()
-      : '';
+      ? "?" + new URLSearchParams(params as any).toString()
+      : "";
     return this.get<WordPressPost[]>(`posts${queryString}`);
   }
 
   async getPost(
     id: number,
-    context: 'view' | 'embed' | 'edit' = 'view'
+    context: "view" | "embed" | "edit" = "view",
   ): Promise<WordPressPost> {
     return this.get<WordPressPost>(`posts/${id}?context=${context}`);
   }
 
   async createPost(data: CreatePostRequest): Promise<WordPressPost> {
-    return this.post<WordPressPost>('posts', data);
+    return this.post<WordPressPost>("posts", data);
   }
 
   async updatePost(data: UpdatePostRequest): Promise<WordPressPost> {
@@ -653,7 +653,7 @@ export class WordPressClient implements IWordPressClient {
 
   async deletePost(
     id: number,
-    force = false
+    force = false,
   ): Promise<{ deleted: boolean; previous?: WordPressPost }> {
     return this.delete(`posts/${id}?force=${force}`);
   }
@@ -665,20 +665,20 @@ export class WordPressClient implements IWordPressClient {
   // Pages
   async getPages(params?: PostQueryParams): Promise<WordPressPage[]> {
     const queryString = params
-      ? '?' + new URLSearchParams(params as any).toString()
-      : '';
+      ? "?" + new URLSearchParams(params as any).toString()
+      : "";
     return this.get<WordPressPage[]>(`pages${queryString}`);
   }
 
   async getPage(
     id: number,
-    context: 'view' | 'embed' | 'edit' = 'view'
+    context: "view" | "embed" | "edit" = "view",
   ): Promise<WordPressPage> {
     return this.get<WordPressPage>(`pages/${id}?context=${context}`);
   }
 
   async createPage(data: CreatePageRequest): Promise<WordPressPage> {
-    return this.post<WordPressPage>('pages', data);
+    return this.post<WordPressPage>("pages", data);
   }
 
   async updatePage(data: UpdatePageRequest): Promise<WordPressPage> {
@@ -688,7 +688,7 @@ export class WordPressClient implements IWordPressClient {
 
   async deletePage(
     id: number,
-    force = false
+    force = false,
   ): Promise<{ deleted: boolean; previous?: WordPressPage }> {
     return this.delete(`pages/${id}?force=${force}`);
   }
@@ -700,14 +700,14 @@ export class WordPressClient implements IWordPressClient {
   // Media
   async getMedia(params?: MediaQueryParams): Promise<WordPressMedia[]> {
     const queryString = params
-      ? '?' + new URLSearchParams(params as any).toString()
-      : '';
+      ? "?" + new URLSearchParams(params as any).toString()
+      : "";
     return this.get<WordPressMedia[]>(`media${queryString}`);
   }
 
   async getMediaItem(
     id: number,
-    context: 'view' | 'embed' | 'edit' = 'view'
+    context: "view" | "embed" | "edit" = "view",
   ): Promise<WordPressMedia> {
     return this.get<WordPressMedia>(`media/${id}?context=${context}`);
   }
@@ -725,19 +725,19 @@ export class WordPressClient implements IWordPressClient {
     const maxSize = 10 * 1024 * 1024; // 10MB reasonable limit
     if (stats.size > maxSize) {
       throw new Error(
-        `File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB. Maximum allowed: ${maxSize / 1024 / 1024}MB`
+        `File too large: ${(stats.size / 1024 / 1024).toFixed(2)}MB. Maximum allowed: ${maxSize / 1024 / 1024}MB`,
       );
     }
 
     debug.log(
-      `Uploading file: ${filename} (${(stats.size / 1024).toFixed(2)}KB)`
+      `Uploading file: ${filename} (${(stats.size / 1024).toFixed(2)}KB)`,
     );
 
     return this.uploadFile(
       fileBuffer,
       filename,
       this.getMimeType(data.file_path),
-      data
+      data,
     );
   }
 
@@ -746,7 +746,7 @@ export class WordPressClient implements IWordPressClient {
     filename: string,
     mimeType: string,
     meta: Partial<UploadMediaRequest> = {},
-    options?: RequestOptions
+    options?: RequestOptions,
   ): Promise<WordPressMedia> {
     debug.log(`Uploading file: ${filename} (${fileData.length} bytes)`);
 
@@ -755,30 +755,30 @@ export class WordPressClient implements IWordPressClient {
     formData.setMaxListeners(20);
 
     // Add file with correct options
-    formData.append('file', fileData, {
+    formData.append("file", fileData, {
       filename,
-      contentType: mimeType
+      contentType: mimeType,
     });
 
     // Add metadata
-    if (meta.title) formData.append('title', meta.title);
-    if (meta.alt_text) formData.append('alt_text', meta.alt_text);
-    if (meta.caption) formData.append('caption', meta.caption);
-    if (meta.description) formData.append('description', meta.description);
-    if (meta.post) formData.append('post', meta.post.toString());
+    if (meta.title) formData.append("title", meta.title);
+    if (meta.alt_text) formData.append("alt_text", meta.alt_text);
+    if (meta.caption) formData.append("caption", meta.caption);
+    if (meta.description) formData.append("description", meta.description);
+    if (meta.post) formData.append("post", meta.post.toString());
 
     // Use longer timeout for file uploads
     const uploadTimeout =
       options?.timeout !== undefined ? options.timeout : 600000; // 10 minutes default
     const uploadOptions: RequestOptions = {
       ...options,
-      timeout: uploadTimeout
+      timeout: uploadTimeout,
     };
 
     debug.log(`Upload prepared with FormData, timeout: ${uploadTimeout}ms`);
 
     // Use the regular post method which handles FormData correctly
-    return this.post<WordPressMedia>('media', formData, uploadOptions);
+    return this.post<WordPressMedia>("media", formData, uploadOptions);
   }
 
   async updateMedia(data: UpdateMediaRequest): Promise<WordPressMedia> {
@@ -788,7 +788,7 @@ export class WordPressClient implements IWordPressClient {
 
   async deleteMedia(
     id: number,
-    force = false
+    force = false,
   ): Promise<{ deleted: boolean; previous?: WordPressMedia }> {
     return this.delete(`media/${id}?force=${force}`);
   }
@@ -796,20 +796,20 @@ export class WordPressClient implements IWordPressClient {
   // Users
   async getUsers(params?: UserQueryParams): Promise<WordPressUser[]> {
     const queryString = params
-      ? '?' + new URLSearchParams(params as any).toString()
-      : '';
+      ? "?" + new URLSearchParams(params as any).toString()
+      : "";
     return this.get<WordPressUser[]>(`users${queryString}`);
   }
 
   async getUser(
-    id: number | 'me',
-    context: 'view' | 'embed' | 'edit' = 'view'
+    id: number | "me",
+    context: "view" | "embed" | "edit" = "view",
   ): Promise<WordPressUser> {
     return this.get<WordPressUser>(`users/${id}?context=${context}`);
   }
 
   async createUser(data: CreateUserRequest): Promise<WordPressUser> {
-    return this.post<WordPressUser>('users', data);
+    return this.post<WordPressUser>("users", data);
   }
 
   async updateUser(data: UpdateUserRequest): Promise<WordPressUser> {
@@ -819,35 +819,35 @@ export class WordPressClient implements IWordPressClient {
 
   async deleteUser(
     id: number,
-    reassign?: number
+    reassign?: number,
   ): Promise<{ deleted: boolean; previous?: WordPressUser }> {
     const params = reassign
       ? `?reassign=${reassign}&force=true`
-      : '?force=true';
+      : "?force=true";
     return this.delete(`users/${id}${params}`);
   }
 
   async getCurrentUser(): Promise<WordPressUser> {
-    return this.getUser('me');
+    return this.getUser("me");
   }
 
   // Comments
   async getComments(params?: CommentQueryParams): Promise<WordPressComment[]> {
     const queryString = params
-      ? '?' + new URLSearchParams(params as any).toString()
-      : '';
+      ? "?" + new URLSearchParams(params as any).toString()
+      : "";
     return this.get<WordPressComment[]>(`comments${queryString}`);
   }
 
   async getComment(
     id: number,
-    context: 'view' | 'embed' | 'edit' = 'view'
+    context: "view" | "embed" | "edit" = "view",
   ): Promise<WordPressComment> {
     return this.get<WordPressComment>(`comments/${id}?context=${context}`);
   }
 
   async createComment(data: CreateCommentRequest): Promise<WordPressComment> {
-    return this.post<WordPressComment>('comments', data);
+    return this.post<WordPressComment>("comments", data);
   }
 
   async updateComment(data: UpdateCommentRequest): Promise<WordPressComment> {
@@ -857,30 +857,30 @@ export class WordPressClient implements IWordPressClient {
 
   async deleteComment(
     id: number,
-    force = false
+    force = false,
   ): Promise<{ deleted: boolean; previous?: WordPressComment }> {
     return this.delete(`comments/${id}?force=${force}`);
   }
 
   async approveComment(id: number): Promise<WordPressComment> {
-    return this.put<WordPressComment>(`comments/${id}`, { status: 'approved' });
+    return this.put<WordPressComment>(`comments/${id}`, { status: "approved" });
   }
 
   async rejectComment(id: number): Promise<WordPressComment> {
     return this.put<WordPressComment>(`comments/${id}`, {
-      status: 'unapproved'
+      status: "unapproved",
     });
   }
 
   async spamComment(id: number): Promise<WordPressComment> {
-    return this.put<WordPressComment>(`comments/${id}`, { status: 'spam' });
+    return this.put<WordPressComment>(`comments/${id}`, { status: "spam" });
   }
 
   // Taxonomies
   async getCategories(params?: any): Promise<WordPressCategory[]> {
     const queryString = params
-      ? '?' + new URLSearchParams(params).toString()
-      : '';
+      ? "?" + new URLSearchParams(params).toString()
+      : "";
     return this.get<WordPressCategory[]>(`categories${queryString}`);
   }
 
@@ -889,13 +889,13 @@ export class WordPressClient implements IWordPressClient {
   }
 
   async createCategory(
-    data: CreateCategoryRequest
+    data: CreateCategoryRequest,
   ): Promise<WordPressCategory> {
-    return this.post<WordPressCategory>('categories', data);
+    return this.post<WordPressCategory>("categories", data);
   }
 
   async updateCategory(
-    data: UpdateCategoryRequest
+    data: UpdateCategoryRequest,
   ): Promise<WordPressCategory> {
     const { id, ...updateData } = data;
     return this.put<WordPressCategory>(`categories/${id}`, updateData);
@@ -903,15 +903,15 @@ export class WordPressClient implements IWordPressClient {
 
   async deleteCategory(
     id: number,
-    force = false
+    force = false,
   ): Promise<{ deleted: boolean; previous?: WordPressCategory }> {
     return this.delete(`categories/${id}?force=${force}`);
   }
 
   async getTags(params?: any): Promise<WordPressTag[]> {
     const queryString = params
-      ? '?' + new URLSearchParams(params).toString()
-      : '';
+      ? "?" + new URLSearchParams(params).toString()
+      : "";
     return this.get<WordPressTag[]>(`tags${queryString}`);
   }
 
@@ -920,7 +920,7 @@ export class WordPressClient implements IWordPressClient {
   }
 
   async createTag(data: CreateTagRequest): Promise<WordPressTag> {
-    return this.post<WordPressTag>('tags', data);
+    return this.post<WordPressTag>("tags", data);
   }
 
   async updateTag(data: UpdateTagRequest): Promise<WordPressTag> {
@@ -930,51 +930,51 @@ export class WordPressClient implements IWordPressClient {
 
   async deleteTag(
     id: number,
-    force = false
+    force = false,
   ): Promise<{ deleted: boolean; previous?: WordPressTag }> {
     return this.delete(`tags/${id}?force=${force}`);
   }
 
   // Site Management
   async getSiteSettings(): Promise<WordPressSiteSettings> {
-    return this.get<WordPressSiteSettings>('settings');
+    return this.get<WordPressSiteSettings>("settings");
   }
 
   async updateSiteSettings(
-    settings: Partial<WordPressSiteSettings>
+    settings: Partial<WordPressSiteSettings>,
   ): Promise<WordPressSiteSettings> {
-    return this.post<WordPressSiteSettings>('settings', settings);
+    return this.post<WordPressSiteSettings>("settings", settings);
   }
 
   async getSiteInfo(): Promise<any> {
-    return this.get('');
+    return this.get("");
   }
 
   // Application Passwords
   async getApplicationPasswords(
-    userId: number | 'me' = 'me'
+    userId: number | "me" = "me",
   ): Promise<WordPressApplicationPassword[]> {
     return this.get<WordPressApplicationPassword[]>(
-      `users/${userId}/application-passwords`
+      `users/${userId}/application-passwords`,
     );
   }
 
   async createApplicationPassword(
-    userId: number | 'me',
+    userId: number | "me",
     name: string,
-    appId?: string
+    appId?: string,
   ): Promise<WordPressApplicationPassword> {
     const data: any = { name };
     if (appId) data.app_id = appId;
     return this.post<WordPressApplicationPassword>(
       `users/${userId}/application-passwords`,
-      data
+      data,
     );
   }
 
   async deleteApplicationPassword(
-    userId: number | 'me',
-    uuid: string
+    userId: number | "me",
+    uuid: string,
   ): Promise<{ deleted: boolean }> {
     return this.delete(`users/${userId}/application-passwords/${uuid}`);
   }
@@ -983,11 +983,11 @@ export class WordPressClient implements IWordPressClient {
   async search(
     query: string,
     types?: string[],
-    subtype?: string
+    subtype?: string,
   ): Promise<any[]> {
     const params = new URLSearchParams({ search: query });
-    if (types) params.append('type', types.join(','));
-    if (subtype) params.append('subtype', subtype);
+    if (types) params.append("type", types.join(","));
+    if (subtype) params.append("subtype", subtype);
 
     return this.get<any[]>(`search?${params.toString()}`);
   }
@@ -995,7 +995,7 @@ export class WordPressClient implements IWordPressClient {
   // Utility Methods
   async ping(): Promise<boolean> {
     try {
-      await this.get('');
+      await this.get("");
       return true;
     } catch {
       return false;
@@ -1003,7 +1003,7 @@ export class WordPressClient implements IWordPressClient {
   }
 
   async getServerInfo(): Promise<Record<string, any>> {
-    return this.get('');
+    return this.get("");
   }
 
   validateEndpoint(endpoint: string): boolean {
@@ -1011,7 +1011,7 @@ export class WordPressClient implements IWordPressClient {
   }
 
   buildUrl(endpoint: string, params?: Record<string, any>): string {
-    const url = `${this.apiUrl}/${endpoint.replace(/^\/+/, '')}`;
+    const url = `${this.apiUrl}/${endpoint.replace(/^\/+/, "")}`;
     if (params) {
       const searchParams = new URLSearchParams(params);
       return `${url}?${searchParams.toString()}`;
@@ -1022,22 +1022,22 @@ export class WordPressClient implements IWordPressClient {
   private getMimeType(filePath: string): string {
     const ext = path.extname(filePath).toLowerCase();
     const mimeTypes: Record<string, string> = {
-      '.jpg': 'image/jpeg',
-      '.jpeg': 'image/jpeg',
-      '.png': 'image/png',
-      '.gif': 'image/gif',
-      '.webp': 'image/webp',
-      '.svg': 'image/svg+xml',
-      '.pdf': 'application/pdf',
-      '.doc': 'application/msword',
-      '.docx':
-        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-      '.txt': 'text/plain',
-      '.mp4': 'video/mp4',
-      '.mp3': 'audio/mpeg',
-      '.wav': 'audio/wav'
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".png": "image/png",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".svg": "image/svg+xml",
+      ".pdf": "application/pdf",
+      ".doc": "application/msword",
+      ".docx":
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      ".txt": "text/plain",
+      ".mp4": "video/mp4",
+      ".mp3": "audio/mpeg",
+      ".wav": "audio/wav",
     };
 
-    return mimeTypes[ext] || 'application/octet-stream';
+    return mimeTypes[ext] || "application/octet-stream";
   }
 }