mcp-wordpress 2.4.2 → 2.5.0

package/src/tools/site.ts

@@ -11,7 +11,12 @@ export class SiteTools {
    * Retrieves the list of site management tools.
    * @returns An array of MCPTool definitions.
    */
-  public getTools(): any[] {
+  public getTools(): Array<{
+    name: string;
+    description: string;
+    parameters?: Array<{ name: string; type?: string; description?: string; required?: boolean; enum?: string[]; items?: unknown }>;
+    handler: (client: WordPressClient, params: Record<string, unknown>) => Promise<unknown>;
+  }> {
     return [
       {
         name: "wp_get_site_settings",
@@ -121,7 +126,10 @@ export class SiteTools {
     ];
   }
 
-  public async handleGetSiteSettings(client: WordPressClient, params: any): Promise<any> {
+  public async handleGetSiteSettings(
+    client: WordPressClient,
+    _params: Record<string, unknown>,
+  ): Promise<unknown> {
     try {
       const settings = await client.getSiteSettings();
       const siteUrl = client.getSiteUrl();
@@ -179,7 +187,10 @@ export class SiteTools {
     }
   }
 
-  public async handleUpdateSiteSettings(client: WordPressClient, params: any): Promise<any> {
+  public async handleUpdateSiteSettings(
+    client: WordPressClient,
+    params: Record<string, unknown>,
+  ): Promise<unknown> {
     try {
       const updatedSettings = await client.updateSiteSettings(params);
       return `✅ Site settings updated successfully. New title: ${updatedSettings.title}`;
@@ -190,15 +201,16 @@ export class SiteTools {
 
   public async handleSearchSite(
     client: WordPressClient,
-    params: { term: string; type?: "posts" | "pages" | "media" },
-  ): Promise<any> {
+    params: Record<string, unknown>,
+  ): Promise<unknown> {
     try {
-      const results = await client.search(params.term, params.type ? [params.type] : undefined);
+      const { term, type } = params as { term: string; type?: "posts" | "pages" | "media" };
+      const results = await client.search(term, type ? [type] : undefined);
       if (results.length === 0) {
-        return `No results found for "${params.term}".`;
+        return `No results found for "${term}".`;
       }
       const content =
-        `Found ${results.length} results for "${params.term}":\n\n` +
+        `Found ${results.length} results for "${term}":\n\n` +
         results.map((r) => `- [${r.type}] **${r.title}**\n  Link: ${r.url}`).join("\n");
       return content;
     } catch (error) {
@@ -206,14 +218,15 @@ export class SiteTools {
     }
   }
 
-  public async handleGetApplicationPasswords(client: WordPressClient, params: { user_id: number }): Promise<any> {
+  public async handleGetApplicationPasswords(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
     try {
-      const passwords = await client.getApplicationPasswords(params.user_id);
+      const { user_id } = params as { user_id: number };
+      const passwords = await client.getApplicationPasswords(user_id);
       if (passwords.length === 0) {
-        return `No application passwords found for user ID ${params.user_id}.`;
+        return `No application passwords found for user ID ${user_id}.`;
       }
       const content =
-        `Found ${passwords.length} application passwords for user ID ${params.user_id}:\n\n` +
+        `Found ${passwords.length} application passwords for user ID ${user_id}:\n\n` +
         passwords
           .map(
             (p: WordPressApplicationPassword) =>
@@ -228,10 +241,11 @@ export class SiteTools {
 
   public async handleCreateApplicationPassword(
     client: WordPressClient,
-    params: { user_id: number; app_name: string },
-  ): Promise<any> {
+    params: Record<string, unknown>,
+  ): Promise<unknown> {
     try {
-      const result = await client.createApplicationPassword(params.user_id, params.app_name);
+      const { user_id, app_name } = params as { user_id: number; app_name: string };
+      const result = await client.createApplicationPassword(user_id, app_name);
       const content =
         "✅ **Application password created successfully!**\n\n" +
         `**Name:** ${result.name}\n` +
@@ -245,11 +259,12 @@ export class SiteTools {
 
   public async handleDeleteApplicationPassword(
     client: WordPressClient,
-    params: { user_id: number; uuid: string },
-  ): Promise<any> {
+    params: Record<string, unknown>,
+  ): Promise<unknown> {
     try {
-      await client.deleteApplicationPassword(params.user_id, params.uuid);
-      return `✅ Application password with UUID ${params.uuid} has been revoked.`;
+      const { user_id, uuid } = params as { user_id: number; uuid: string };
+      await client.deleteApplicationPassword(user_id, uuid);
+      return `✅ Application password with UUID ${uuid} has been revoked.`;
     } catch (error) {
       throw new Error(`Failed to delete application password: ${getErrorMessage(error)}`);
     }

package/src/tools/taxonomies.ts

@@ -16,7 +16,12 @@ export class TaxonomyTools {
    * Retrieves the list of taxonomy management tools.
    * @returns An array of MCPTool definitions.
    */
-  public getTools(): any[] {
+  public getTools(): Array<{
+    name: string;
+    description: string;
+    parameters?: Array<{ name: string; type?: string; description?: string; required?: boolean; enum?: string[]; items?: unknown }>;
+    handler: (client: WordPressClient, params: Record<string, unknown>) => Promise<unknown>;
+  }> {
     return [
       // Categories
       {
@@ -171,32 +176,26 @@ export class TaxonomyTools {
     ];
   }
 
-  public async handleListCategories(
-    client: WordPressClient,
-    params: any,
-  ): Promise<any> {
+  public async handleListCategories(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const queryParams = params as Record<string, string | number | boolean>;
     try {
-      const categories = await client.getCategories(params);
+      const categories = await client.getCategories(queryParams);
       if (categories.length === 0) {
         return "No categories found.";
       }
       const content =
         `Found ${categories.length} categories:\n\n` +
-        categories
-          .map((c) => `- ID ${c.id}: **${c.name}** (Posts: ${c.count})`)
-          .join("\n");
+        categories.map((c) => `- ID ${c.id}: **${c.name}** (Posts: ${c.count})`).join("\n");
       return content;
     } catch (error) {
       throw new Error(`Failed to list categories: ${getErrorMessage(error)}`);
     }
   }
 
-  public async handleGetCategory(
-    client: WordPressClient,
-    params: { id: number },
-  ): Promise<any> {
+  public async handleGetCategory(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const { id } = params as { id: number };
     try {
-      const category = await client.getCategory(params.id);
+      const category = await client.getCategory(id);
       const content =
         `**Category Details (ID: ${category.id})**\n\n` +
         `- **Name:** ${category.name}\n` +
@@ -209,12 +208,10 @@ export class TaxonomyTools {
     }
   }
 
-  public async handleCreateCategory(
-    client: WordPressClient,
-    params: CreateCategoryRequest,
-  ): Promise<any> {
+  public async handleCreateCategory(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const createParams = params as unknown as CreateCategoryRequest;
     try {
-      const category = await client.createCategory(params);
+      const category = await client.createCategory(createParams);
       return `✅ Category "${category.name}" created successfully with ID: ${category.id}.`;
     } catch (error) {
       throw new Error(`Failed to create category: ${getErrorMessage(error)}`);
@@ -223,54 +220,47 @@ export class TaxonomyTools {
 
   public async handleUpdateCategory(
     client: WordPressClient,
-    params: UpdateCategoryRequest & { id: number },
-  ): Promise<any> {
+    params: Record<string, unknown>,
+  ): Promise<unknown> {
+    const updateParams = params as unknown as UpdateCategoryRequest;
     try {
-      const category = await client.updateCategory(params);
+      const category = await client.updateCategory(updateParams);
       return `✅ Category ${category.id} updated successfully.`;
     } catch (error) {
       throw new Error(`Failed to update category: ${getErrorMessage(error)}`);
     }
   }
 
-  public async handleDeleteCategory(
-    client: WordPressClient,
-    params: { id: number },
-  ): Promise<any> {
+  public async handleDeleteCategory(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const { id } = params as { id: number };
     try {
-      await client.deleteCategory(params.id);
-      return `✅ Category ${params.id} has been deleted.`;
+      await client.deleteCategory(id);
+      return `✅ Category ${id} has been deleted.`;
     } catch (error) {
       throw new Error(`Failed to delete category: ${getErrorMessage(error)}`);
     }
   }
 
-  public async handleListTags(
-    client: WordPressClient,
-    params: any,
-  ): Promise<any> {
+  public async handleListTags(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const queryParams = params as Record<string, string | number | boolean>;
     try {
-      const tags = await client.getTags(params);
+      const tags = await client.getTags(queryParams);
       if (tags.length === 0) {
         return "No tags found.";
       }
       const content =
         `Found ${tags.length} tags:\n\n` +
-        tags
-          .map((t) => `- ID ${t.id}: **${t.name}** (Posts: ${t.count})`)
-          .join("\n");
+        tags.map((t) => `- ID ${t.id}: **${t.name}** (Posts: ${t.count})`).join("\n");
       return content;
     } catch (error) {
       throw new Error(`Failed to list tags: ${getErrorMessage(error)}`);
     }
   }
 
-  public async handleGetTag(
-    client: WordPressClient,
-    params: { id: number },
-  ): Promise<any> {
+  public async handleGetTag(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const { id } = params as { id: number };
     try {
-      const tag = await client.getTag(params.id);
+      const tag = await client.getTag(id);
       const content =
         `**Tag Details (ID: ${tag.id})**\n\n` +
         `- **Name:** ${tag.name}\n` +
@@ -282,37 +272,31 @@ export class TaxonomyTools {
     }
   }
 
-  public async handleCreateTag(
-    client: WordPressClient,
-    params: CreateTagRequest,
-  ): Promise<any> {
+  public async handleCreateTag(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const createParams = params as unknown as CreateTagRequest;
     try {
-      const tag = await client.createTag(params);
+      const tag = await client.createTag(createParams);
       return `✅ Tag "${tag.name}" created successfully with ID: ${tag.id}.`;
     } catch (error) {
       throw new Error(`Failed to create tag: ${getErrorMessage(error)}`);
     }
   }
 
-  public async handleUpdateTag(
-    client: WordPressClient,
-    params: UpdateTagRequest & { id: number },
-  ): Promise<any> {
+  public async handleUpdateTag(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const updateParams = params as unknown as UpdateTagRequest;
     try {
-      const tag = await client.updateTag(params);
+      const tag = await client.updateTag(updateParams);
       return `✅ Tag ${tag.id} updated successfully.`;
     } catch (error) {
       throw new Error(`Failed to update tag: ${getErrorMessage(error)}`);
     }
   }
 
-  public async handleDeleteTag(
-    client: WordPressClient,
-    params: { id: number },
-  ): Promise<any> {
+  public async handleDeleteTag(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const { id } = params as { id: number };
     try {
-      await client.deleteTag(params.id);
-      return `✅ Tag ${params.id} has been deleted.`;
+      await client.deleteTag(id);
+      return `✅ Tag ${id} has been deleted.`;
     } catch (error) {
       throw new Error(`Failed to delete tag: ${getErrorMessage(error)}`);
     }

package/src/tools/users.ts

@@ -12,7 +12,12 @@ export class UserTools {
    * Retrieves the list of user management tools.
    * @returns An array of MCPTool definitions.
    */
-  public getTools(): any[] {
+  public getTools(): Array<{
+    name: string;
+    description: string;
+    parameters?: Array<{ name: string; type?: string; description?: string; required?: boolean; enum?: string[]; items?: unknown }>;
+    handler: (client: WordPressClient, params: Record<string, unknown>) => Promise<unknown>;
+  }> {
     return [
       {
         name: "wp_list_users",
@@ -139,7 +144,7 @@ export class UserTools {
     ];
   }
 
-  public async handleListUsers(client: WordPressClient, params: UserQueryParams): Promise<any> {
+  public async handleListUsers(client: WordPressClient, params: UserQueryParams): Promise<unknown> {
     try {
       const users = await client.getUsers(params);
       if (users.length === 0) {
@@ -148,7 +153,7 @@ export class UserTools {
 
       // Use streaming for large user result sets (>30 users)
       if (users.length > 30) {
-        const streamResults: StreamingResult<any>[] = [];
+        const streamResults: StreamingResult<unknown>[] = [];
 
         for await (const result of WordPressDataStreamer.streamUsers(users, {
           includeRoles: true,
@@ -218,9 +223,10 @@ export class UserTools {
     }
   }
 
-  public async handleGetUser(client: WordPressClient, params: { id: number }): Promise<any> {
+  public async handleGetUser(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const { id } = params as { id: number };
     try {
-      const user = await client.getUser(params.id);
+      const user = await client.getUser(id);
       const content =
         `**User Details (ID: ${user.id})**\n\n` +
         `- **Name:** ${user.name}\n` +
@@ -233,7 +239,10 @@ export class UserTools {
     }
   }
 
-  public async handleGetCurrentUser(client: WordPressClient, params: any): Promise<any> {
+  public async handleGetCurrentUser(
+    client: WordPressClient,
+    params: Record<string, unknown>,
+  ): Promise<Record<string, unknown>> {
     try {
       const user = await client.getCurrentUser();
       const siteUrl = client.getSiteUrl();
@@ -290,36 +299,39 @@ export class UserTools {
         `- **Key Capabilities:** ${userCapabilities || "None"}\n` +
         `- **Profile Link:** ${user.link || `${siteUrl}/wp-admin/profile.php`}`;
 
-      return content;
+      return { content };
     } catch (error) {
       throw new Error(`Failed to get current user: ${getErrorMessage(error)}`);
     }
   }
 
-  public async handleCreateUser(client: WordPressClient, params: CreateUserRequest): Promise<any> {
+  public async handleCreateUser(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const createParams = params as unknown as CreateUserRequest;
     try {
-      const user = await client.createUser(params);
+      const user = await client.createUser(createParams);
       return `✅ User "${user.name}" created successfully with ID: ${user.id}.`;
     } catch (error) {
       throw new Error(`Failed to create user: ${getErrorMessage(error)}`);
     }
   }
 
-  public async handleUpdateUser(client: WordPressClient, params: UpdateUserRequest & { id: number }): Promise<any> {
+  public async handleUpdateUser(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const updateParams = params as unknown as UpdateUserRequest;
     try {
-      const user = await client.updateUser(params);
+      const user = await client.updateUser(updateParams);
       return `✅ User ${user.id} updated successfully.`;
     } catch (error) {
       throw new Error(`Failed to update user: ${getErrorMessage(error)}`);
     }
   }
 
-  public async handleDeleteUser(client: WordPressClient, params: { id: number; reassign?: number }): Promise<any> {
+  public async handleDeleteUser(client: WordPressClient, params: Record<string, unknown>): Promise<unknown> {
+    const { id, reassign } = params as { id: number; reassign?: number };
     try {
-      await client.deleteUser(params.id, params.reassign);
-      let content = `✅ User ${params.id} has been deleted.`;
-      if (params.reassign) {
-        content += ` Their content has been reassigned to user ID ${params.reassign}.`;
+      await client.deleteUser(id, reassign);
+      let content = `✅ User ${id} has been deleted.`;
+      if (reassign) {
+        content += ` Their content has been reassigned to user ID ${reassign}.`;
       }
       return content;
     } catch (error) {