@wplaunchify/ml-mcp-server 1.0.0

package/build/tools/plugin-repository.d.ts

@@ -0,0 +1,62 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const searchPluginRepositorySchema: z.ZodObject<{
+    search: z.ZodString;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    per_page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    page: number;
+    per_page: number;
+    search: string;
+}, {
+    search: string;
+    page?: number | undefined;
+    per_page?: number | undefined;
+}>;
+declare const getPluginDetailsSchema: z.ZodObject<{
+    slug: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    slug: string;
+}, {
+    slug: string;
+}>;
+type SearchPluginRepositoryParams = z.infer<typeof searchPluginRepositorySchema>;
+type GetPluginDetailsParams = z.infer<typeof getPluginDetailsSchema>;
+export declare const pluginRepositoryTools: Tool[];
+export declare const pluginRepositoryHandlers: {
+    search_plugin_repository: (params: SearchPluginRepositoryParams) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    get_plugin_details: (params: GetPluginDetailsParams) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+};
+export {};

package/build/tools/plugin-repository.js

@@ -0,0 +1,149 @@
+import { searchWordPressPluginRepository } from '../wordpress.js';
+import { z } from 'zod';
+// Define the schema for plugin repository search
+const searchPluginRepositorySchema = z.object({
+    search: z.string().describe("Search query for WordPress.org plugin repository"),
+    page: z.number().min(1).optional().default(1).describe("Page number (1-based)"),
+    per_page: z.number().min(1).max(100).optional().default(10).describe("Number of results per page (max 100)")
+}).strict();
+// Define the schema for getting plugin details
+const getPluginDetailsSchema = z.object({
+    slug: z.string().describe("Plugin slug from WordPress.org repository")
+}).strict();
+// Define the plugin repository tools
+export const pluginRepositoryTools = [
+    {
+        name: "search_plugin_repository",
+        description: "Search for plugins in the WordPress.org plugin repository",
+        inputSchema: { type: "object", properties: searchPluginRepositorySchema.shape }
+    },
+    {
+        name: "get_plugin_details",
+        description: "Get detailed information about a plugin from the WordPress.org repository",
+        inputSchema: { type: "object", properties: getPluginDetailsSchema.shape }
+    }
+];
+// Define handlers for plugin repository operations
+export const pluginRepositoryHandlers = {
+    search_plugin_repository: async (params) => {
+        try {
+            const response = await searchWordPressPluginRepository(params.search, params.page, params.per_page);
+            // Format the response to be more user-friendly
+            const formattedPlugins = response.plugins.map((plugin) => ({
+                name: plugin.name,
+                slug: plugin.slug,
+                version: plugin.version,
+                author: plugin.author,
+                requires_wp: plugin.requires,
+                tested: plugin.tested,
+                rating: plugin.rating,
+                active_installs: plugin.active_installs,
+                downloaded: plugin.downloaded,
+                last_updated: plugin.last_updated,
+                short_description: plugin.short_description,
+                download_link: plugin.download_link,
+                homepage: plugin.homepage
+            }));
+            const result = {
+                info: {
+                    page: response.info.page,
+                    pages: response.info.pages,
+                    results: response.info.results
+                },
+                plugins: formattedPlugins
+            };
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error searching plugin repository: ${errorMessage}` }],
+                },
+            };
+        }
+    },
+    get_plugin_details: async (params) => {
+        try {
+            // For plugin details, we use a different action in the WordPress.org API
+            const apiUrl = 'https://api.wordpress.org/plugins/info/1.2/';
+            const requestData = {
+                action: 'plugin_information',
+                request: {
+                    slug: params.slug,
+                    fields: {
+                        description: true,
+                        sections: true,
+                        tested: true,
+                        requires: true,
+                        rating: true,
+                        ratings: true,
+                        downloaded: true,
+                        downloadlink: true,
+                        last_updated: true,
+                        homepage: true,
+                        tags: true,
+                        compatibility: true,
+                        author: true,
+                        contributors: true,
+                        banners: true,
+                        icons: true
+                    }
+                }
+            };
+            // Use axios directly for this specific request
+            const axios = (await import('axios')).default;
+            const response = await axios.post(apiUrl, requestData, {
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+            // Format the plugin details
+            const plugin = response.data;
+            const formattedPlugin = {
+                name: plugin.name,
+                slug: plugin.slug,
+                version: plugin.version,
+                author: plugin.author,
+                author_profile: plugin.author_profile,
+                contributors: plugin.contributors,
+                requires_wp: plugin.requires,
+                tested: plugin.tested,
+                requires_php: plugin.requires_php,
+                rating: plugin.rating,
+                ratings: plugin.ratings,
+                active_installs: plugin.active_installs,
+                downloaded: plugin.downloaded,
+                last_updated: plugin.last_updated,
+                added: plugin.added,
+                homepage: plugin.homepage,
+                description: plugin.description,
+                short_description: plugin.short_description,
+                download_link: plugin.download_link,
+                tags: plugin.tags,
+                sections: plugin.sections,
+                banners: plugin.banners,
+                icons: plugin.icons
+            };
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(formattedPlugin, null, 2) }],
+                },
+            };
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.message || error.message;
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{ type: 'text', text: `Error getting plugin details: ${errorMessage}` }],
+                },
+            };
+        }
+    }
+};

package/build/tools/plugins.d.ts

@@ -0,0 +1,129 @@
+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;
+}>;
+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;
+            }[];
+        };
+    }>;
+};
+export {};

package/build/tools/plugins.js

@@ -0,0 +1,148 @@
+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 slug (e.g., 'akismet', 'elementor', 'wordpress-seo')")
+}).strict();
+const activatePluginSchema = z.object({
+    plugin: z.string().describe("Plugin slug (e.g., 'akismet', 'elementor', 'wordpress-seo')")
+}).strict();
+const deactivatePluginSchema = z.object({
+    plugin: z.string().describe("Plugin slug (e.g., 'akismet', 'elementor', 'wordpress-seo')")
+}).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();
+// 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 }
+    }
+];
+// Define handlers for each plugin operation
+export const pluginHandlers = {
+    list_plugins: async (params) => {
+        try {
+            const response = await makeWordPressRequest("GET", "wp/v2/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", `wp/v2/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("POST", `wp/v2/plugins/${params.plugin}/activate`, 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 activating plugin: ${errorMessage}` }]
+                }
+            };
+        }
+    },
+    deactivate_plugin: async (params) => {
+        try {
+            const response = await makeWordPressRequest("POST", `wp/v2/plugins/${params.plugin}/deactivate`, 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 deactivating plugin: ${errorMessage}` }]
+                }
+            };
+        }
+    },
+    create_plugin: async (params) => {
+        try {
+            const response = await makeWordPressRequest("POST", "wp/v2/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}` }]
+                }
+            };
+        }
+    }
+};