mcp-wordpress 1.2.2 → 1.3.0

package/dist/client/api.js

@@ -2,12 +2,12 @@
  * WordPress API Client
  * 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 { WordPressAPIError, AuthenticationError, RateLimitError } from '../types/client.js';
-import { debug, logError, startTimer } from '../utils/debug.js';
+import fetch from "node-fetch";
+import FormData from "form-data";
+import * as fs from "fs";
+import * as path from "path";
+import { WordPressAPIError, AuthenticationError, RateLimitError, } from "../types/client.js";
+import { debug, logError, startTimer } from "../utils/debug.js";
 export class WordPressClient {
     baseUrl;
     apiUrl;
@@ -21,16 +21,16 @@ export class WordPressClient {
     jwtToken = null;
     _stats;
     constructor(options = {}) {
-        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 = {
             totalRequests: 0,
@@ -38,7 +38,7 @@ export class WordPressClient {
             failedRequests: 0,
             averageResponseTime: 0,
             rateLimitHits: 0,
-            authFailures: 0
+            authFailures: 0,
         };
         // Validate configuration
         this.validateConfig();
@@ -48,7 +48,7 @@ export class WordPressClient {
             baseUrl: this.baseUrl,
             auth: this.auth,
             timeout: this.timeout,
-            maxRetries: this.maxRetries
+            maxRetries: this.maxRetries,
         };
     }
     get isAuthenticated() {
@@ -60,21 +60,21 @@ export class WordPressClient {
     getAuthFromEnv() {
         const authMethod = process.env.WORDPRESS_AUTH_METHOD;
         // Use explicit auth method if set
-        if (authMethod === 'app-password' &&
+        if (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,
             };
         }
         // Try JWT
@@ -82,41 +82,41 @@ export class WordPressClient {
             process.env.WORDPRESS_USERNAME &&
             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 ||
-                ''
+                "",
         };
     }
     validateConfig() {
         if (!this.baseUrl) {
-            throw new Error('WordPress configuration is incomplete: baseUrl is required');
+            throw new Error("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}`);
     }
@@ -126,7 +126,7 @@ export class WordPressClient {
     async disconnect() {
         this.authenticated = false;
         this.jwtToken = null;
-        debug.log('WordPress client disconnected');
+        debug.log("WordPress client disconnected");
     }
     /**
      * Add authentication headers to request
@@ -134,31 +134,31 @@ export class WordPressClient {
     addAuthHeaders(headers) {
         const method = this.auth.method?.toLowerCase();
         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}`;
+                    const credentials = Buffer.from(`${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}`;
+                    const credentials = Buffer.from(`${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;
         }
@@ -185,14 +185,14 @@ export class WordPressClient {
         const method = this.auth.method?.toLowerCase();
         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;
@@ -211,19 +211,19 @@ export class WordPressClient {
      */
     async authenticateWithBasic() {
         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';
-            const passwordField = this.auth.method === 'app-password' ? 'app password' : 'password';
+            const methodName = this.auth.method === "app-password" ? "Application Password" : "Basic";
+            const passwordField = this.auth.method === "app-password" ? "app password" : "password";
             throw new AuthenticationError(`Username and ${passwordField} are required for ${methodName} authentication`, this.auth.method);
         }
         try {
             // Test authentication by getting current user
-            await this.request('GET', 'users/me');
+            await this.request("GET", "users/me");
             this.authenticated = true;
-            debug.log('Basic/Application Password authentication successful');
+            debug.log("Basic/Application Password authentication successful");
             return true;
         }
         catch (error) {
@@ -235,18 +235,18 @@ export class WordPressClient {
      */
     async authenticateWithJWT() {
         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);
+            throw new AuthenticationError("JWT secret, username, and password are required for JWT authentication", this.auth.method);
         }
         try {
             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) {
                 throw new Error(`HTTP ${response.status}: ${response.statusText}`);
@@ -254,7 +254,7 @@ export class WordPressClient {
             const data = (await response.json());
             this.jwtToken = data.token;
             this.authenticated = true;
-            debug.log('JWT authentication successful');
+            debug.log("JWT authentication successful");
             return true;
         }
         catch (error) {
@@ -266,10 +266,10 @@ export class WordPressClient {
      */
     async authenticateWithCookie() {
         if (!this.auth.nonce) {
-            throw new AuthenticationError('Nonce is required for cookie authentication', this.auth.method);
+            throw new AuthenticationError("Nonce is required for cookie authentication", this.auth.method);
         }
         this.authenticated = true;
-        debug.log('Cookie authentication configured');
+        debug.log("Cookie authentication configured");
         return true;
     }
     /**
@@ -279,14 +279,14 @@ export class WordPressClient {
         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 = {
-            '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
         this.addAuthHeaders(headers);
@@ -295,24 +295,24 @@ export class WordPressClient {
         const requestTimeout = options.timeout || this.timeout;
         const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
         const fetchOptions = {
+            ...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 {
@@ -321,10 +321,10 @@ export class WordPressClient {
         }
         // Rate limiting
         await this.rateLimit();
-        let lastError = new Error('Unknown error');
+        let lastError = new Error("Unknown error");
         for (let attempt = 0; attempt < this.maxRetries; attempt++) {
             try {
-                debug.log(`API Request: ${method} ${url}${attempt > 0 ? ` (attempt ${attempt + 1})` : ''}`);
+                debug.log(`API Request: ${method} ${url}${attempt > 0 ? ` (attempt ${attempt + 1})` : ""}`);
                 const response = await fetch(url, fetchOptions);
                 clearTimeout(timeoutId);
                 // Handle different response types
@@ -347,20 +347,20 @@ export class WordPressClient {
                     }
                     // Handle permission errors specifically for uploads
                     if (response.status === 403 &&
-                        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. ' +
+                        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. " +
                             `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')) {
+                    if (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);
                     }
                     throw new WordPressAPIError(errorMessage, response.status);
                 }
@@ -381,7 +381,7 @@ export class WordPressClient {
                 }
                 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.message}`);
                     }
                     this._stats.successfulRequests++;
@@ -394,20 +394,20 @@ export class WordPressClient {
                 clearTimeout(timeoutId);
                 lastError = error;
                 // Handle timeout errors
-                if (error.name === 'AbortError') {
+                if (error.name === "AbortError") {
                     lastError = new Error(`Request timeout after ${requestTimeout}ms`);
                 }
                 // Handle network errors
-                if (lastError.message.includes('socket hang up') ||
-                    lastError.message.includes('ECONNRESET')) {
+                if (lastError.message.includes("socket hang up") ||
+                    lastError.message.includes("ECONNRESET")) {
                     lastError = new Error(`Network connection lost during upload: ${lastError.message}`);
                 }
                 debug.log(`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')) {
+                if (lastError.message.includes("401") ||
+                    lastError.message.includes("403") ||
+                    lastError.message.includes("timeout") ||
+                    lastError.message.includes("Network connection lost")) {
                     break;
                 }
                 if (attempt < this.maxRetries - 1) {
@@ -428,33 +428,33 @@ export class WordPressClient {
     }
     // HTTP method helpers
     async get(endpoint, options) {
-        return this.request('GET', endpoint, null, options);
+        return this.request("GET", endpoint, null, options);
     }
     async post(endpoint, data, options) {
-        return this.request('POST', endpoint, data, options);
+        return this.request("POST", endpoint, data, options);
     }
     async put(endpoint, data, options) {
-        return this.request('PUT', endpoint, data, options);
+        return this.request("PUT", endpoint, data, options);
     }
     async patch(endpoint, data, options) {
-        return this.request('PATCH', endpoint, data, options);
+        return this.request("PATCH", endpoint, data, options);
     }
     async delete(endpoint, options) {
-        return this.request('DELETE', endpoint, null, options);
+        return this.request("DELETE", endpoint, null, options);
     }
     // WordPress API Methods
     // Posts
     async getPosts(params) {
         const queryString = params
-            ? '?' + new URLSearchParams(params).toString()
-            : '';
+            ? "?" + new URLSearchParams(params).toString()
+            : "";
         return this.get(`posts${queryString}`);
     }
-    async getPost(id, context = 'view') {
+    async getPost(id, context = "view") {
         return this.get(`posts/${id}?context=${context}`);
     }
     async createPost(data) {
-        return this.post('posts', data);
+        return this.post("posts", data);
     }
     async updatePost(data) {
         const { id, ...updateData } = data;
@@ -469,15 +469,15 @@ export class WordPressClient {
     // Pages
     async getPages(params) {
         const queryString = params
-            ? '?' + new URLSearchParams(params).toString()
-            : '';
+            ? "?" + new URLSearchParams(params).toString()
+            : "";
         return this.get(`pages${queryString}`);
     }
-    async getPage(id, context = 'view') {
+    async getPage(id, context = "view") {
         return this.get(`pages/${id}?context=${context}`);
     }
     async createPage(data) {
-        return this.post('pages', data);
+        return this.post("pages", data);
     }
     async updatePage(data) {
         const { id, ...updateData } = data;
@@ -492,11 +492,11 @@ export class WordPressClient {
     // Media
     async getMedia(params) {
         const queryString = params
-            ? '?' + new URLSearchParams(params).toString()
-            : '';
+            ? "?" + new URLSearchParams(params).toString()
+            : "";
         return this.get(`media${queryString}`);
     }
-    async getMediaItem(id, context = 'view') {
+    async getMediaItem(id, context = "view") {
         return this.get(`media/${id}?context=${context}`);
     }
     async uploadMedia(data) {
@@ -520,30 +520,30 @@ export class WordPressClient {
         const formData = new FormData();
         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);
+            formData.append("title", meta.title);
         if (meta.alt_text)
-            formData.append('alt_text', meta.alt_text);
+            formData.append("alt_text", meta.alt_text);
         if (meta.caption)
-            formData.append('caption', meta.caption);
+            formData.append("caption", meta.caption);
         if (meta.description)
-            formData.append('description', meta.description);
+            formData.append("description", meta.description);
         if (meta.post)
-            formData.append('post', meta.post.toString());
+            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 = {
             ...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('media', formData, uploadOptions);
+        return this.post("media", formData, uploadOptions);
     }
     async updateMedia(data) {
         const { id, ...updateData } = data;
@@ -555,15 +555,15 @@ export class WordPressClient {
     // Users
     async getUsers(params) {
         const queryString = params
-            ? '?' + new URLSearchParams(params).toString()
-            : '';
+            ? "?" + new URLSearchParams(params).toString()
+            : "";
         return this.get(`users${queryString}`);
     }
-    async getUser(id, context = 'view') {
+    async getUser(id, context = "view") {
         return this.get(`users/${id}?context=${context}`);
     }
     async createUser(data) {
-        return this.post('users', data);
+        return this.post("users", data);
     }
     async updateUser(data) {
         const { id, ...updateData } = data;
@@ -572,24 +572,24 @@ export class WordPressClient {
     async deleteUser(id, reassign) {
         const params = reassign
             ? `?reassign=${reassign}&force=true`
-            : '?force=true';
+            : "?force=true";
         return this.delete(`users/${id}${params}`);
     }
     async getCurrentUser() {
-        return this.getUser('me');
+        return this.getUser("me");
     }
     // Comments
     async getComments(params) {
         const queryString = params
-            ? '?' + new URLSearchParams(params).toString()
-            : '';
+            ? "?" + new URLSearchParams(params).toString()
+            : "";
         return this.get(`comments${queryString}`);
     }
-    async getComment(id, context = 'view') {
+    async getComment(id, context = "view") {
         return this.get(`comments/${id}?context=${context}`);
     }
     async createComment(data) {
-        return this.post('comments', data);
+        return this.post("comments", data);
     }
     async updateComment(data) {
         const { id, ...updateData } = data;
@@ -599,28 +599,28 @@ export class WordPressClient {
         return this.delete(`comments/${id}?force=${force}`);
     }
     async approveComment(id) {
-        return this.put(`comments/${id}`, { status: 'approved' });
+        return this.put(`comments/${id}`, { status: "approved" });
     }
     async rejectComment(id) {
         return this.put(`comments/${id}`, {
-            status: 'unapproved'
+            status: "unapproved",
         });
     }
     async spamComment(id) {
-        return this.put(`comments/${id}`, { status: 'spam' });
+        return this.put(`comments/${id}`, { status: "spam" });
     }
     // Taxonomies
     async getCategories(params) {
         const queryString = params
-            ? '?' + new URLSearchParams(params).toString()
-            : '';
+            ? "?" + new URLSearchParams(params).toString()
+            : "";
         return this.get(`categories${queryString}`);
     }
     async getCategory(id) {
         return this.get(`categories/${id}`);
     }
     async createCategory(data) {
-        return this.post('categories', data);
+        return this.post("categories", data);
     }
     async updateCategory(data) {
         const { id, ...updateData } = data;
@@ -631,15 +631,15 @@ export class WordPressClient {
     }
     async getTags(params) {
         const queryString = params
-            ? '?' + new URLSearchParams(params).toString()
-            : '';
+            ? "?" + new URLSearchParams(params).toString()
+            : "";
         return this.get(`tags${queryString}`);
     }
     async getTag(id) {
         return this.get(`tags/${id}`);
     }
     async createTag(data) {
-        return this.post('tags', data);
+        return this.post("tags", data);
     }
     async updateTag(data) {
         const { id, ...updateData } = data;
@@ -650,16 +650,16 @@ export class WordPressClient {
     }
     // Site Management
     async getSiteSettings() {
-        return this.get('settings');
+        return this.get("settings");
     }
     async updateSiteSettings(settings) {
-        return this.post('settings', settings);
+        return this.post("settings", settings);
     }
     async getSiteInfo() {
-        return this.get('');
+        return this.get("");
     }
     // Application Passwords
-    async getApplicationPasswords(userId = 'me') {
+    async getApplicationPasswords(userId = "me") {
         return this.get(`users/${userId}/application-passwords`);
     }
     async createApplicationPassword(userId, name, appId) {
@@ -675,15 +675,15 @@ export class WordPressClient {
     async search(query, types, subtype) {
         const params = new URLSearchParams({ search: query });
         if (types)
-            params.append('type', types.join(','));
+            params.append("type", types.join(","));
         if (subtype)
-            params.append('subtype', subtype);
+            params.append("subtype", subtype);
         return this.get(`search?${params.toString()}`);
     }
     // Utility Methods
     async ping() {
         try {
-            await this.get('');
+            await this.get("");
             return true;
         }
         catch {
@@ -691,13 +691,13 @@ export class WordPressClient {
         }
     }
     async getServerInfo() {
-        return this.get('');
+        return this.get("");
     }
     validateEndpoint(endpoint) {
         return /^[a-zA-Z0-9\/\-_]+$/.test(endpoint);
     }
     buildUrl(endpoint, params) {
-        const url = `${this.apiUrl}/${endpoint.replace(/^\/+/, '')}`;
+        const url = `${this.apiUrl}/${endpoint.replace(/^\/+/, "")}`;
         if (params) {
             const searchParams = new URLSearchParams(params);
             return `${url}?${searchParams.toString()}`;
@@ -707,21 +707,21 @@ export class WordPressClient {
     getMimeType(filePath) {
         const ext = path.extname(filePath).toLowerCase();
         const mimeTypes = {
-            '.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";
     }
 }
 //# sourceMappingURL=api.js.map