mcp-wordpress 2.11.13 → 3.0.0

package/src/client/managers/composed/index.ts

@@ -24,16 +24,16 @@ export type {
   ComposedManager,
   ManagerFactory,
   ManagerCompositionConfig,
-} from "../interfaces/ManagerInterfaces.js";
+} from "@/client/managers/interfaces/ManagerInterfaces.js";
 
 // Implementations
-export { ConfigurationProviderImpl } from "../implementations/ConfigurationProviderImpl.js";
-export { ErrorHandlerImpl } from "../implementations/ErrorHandlerImpl.js";
-export { ParameterValidatorImpl } from "../implementations/ParameterValidatorImpl.js";
+export { ConfigurationProviderImpl } from "@/client/managers/implementations/ConfigurationProviderImpl.js";
+export { ErrorHandlerImpl } from "@/client/managers/implementations/ErrorHandlerImpl.js";
+export { ParameterValidatorImpl } from "@/client/managers/implementations/ParameterValidatorImpl.js";
 
 // Composed Managers
-export { ComposedAuthenticationManager } from "../ComposedAuthenticationManager.js";
-export { ComposedRequestManager } from "../ComposedRequestManager.js";
+export { ComposedAuthenticationManager } from "@/client/managers/ComposedAuthenticationManager.js";
+export { ComposedRequestManager } from "@/client/managers/ComposedRequestManager.js";
 
 // Factory and Client
 export {
@@ -41,7 +41,7 @@ export {
   ComposedWordPressClient,
   createComposedWordPressClient,
   type ComposedWordPressClientDependencies,
-} from "../ComposedManagerFactory.js";
+} from "@/client/managers/ComposedManagerFactory.js";
 
 // Migration utilities (for gradual migration from inheritance to composition)
 export { MigrationAdapter } from "./MigrationAdapter.js";

package/src/client/managers/implementations/ConfigurationProviderImpl.ts

@@ -4,7 +4,7 @@
  */
 
 import type { WordPressClientConfig } from "@/types/client.js";
-import type { ConfigurationProvider } from "../interfaces/ManagerInterfaces.js";
+import type { ConfigurationProvider } from "@/client/managers/interfaces/ManagerInterfaces.js";
 
 export class ConfigurationProviderImpl implements ConfigurationProvider {
   public readonly config: WordPressClientConfig;

package/src/client/managers/implementations/ErrorHandlerImpl.ts

@@ -6,7 +6,7 @@
 import { WordPressAPIError } from "@/types/client.js";
 import { debug, logError } from "@/utils/debug.js";
 import { getErrorMessage } from "@/utils/error.js";
-import type { ErrorHandler, ConfigurationProvider } from "../interfaces/ManagerInterfaces.js";
+import type { ErrorHandler, ConfigurationProvider } from "@/client/managers/interfaces/ManagerInterfaces.js";
 
 export class ErrorHandlerImpl implements ErrorHandler {
   constructor(private configProvider: ConfigurationProvider) {}

package/src/client/managers/implementations/ParameterValidatorImpl.ts

@@ -4,7 +4,7 @@
  */
 
 import { WordPressAPIError } from "@/types/client.js";
-import type { ParameterValidator } from "../interfaces/ManagerInterfaces.js";
+import type { ParameterValidator } from "@/client/managers/interfaces/ManagerInterfaces.js";
 
 export class ParameterValidatorImpl implements ParameterValidator {
   /**

package/src/client/operations/comments.ts

@@ -0,0 +1,96 @@
+/**
+ * Comments Operations Module
+ * Handles all comment-related WordPress REST API operations
+ */
+
+import type {
+  WordPressComment,
+  CommentQueryParams,
+  CreateCommentRequest,
+  UpdateCommentRequest,
+} from "@/types/wordpress.js";
+
+/**
+ * Interface for the base client methods needed by comments operations
+ */
+export interface CommentsClientBase {
+  get<T>(endpoint: string): Promise<T>;
+  post<T>(endpoint: string, data?: unknown): Promise<T>;
+  put<T>(endpoint: string, data?: unknown): Promise<T>;
+  delete<T>(endpoint: string): Promise<T>;
+}
+
+/**
+ * Comments operations mixin
+ * Provides CRUD operations for WordPress comments
+ */
+export class CommentsOperations {
+  constructor(private client: CommentsClientBase) {}
+
+  /**
+   * Get a list of comments with optional filtering
+   */
+  async getComments(params?: CommentQueryParams): Promise<WordPressComment[]> {
+    const normalizedParams = params
+      ? Object.fromEntries(Object.entries(params).map(([k, v]) => [k, String(v)]))
+      : undefined;
+    const queryString = normalizedParams ? "?" + new URLSearchParams(normalizedParams).toString() : "";
+    return this.client.get<WordPressComment[]>(`comments${queryString}`);
+  }
+
+  /**
+   * Get a single comment by ID
+   */
+  async getComment(id: number, context: "view" | "embed" | "edit" = "view"): Promise<WordPressComment> {
+    return this.client.get<WordPressComment>(`comments/${id}?context=${context}`);
+  }
+
+  /**
+   * Create a new comment
+   */
+  async createComment(data: CreateCommentRequest): Promise<WordPressComment> {
+    return this.client.post<WordPressComment>("comments", data);
+  }
+
+  /**
+   * Update an existing comment
+   */
+  async updateComment(data: UpdateCommentRequest): Promise<WordPressComment> {
+    const { id, ...updateData } = data;
+    return this.client.put<WordPressComment>(`comments/${id}`, updateData);
+  }
+
+  /**
+   * Delete a comment
+   */
+  async deleteComment(id: number, force = false): Promise<{ deleted: boolean; previous?: WordPressComment }> {
+    return this.client.delete(`comments/${id}?force=${force}`);
+  }
+
+  /**
+   * Approve a comment
+   */
+  async approveComment(id: number): Promise<WordPressComment> {
+    return this.client.put<WordPressComment>(`comments/${id}`, {
+      status: "approved",
+    });
+  }
+
+  /**
+   * Reject/unapprove a comment
+   */
+  async rejectComment(id: number): Promise<WordPressComment> {
+    return this.client.put<WordPressComment>(`comments/${id}`, {
+      status: "unapproved",
+    });
+  }
+
+  /**
+   * Mark a comment as spam
+   */
+  async spamComment(id: number): Promise<WordPressComment> {
+    return this.client.put<WordPressComment>(`comments/${id}`, {
+      status: "spam",
+    });
+  }
+}

package/src/client/operations/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Operations Module Index
+ * Re-exports all domain-specific operations for the WordPress API client
+ */
+
+export { PostsOperations, type PostsClientBase } from "./posts.js";
+export { PagesOperations, type PagesClientBase } from "./pages.js";
+export { MediaOperations, type MediaClientBase } from "./media.js";
+export { UsersOperations, type UsersClientBase } from "./users.js";
+export { CommentsOperations, type CommentsClientBase } from "./comments.js";
+export { TaxonomiesOperations, type TaxonomiesClientBase } from "./taxonomies.js";
+export { SiteOperations, type SiteClientBase } from "./site.js";

package/src/client/operations/media.ts

@@ -0,0 +1,162 @@
+/**
+ * Media Operations Module
+ * Handles all media-related WordPress REST API operations
+ */
+
+import FormData from "form-data";
+import { promises as fsPromises } from "fs";
+import * as path from "path";
+import type { WordPressMedia, MediaQueryParams, UploadMediaRequest, UpdateMediaRequest } from "@/types/wordpress.js";
+import type { RequestOptions } from "@/types/client.js";
+import { debug } from "@/utils/debug.js";
+
+/**
+ * Interface for the base client methods needed by media operations
+ */
+export interface MediaClientBase {
+  get<T>(endpoint: string): Promise<T>;
+  post<T>(endpoint: string, data?: unknown, options?: RequestOptions): Promise<T>;
+  put<T>(endpoint: string, data?: unknown): Promise<T>;
+  delete<T>(endpoint: string): Promise<T>;
+}
+
+/**
+ * Media operations mixin
+ * Provides CRUD operations for WordPress media
+ */
+export class MediaOperations {
+  constructor(private client: MediaClientBase) {}
+
+  /**
+   * Get a list of media items with optional filtering
+   */
+  async getMedia(params?: MediaQueryParams): Promise<WordPressMedia[]> {
+    const normalizedParams = params
+      ? Object.fromEntries(Object.entries(params).map(([k, v]) => [k, String(v)]))
+      : undefined;
+    const queryString = normalizedParams ? "?" + new URLSearchParams(normalizedParams).toString() : "";
+    return this.client.get<WordPressMedia[]>(`media${queryString}`);
+  }
+
+  /**
+   * Get a single media item by ID
+   */
+  async getMediaItem(id: number, context: "view" | "embed" | "edit" = "view"): Promise<WordPressMedia> {
+    return this.client.get<WordPressMedia>(`media/${id}?context=${context}`);
+  }
+
+  /**
+   * Upload media from a file path
+   */
+  async uploadMedia(data: UploadMediaRequest): Promise<WordPressMedia> {
+    // Use file handle to avoid TOCTOU race condition
+    let fileHandle;
+    try {
+      fileHandle = await fsPromises.open(data.file_path, "r");
+    } catch {
+      throw new Error(`File not found: ${data.file_path}`);
+    }
+
+    try {
+      const stats = await fileHandle.stat();
+      const filename = data.title || path.basename(data.file_path);
+
+      // Check if file is too large (WordPress default is 2MB for most installs)
+      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`,
+        );
+      }
+
+      const fileBuffer = await fileHandle.readFile();
+
+      debug.log(`Uploading file: ${filename} (${(stats.size / 1024).toFixed(2)}KB)`);
+
+      return this.uploadFile(fileBuffer, filename, this.getMimeType(data.file_path), data);
+    } finally {
+      await fileHandle.close();
+    }
+  }
+
+  /**
+   * Upload a file buffer as media
+   */
+  async uploadFile(
+    fileData: Buffer,
+    filename: string,
+    mimeType: string,
+    meta: Partial<UploadMediaRequest> = {},
+    options?: RequestOptions,
+  ): Promise<WordPressMedia> {
+    debug.log(`Uploading file: ${filename} (${fileData.length} bytes)`);
+
+    // Use FormData but with correct configuration for node-fetch
+    const formData = new FormData();
+    formData.setMaxListeners(20);
+
+    // Add file with correct options
+    formData.append("file", fileData, {
+      filename,
+      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());
+
+    // Use longer timeout for file uploads
+    const uploadTimeout = options?.timeout !== undefined ? options.timeout : 600000; // 10 minutes default
+    const uploadOptions: RequestOptions = {
+      ...options,
+      timeout: uploadTimeout,
+    };
+
+    debug.log(`Upload prepared with FormData, timeout: ${uploadTimeout}ms`);
+
+    // Use the regular post method which handles FormData correctly
+    return this.client.post<WordPressMedia>("media", formData, uploadOptions);
+  }
+
+  /**
+   * Update media metadata
+   */
+  async updateMedia(data: UpdateMediaRequest): Promise<WordPressMedia> {
+    const { id, ...updateData } = data;
+    return this.client.put<WordPressMedia>(`media/${id}`, updateData);
+  }
+
+  /**
+   * Delete a media item
+   */
+  async deleteMedia(id: number, force = false): Promise<{ deleted: boolean; previous?: WordPressMedia }> {
+    return this.client.delete(`media/${id}?force=${force}`);
+  }
+
+  /**
+   * Get MIME type from file extension
+   */
+  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",
+    };
+
+    return mimeTypes[ext] || "application/octet-stream";
+  }
+}

package/src/client/operations/pages.ts

@@ -0,0 +1,71 @@
+/**
+ * Pages Operations Module
+ * Handles all page-related WordPress REST API operations
+ */
+
+import type { WordPressPage, PostQueryParams, CreatePageRequest, UpdatePageRequest } from "@/types/wordpress.js";
+
+/**
+ * Interface for the base client methods needed by pages operations
+ */
+export interface PagesClientBase {
+  get<T>(endpoint: string): Promise<T>;
+  post<T>(endpoint: string, data?: unknown): Promise<T>;
+  put<T>(endpoint: string, data?: unknown): Promise<T>;
+  delete<T>(endpoint: string): Promise<T>;
+}
+
+/**
+ * Pages operations mixin
+ * Provides CRUD operations for WordPress pages
+ */
+export class PagesOperations {
+  constructor(private client: PagesClientBase) {}
+
+  /**
+   * Get a list of pages with optional filtering
+   */
+  async getPages(params?: PostQueryParams): Promise<WordPressPage[]> {
+    const normalizedParams = params
+      ? Object.fromEntries(Object.entries(params).map(([k, v]) => [k, String(v)]))
+      : undefined;
+    const queryString = normalizedParams ? "?" + new URLSearchParams(normalizedParams).toString() : "";
+    return this.client.get<WordPressPage[]>(`pages${queryString}`);
+  }
+
+  /**
+   * Get a single page by ID
+   */
+  async getPage(id: number, context: "view" | "embed" | "edit" = "view"): Promise<WordPressPage> {
+    return this.client.get<WordPressPage>(`pages/${id}?context=${context}`);
+  }
+
+  /**
+   * Create a new page
+   */
+  async createPage(data: CreatePageRequest): Promise<WordPressPage> {
+    return this.client.post<WordPressPage>("pages", data);
+  }
+
+  /**
+   * Update an existing page
+   */
+  async updatePage(data: UpdatePageRequest): Promise<WordPressPage> {
+    const { id, ...updateData } = data;
+    return this.client.put<WordPressPage>(`pages/${id}`, updateData);
+  }
+
+  /**
+   * Delete a page
+   */
+  async deletePage(id: number, force = false): Promise<{ deleted: boolean; previous?: WordPressPage }> {
+    return this.client.delete(`pages/${id}?force=${force}`);
+  }
+
+  /**
+   * Get page revisions
+   */
+  async getPageRevisions(id: number): Promise<WordPressPage[]> {
+    return this.client.get<WordPressPage[]>(`pages/${id}/revisions`);
+  }
+}

package/src/client/operations/posts.ts

@@ -0,0 +1,68 @@
+/**
+ * Posts Operations Module
+ * Handles all post-related WordPress REST API operations
+ */
+
+import type { WordPressPost, PostQueryParams, CreatePostRequest, UpdatePostRequest } from "@/types/wordpress.js";
+
+/**
+ * Interface for the base client methods needed by posts operations
+ */
+export interface PostsClientBase {
+  get<T>(endpoint: string): Promise<T>;
+  post<T>(endpoint: string, data?: unknown): Promise<T>;
+  put<T>(endpoint: string, data?: unknown): Promise<T>;
+  delete<T>(endpoint: string): Promise<T>;
+}
+
+/**
+ * Posts operations mixin
+ * Provides CRUD operations for WordPress posts
+ */
+export class PostsOperations {
+  constructor(private client: PostsClientBase) {}
+
+  /**
+   * Get a list of posts with optional filtering
+   */
+  async getPosts(params?: PostQueryParams): Promise<WordPressPost[]> {
+    const queryString = params ? "?" + new URLSearchParams(params as Record<string, string>).toString() : "";
+    return this.client.get<WordPressPost[]>(`posts${queryString}`);
+  }
+
+  /**
+   * Get a single post by ID
+   */
+  async getPost(id: number, context: "view" | "embed" | "edit" = "view"): Promise<WordPressPost> {
+    return this.client.get<WordPressPost>(`posts/${id}?context=${context}`);
+  }
+
+  /**
+   * Create a new post
+   */
+  async createPost(data: CreatePostRequest): Promise<WordPressPost> {
+    return this.client.post<WordPressPost>("posts", data);
+  }
+
+  /**
+   * Update an existing post
+   */
+  async updatePost(data: UpdatePostRequest): Promise<WordPressPost> {
+    const { id, ...updateData } = data;
+    return this.client.put<WordPressPost>(`posts/${id}`, updateData);
+  }
+
+  /**
+   * Delete a post
+   */
+  async deletePost(id: number, force = false): Promise<{ deleted: boolean; previous?: WordPressPost }> {
+    return this.client.delete(`posts/${id}?force=${force}`);
+  }
+
+  /**
+   * Get post revisions
+   */
+  async getPostRevisions(id: number): Promise<WordPressPost[]> {
+    return this.client.get<WordPressPost[]>(`posts/${id}/revisions`);
+  }
+}

package/src/client/operations/site.ts

@@ -0,0 +1,106 @@
+/**
+ * Site Operations Module
+ * Handles site management, settings, and application passwords
+ */
+
+import type {
+  WordPressSiteSettings,
+  WordPressSiteInfo,
+  WordPressApplicationPassword,
+  WordPressSearchResult,
+} from "@/types/wordpress.js";
+
+/**
+ * Interface for the base client methods needed by site operations
+ */
+export interface SiteClientBase {
+  get<T>(endpoint: string): Promise<T>;
+  post<T>(endpoint: string, data?: unknown): Promise<T>;
+  delete<T>(endpoint: string): Promise<T>;
+}
+
+/**
+ * Site operations mixin
+ * Provides operations for WordPress site settings, info, and application passwords
+ */
+export class SiteOperations {
+  constructor(private client: SiteClientBase) {}
+
+  /**
+   * Get site settings
+   */
+  async getSiteSettings(): Promise<WordPressSiteSettings> {
+    return this.client.get<WordPressSiteSettings>("settings");
+  }
+
+  /**
+   * Update site settings
+   */
+  async updateSiteSettings(settings: Partial<WordPressSiteSettings>): Promise<WordPressSiteSettings> {
+    return this.client.post<WordPressSiteSettings>("settings", settings);
+  }
+
+  /**
+   * Get site info (root endpoint)
+   */
+  async getSiteInfo(): Promise<WordPressSiteInfo> {
+    return this.client.get("");
+  }
+
+  /**
+   * Get application passwords for a user
+   */
+  async getApplicationPasswords(userId: number | "me" = "me"): Promise<WordPressApplicationPassword[]> {
+    return this.client.get<WordPressApplicationPassword[]>(`users/${userId}/application-passwords`);
+  }
+
+  /**
+   * Create an application password for a user
+   */
+  async createApplicationPassword(
+    userId: number | "me",
+    name: string,
+    appId?: string,
+  ): Promise<WordPressApplicationPassword> {
+    const data: Record<string, unknown> = { name };
+    if (appId) data.app_id = appId;
+    return this.client.post<WordPressApplicationPassword>(`users/${userId}/application-passwords`, data);
+  }
+
+  /**
+   * Delete an application password
+   */
+  async deleteApplicationPassword(userId: number | "me", uuid: string): Promise<{ deleted: boolean }> {
+    return this.client.delete(`users/${userId}/application-passwords/${uuid}`);
+  }
+
+  /**
+   * Search across WordPress content
+   */
+  async search(query: string, types?: string[], subtype?: string): Promise<WordPressSearchResult[]> {
+    const params = new URLSearchParams({ search: query });
+    if (types) params.append("type", types.join(","));
+    if (subtype) params.append("subtype", subtype);
+
+    return this.client.get<WordPressSearchResult[]>(`search?${params.toString()}`);
+  }
+
+  /**
+   * Ping the site to check availability
+   */
+  async ping(): Promise<boolean> {
+    try {
+      await this.client.get("");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get server info
+   */
+  async getServerInfo(): Promise<Record<string, unknown>> {
+    return this.client.get("");
+  }
+}