mcp-wordpress 1.1.2

package/src/tools/site.ts

@@ -0,0 +1,227 @@
+import { WordPressClient } from "../client/api.js";
+import {
+  WordPressApplicationPassword,
+} from "../types/wordpress.js";
+import { getErrorMessage } from "../utils/error.js";
+
+/**
+ * Provides tools for managing general site settings and operations on a WordPress site.
+ * This class encapsulates tool definitions and their corresponding handlers.
+ */
+export class SiteTools {
+  /**
+   * Retrieves the list of site management tools.
+   * @returns An array of MCPTool definitions.
+   */
+  public getTools(): any[] {
+    return [
+      {
+        name: "wp_get_site_settings",
+        description: "Retrieves the general settings for a WordPress site.",
+        parameters: [],
+        handler: this.handleGetSiteSettings.bind(this),
+      },
+      {
+        name: "wp_update_site_settings",
+        description:
+          "Updates one or more general settings for a WordPress site.",
+        parameters: [
+          {
+            name: "title",
+            type: "string",
+            description: "The title of the site.",
+          },
+          {
+            name: "description",
+            type: "string",
+            description: "The tagline or description of the site.",
+          },
+          {
+            name: "timezone",
+            type: "string",
+            description:
+              "A city in the same timezone, e.g., 'America/New_York'.",
+          },
+        ],
+        handler: this.handleUpdateSiteSettings.bind(this),
+      },
+      {
+        name: "wp_search_site",
+        description: "Performs a site-wide search for content.",
+        parameters: [
+          {
+            name: "term",
+            type: "string",
+            required: true,
+            description: "The search term to look for.",
+          },
+          {
+            name: "type",
+            type: "string",
+            description: "The type of content to search.",
+            enum: ["posts", "pages", "media"],
+          },
+        ],
+        handler: this.handleSearchSite.bind(this),
+      },
+      {
+        name: "wp_get_application_passwords",
+        description: "Lists application passwords for a specific user.",
+        parameters: [
+          {
+            name: "user_id",
+            type: "number",
+            required: true,
+            description: "The ID of the user to get application passwords for.",
+          },
+        ],
+        handler: this.handleGetApplicationPasswords.bind(this),
+      },
+      {
+        name: "wp_create_application_password",
+        description: "Creates a new application password for a user.",
+        parameters: [
+          {
+            name: "user_id",
+            type: "number",
+            required: true,
+            description: "The ID of the user to create the password for.",
+          },
+          {
+            name: "app_name",
+            type: "string",
+            required: true,
+            description: "The name of the application this password is for.",
+          },
+        ],
+        handler: this.handleCreateApplicationPassword.bind(this),
+      },
+      {
+        name: "wp_delete_application_password",
+        description: "Revokes an existing application password.",
+        parameters: [
+          {
+            name: "user_id",
+            type: "number",
+            required: true,
+            description: "The ID of the user who owns the password.",
+          },
+          {
+            name: "uuid",
+            type: "string",
+            required: true,
+            description: "The UUID of the application password to revoke.",
+          },
+        ],
+        handler: this.handleDeleteApplicationPassword.bind(this),
+      },
+    ];
+  }
+
+  public async handleGetSiteSettings(
+    client: WordPressClient,
+    params: any,
+  ): Promise<any> {
+    try {
+      const settings = await client.getSiteSettings();
+      const content =
+        `**Site Settings for ${settings.url}**\n\n` +
+        `- **Title:** ${settings.title}\n` +
+        `- **Description:** ${settings.description}\n` +
+        `- **Timezone:** ${settings.timezone}\n` +
+        `- **Language:** ${settings.language}`;
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to get site settings: ${getErrorMessage(error)}`);
+    }
+  }
+
+  public async handleUpdateSiteSettings(
+    client: WordPressClient,
+    params: any,
+  ): Promise<any> {
+    try {
+      const updatedSettings = await client.updateSiteSettings(params);
+      return `✅ Site settings updated successfully. New title: ${updatedSettings.title}`;
+    } catch (error) {
+      throw new Error(`Failed to update site settings: ${getErrorMessage(error)}`);
+    }
+  }
+
+  public async handleSearchSite(
+    client: WordPressClient,
+    params: { term: string; type?: "posts" | "pages" | "media" },
+  ): Promise<any> {
+    try {
+      const results = await client.search(params.term, params.type ? [params.type] : undefined);
+      if (results.length === 0) {
+        return `No results found for "${params.term}".`;
+      }
+      const content =
+        `Found ${results.length} results for "${params.term}":\n\n` +
+        results
+          .map((r) => `- [${r.type}] **${r.title}**\n  Link: ${r.url}`)
+          .join("\n");
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to perform search: ${getErrorMessage(error)}`);
+    }
+  }
+
+  public async handleGetApplicationPasswords(
+    client: WordPressClient,
+    params: { user_id: number },
+  ): Promise<any> {
+    try {
+      const passwords = await client.getApplicationPasswords(params.user_id);
+      if (passwords.length === 0) {
+        return `No application passwords found for user ID ${params.user_id}.`;
+      }
+      const content =
+        `Found ${passwords.length} application passwords for user ID ${params.user_id}:\n\n` +
+        passwords
+          .map(
+            (p: WordPressApplicationPassword) =>
+              `- **${p.name}** (UUID: ${p.uuid})\n  Created: ${new Date(p.created).toLocaleDateString()}`,
+          )
+          .join("\n");
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to get application passwords: ${getErrorMessage(error)}`);
+    }
+  }
+
+  public async handleCreateApplicationPassword(
+    client: WordPressClient,
+    params: { user_id: number; app_name: string },
+  ): Promise<any> {
+    try {
+      const result = await client.createApplicationPassword(
+        params.user_id,
+        params.app_name,
+      );
+      const content =
+        `✅ **Application password created successfully!**\n\n` +
+        `**Name:** ${result.name}\n` +
+        `**Password:** \`${result.password}\`\n\n` +
+        `**IMPORTANT:** This password is shown only once. Please save it securely.`;
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to create application password: ${getErrorMessage(error)}`);
+    }
+  }
+
+  public async handleDeleteApplicationPassword(
+    client: WordPressClient,
+    params: { user_id: number; uuid: string },
+  ): Promise<any> {
+    try {
+      await client.deleteApplicationPassword(params.user_id, params.uuid);
+      return `✅ Application password with UUID ${params.uuid} has been revoked.`;
+    } catch (error) {
+      throw new Error(`Failed to delete application password: ${getErrorMessage(error)}`);
+    }
+  }
+}
+
+export default SiteTools;

package/src/tools/taxonomies.ts

@@ -0,0 +1,322 @@
+import { WordPressClient } from "../client/api.js";
+import {
+  CreateCategoryRequest,
+  CreateTagRequest,
+  UpdateCategoryRequest,
+  UpdateTagRequest,
+} from "../types/wordpress.js";
+import { getErrorMessage } from "../utils/error.js";
+
+/**
+ * Provides tools for managing taxonomies (categories and tags) on a WordPress site.
+ * This class encapsulates tool definitions and their corresponding handlers.
+ */
+export class TaxonomyTools {
+  /**
+   * Retrieves the list of taxonomy management tools.
+   * @returns An array of MCPTool definitions.
+   */
+  public getTools(): any[] {
+    return [
+      // Categories
+      {
+        name: "wp_list_categories",
+        description: "Lists categories from a WordPress site.",
+        parameters: [
+          {
+            name: "search",
+            type: "string",
+            description: "Limit results to those matching a search term.",
+          },
+          {
+            name: "hide_empty",
+            type: "boolean",
+            description: "Whether to hide categories with no posts.",
+          },
+        ],
+        handler: this.handleListCategories.bind(this),
+      },
+      {
+        name: "wp_get_category",
+        description: "Retrieves a single category by its ID.",
+        parameters: [
+          {
+            name: "id",
+            type: "number",
+            required: true,
+            description: "The unique identifier for the category.",
+          },
+        ],
+        handler: this.handleGetCategory.bind(this),
+      },
+      {
+        name: "wp_create_category",
+        description: "Creates a new category.",
+        parameters: [
+          {
+            name: "name",
+            type: "string",
+            required: true,
+            description: "The name of the category.",
+          },
+          {
+            name: "description",
+            type: "string",
+            description: "The description for the category.",
+          },
+        ],
+        handler: this.handleCreateCategory.bind(this),
+      },
+      {
+        name: "wp_update_category",
+        description: "Updates an existing category.",
+        parameters: [
+          {
+            name: "id",
+            type: "number",
+            required: true,
+            description: "The ID of the category to update.",
+          },
+          {
+            name: "name",
+            type: "string",
+            description: "The new name for the category.",
+          },
+        ],
+        handler: this.handleUpdateCategory.bind(this),
+      },
+      {
+        name: "wp_delete_category",
+        description: "Deletes a category.",
+        parameters: [
+          {
+            name: "id",
+            type: "number",
+            required: true,
+            description: "The ID of the category to delete.",
+          },
+        ],
+        handler: this.handleDeleteCategory.bind(this),
+      },
+      // Tags
+      {
+        name: "wp_list_tags",
+        description: "Lists tags from a WordPress site.",
+        parameters: [
+          {
+            name: "search",
+            type: "string",
+            description: "Limit results to those matching a search term.",
+          },
+        ],
+        handler: this.handleListTags.bind(this),
+      },
+      {
+        name: "wp_get_tag",
+        description: "Retrieves a single tag by its ID.",
+        parameters: [
+          {
+            name: "id",
+            type: "number",
+            required: true,
+            description: "The unique identifier for the tag.",
+          },
+        ],
+        handler: this.handleGetTag.bind(this),
+      },
+      {
+        name: "wp_create_tag",
+        description: "Creates a new tag.",
+        parameters: [
+          {
+            name: "name",
+            type: "string",
+            required: true,
+            description: "The name of the tag.",
+          },
+        ],
+        handler: this.handleCreateTag.bind(this),
+      },
+      {
+        name: "wp_update_tag",
+        description: "Updates an existing tag.",
+        parameters: [
+          {
+            name: "id",
+            type: "number",
+            required: true,
+            description: "The ID of the tag to update.",
+          },
+          {
+            name: "name",
+            type: "string",
+            description: "The new name for the tag.",
+          },
+        ],
+        handler: this.handleUpdateTag.bind(this),
+      },
+      {
+        name: "wp_delete_tag",
+        description: "Deletes a tag.",
+        parameters: [
+          {
+            name: "id",
+            type: "number",
+            required: true,
+            description: "The ID of the tag to delete.",
+          },
+        ],
+        handler: this.handleDeleteTag.bind(this),
+      },
+    ];
+  }
+
+  public async handleListCategories(
+    client: WordPressClient,
+    params: any,
+  ): Promise<any> {
+    try {
+      const categories = await client.getCategories(params);
+      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");
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to list categories: ${getErrorMessage(error)}`);
+    }
+  }
+
+  public async handleGetCategory(
+    client: WordPressClient,
+    params: { id: number },
+  ): Promise<any> {
+    try {
+      const category = await client.getCategory(params.id);
+      const content =
+        `**Category Details (ID: ${category.id})**\n\n` +
+        `- **Name:** ${category.name}\n` +
+        `- **Slug:** ${category.slug}\n` +
+        `- **Description:** ${category.description || "None"}\n` +
+        `- **Post Count:** ${category.count}`;
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to get category: ${getErrorMessage(error)}`);
+    }
+  }
+
+  public async handleCreateCategory(
+    client: WordPressClient,
+    params: CreateCategoryRequest,
+  ): Promise<any> {
+    try {
+      const category = await client.createCategory(params);
+      return `✅ Category "${category.name}" created successfully with ID: ${category.id}.`;
+    } catch (error) {
+      throw new Error(`Failed to create category: ${getErrorMessage(error)}`);
+    }
+  }
+
+  public async handleUpdateCategory(
+    client: WordPressClient,
+    params: UpdateCategoryRequest & { id: number },
+  ): Promise<any> {
+    try {
+      const category = await client.updateCategory(params);
+      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> {
+    try {
+      await client.deleteCategory(params.id);
+      return `✅ Category ${params.id} has been deleted.`;
+    } catch (error) {
+      throw new Error(`Failed to delete category: ${getErrorMessage(error)}`);
+    }
+  }
+
+  public async handleListTags(
+    client: WordPressClient,
+    params: any,
+  ): Promise<any> {
+    try {
+      const tags = await client.getTags(params);
+      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");
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to list tags: ${getErrorMessage(error)}`);
+    }
+  }
+
+  public async handleGetTag(
+    client: WordPressClient,
+    params: { id: number },
+  ): Promise<any> {
+    try {
+      const tag = await client.getTag(params.id);
+      const content =
+        `**Tag Details (ID: ${tag.id})**\n\n` +
+        `- **Name:** ${tag.name}\n` +
+        `- **Slug:** ${tag.slug}\n` +
+        `- **Post Count:** ${tag.count}`;
+      return content;
+    } catch (error) {
+      throw new Error(`Failed to get tag: ${getErrorMessage(error)}`);
+    }
+  }
+
+  public async handleCreateTag(
+    client: WordPressClient,
+    params: CreateTagRequest,
+  ): Promise<any> {
+    try {
+      const tag = await client.createTag(params);
+      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> {
+    try {
+      const tag = await client.updateTag(params);
+      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> {
+    try {
+      await client.deleteTag(params.id);
+      return `✅ Tag ${params.id} has been deleted.`;
+    } catch (error) {
+      throw new Error(`Failed to delete tag: ${getErrorMessage(error)}`);
+    }
+  }
+}
+
+export default TaxonomyTools;