claude-plugin-wordpress-manager 1.4.0

package/servers/wp-rest-bridge/build/tools/plugins.d.ts

@@ -0,0 +1,153 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const listPluginsSchema: z.ZodObject<{
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<["active", "inactive"]>>>;
+}, "strict", z.ZodTypeAny, {
+    status: "active" | "inactive";
+}, {
+    status?: "active" | "inactive" | undefined;
+}>;
+declare const getPluginSchema: z.ZodObject<{
+    plugin: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    plugin: string;
+}, {
+    plugin: string;
+}>;
+declare const activatePluginSchema: z.ZodObject<{
+    plugin: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    plugin: string;
+}, {
+    plugin: string;
+}>;
+declare const deactivatePluginSchema: z.ZodObject<{
+    plugin: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    plugin: string;
+}, {
+    plugin: string;
+}>;
+declare const createPluginSchema: z.ZodObject<{
+    slug: z.ZodString;
+    status: z.ZodDefault<z.ZodOptional<z.ZodEnum<["inactive", "active"]>>>;
+}, "strict", z.ZodTypeAny, {
+    slug: string;
+    status: "active" | "inactive";
+}, {
+    slug: string;
+    status?: "active" | "inactive" | undefined;
+}>;
+declare const deletePluginSchema: z.ZodObject<{
+    plugin: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    plugin: string;
+}, {
+    plugin: string;
+}>;
+export declare const pluginTools: Tool[];
+export declare const pluginHandlers: {
+    list_plugins: (params: z.infer<typeof listPluginsSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    get_plugin: (params: z.infer<typeof getPluginSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    activate_plugin: (params: z.infer<typeof activatePluginSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    deactivate_plugin: (params: z.infer<typeof deactivatePluginSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    create_plugin: (params: z.infer<typeof createPluginSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    delete_plugin: (params: z.infer<typeof deletePluginSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+};
+export {};

package/servers/wp-rest-bridge/build/tools/plugins.js

@@ -0,0 +1,175 @@
+import { makeWordPressRequest } from '../wordpress.js';
+import { z } from 'zod';
+// Note: Plugin operations require authentication with admin privileges
+// and use a different endpoint than the standard WP API (wp-json/wp/v2/plugins)
+// Make schema empty since the WordPress REST API plugins endpoint doesn't accept parameters
+// in the same way as other endpoints
+const listPluginsSchema = z.object({
+    status: z.enum(['active', 'inactive']).optional().default('active').describe("Filter plugins by status (active, inactive)")
+}).strict();
+const getPluginSchema = z.object({
+    plugin: z.string().describe("Plugin identifier in folder/file.php format (e.g., 'akismet/akismet.php', 'elementor/elementor.php')")
+}).strict();
+const activatePluginSchema = z.object({
+    plugin: z.string().describe("Plugin identifier in folder/file.php format (e.g., 'akismet/akismet.php', 'elementor/elementor.php')")
+}).strict();
+const deactivatePluginSchema = z.object({
+    plugin: z.string().describe("Plugin identifier in folder/file.php format (e.g., 'akismet/akismet.php', 'elementor/elementor.php')")
+}).strict();
+const createPluginSchema = z.object({
+    slug: z.string({ required_error: "Plugin slug is required" }).describe("WordPress.org plugin directory slug, e.g., 'akismet', 'elementor', 'wordpress-seo'"),
+    status: z.enum(['inactive', 'active']).optional().default('active').describe("Plugin activation status")
+}).strict();
+const deletePluginSchema = z.object({
+    plugin: z.string().describe("Plugin identifier in folder/file.php format (e.g., 'akismet/akismet.php')")
+}).strict();
+// Define tool set for plugin operations
+export const pluginTools = [
+    {
+        name: "list_plugins",
+        description: "Lists all plugins with filtering options",
+        inputSchema: { type: "object", properties: listPluginsSchema.shape }
+    },
+    {
+        name: "get_plugin",
+        description: "Retrieves plugin details",
+        inputSchema: { type: "object", properties: getPluginSchema.shape }
+    },
+    {
+        name: "activate_plugin",
+        description: "Activates a plugin",
+        inputSchema: { type: "object", properties: activatePluginSchema.shape }
+    },
+    {
+        name: "deactivate_plugin",
+        description: "Deactivates a plugin",
+        inputSchema: { type: "object", properties: deactivatePluginSchema.shape }
+    },
+    {
+        name: "create_plugin",
+        description: "Creates a plugin from the WordPress.org repository",
+        inputSchema: { type: "object", properties: createPluginSchema.shape }
+    },
+    {
+        name: "delete_plugin",
+        description: "Deletes an installed plugin (must be deactivated first)",
+        inputSchema: { type: "object", properties: deletePluginSchema.shape }
+    }
+];
+// Define handlers for each plugin operation
+export const pluginHandlers = {
+    list_plugins: async (params) => {
+        try {
+            const response = await makeWordPressRequest("GET", "plugins", params);
+            return {
+                toolResult: {
+                    content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: "text", text: `Error listing plugins: ${errorMessage}` }]
+                }
+            };
+        }
+    },
+    get_plugin: async (params) => {
+        try {
+            const response = await makeWordPressRequest("GET", `plugins/${params.plugin}`);
+            return {
+                toolResult: {
+                    content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: "text", text: `Error retrieving plugin: ${errorMessage}` }]
+                }
+            };
+        }
+    },
+    activate_plugin: async (params) => {
+        try {
+            const response = await makeWordPressRequest("PUT", `plugins/${params.plugin}`, { status: 'active' });
+            return {
+                toolResult: {
+                    content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: "text", text: `Error activating plugin: ${errorMessage}` }]
+                }
+            };
+        }
+    },
+    deactivate_plugin: async (params) => {
+        try {
+            const response = await makeWordPressRequest("PUT", `plugins/${params.plugin}`, { status: 'inactive' });
+            return {
+                toolResult: {
+                    content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: "text", text: `Error deactivating plugin: ${errorMessage}` }]
+                }
+            };
+        }
+    },
+    create_plugin: async (params) => {
+        try {
+            const response = await makeWordPressRequest("POST", "plugins", params);
+            return {
+                toolResult: {
+                    content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: "text", text: `Error creating plugin: ${errorMessage}` }]
+                }
+            };
+        }
+    },
+    delete_plugin: async (params) => {
+        try {
+            const response = await makeWordPressRequest("DELETE", `plugins/${params.plugin}`);
+            return {
+                toolResult: {
+                    content: [{ type: "text", text: JSON.stringify(response, null, 2) }]
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: "text", text: `Error deleting plugin: ${errorMessage}` }]
+                }
+            };
+        }
+    }
+};

package/servers/wp-rest-bridge/build/tools/search.d.ts

@@ -0,0 +1,44 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const wpSearchSchema: z.ZodObject<{
+    search: z.ZodString;
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodString>;
+    subtype: z.ZodOptional<z.ZodString>;
+    _embed: z.ZodOptional<z.ZodBoolean>;
+    _fields: z.ZodOptional<z.ZodString>;
+    include_pagination: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    search: string;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    type?: string | undefined;
+    _embed?: boolean | undefined;
+    _fields?: string | undefined;
+    include_pagination?: boolean | undefined;
+    subtype?: string | undefined;
+}, {
+    search: string;
+    page?: number | undefined;
+    per_page?: number | undefined;
+    type?: string | undefined;
+    _embed?: boolean | undefined;
+    _fields?: string | undefined;
+    include_pagination?: boolean | undefined;
+    subtype?: string | undefined;
+}>;
+type WpSearchParams = z.infer<typeof wpSearchSchema>;
+export declare const searchTools: Tool[];
+export declare const searchHandlers: {
+    wp_search: (params: WpSearchParams) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError: boolean;
+        };
+    }>;
+};
+export {};

package/servers/wp-rest-bridge/build/tools/search.js

@@ -0,0 +1,44 @@
+import { makeWordPressRequest } from '../wordpress.js';
+import { z } from 'zod';
+const wpSearchSchema = z.object({
+    search: z.string().describe("Search term to find across all content types"),
+    page: z.number().optional().describe("Page number (default 1)"),
+    per_page: z.number().min(1).max(100).optional().describe("Items per page (default 10, max 100)"),
+    type: z.string().optional().describe("Limit to a specific content type (post, page, etc.)"),
+    subtype: z.string().optional().describe("Limit to a specific subtype"),
+    _embed: z.boolean().optional().describe("Inline related resources"),
+    _fields: z.string().optional().describe("Comma-separated list of fields to return"),
+    include_pagination: z.boolean().optional().describe("Include pagination metadata in response")
+});
+export const searchTools = [
+    {
+        name: "wp_search",
+        description: "Searches across all WordPress content types (posts, pages, custom types) using the native /search endpoint",
+        inputSchema: { type: "object", properties: wpSearchSchema.shape }
+    }
+];
+export const searchHandlers = {
+    wp_search: async (params) => {
+        try {
+            const { include_pagination, ...queryParams } = params;
+            const response = await makeWordPressRequest('GET', 'search', queryParams, {
+                includePagination: include_pagination,
+            });
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+                    isError: false
+                }
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error searching WordPress: ${errorMessage}` }],
+                },
+            };
+        }
+    }
+};