claude-plugin-wordpress-manager 1.4.0

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

@@ -0,0 +1,30 @@
+import { unifiedContentTools, unifiedContentHandlers } from './unified-content.js';
+import { unifiedTaxonomyTools, unifiedTaxonomyHandlers } from './unified-taxonomies.js';
+import { pluginTools, pluginHandlers } from './plugins.js';
+import { mediaTools, mediaHandlers } from './media.js';
+import { userTools, userHandlers } from './users.js';
+import { pluginRepositoryTools, pluginRepositoryHandlers } from './plugin-repository.js';
+import { commentTools, commentHandlers } from './comments.js';
+import { searchTools, searchHandlers } from './search.js';
+// Combine all tools
+export const allTools = [
+    ...unifiedContentTools, // 8 tools
+    ...unifiedTaxonomyTools, // 8 tools
+    ...pluginTools, // 6 tools
+    ...mediaTools, // 5 tools
+    ...userTools, // 6 tools
+    ...pluginRepositoryTools, // 2 tools
+    ...commentTools, // 5 tools
+    ...searchTools // 1 tool
+];
+// Combine all handlers
+export const toolHandlers = {
+    ...unifiedContentHandlers,
+    ...unifiedTaxonomyHandlers,
+    ...pluginHandlers,
+    ...mediaHandlers,
+    ...userHandlers,
+    ...pluginRepositoryHandlers,
+    ...commentHandlers,
+    ...searchHandlers
+};

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

@@ -0,0 +1,174 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const listMediaSchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodNumber>;
+    per_page: z.ZodOptional<z.ZodNumber>;
+    search: z.ZodOptional<z.ZodString>;
+    _embed: z.ZodOptional<z.ZodBoolean>;
+    _fields: z.ZodOptional<z.ZodString>;
+    include_pagination: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search?: string | undefined;
+    _embed?: boolean | undefined;
+    _fields?: string | undefined;
+    include_pagination?: boolean | undefined;
+}, {
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search?: string | undefined;
+    _embed?: boolean | undefined;
+    _fields?: string | undefined;
+    include_pagination?: boolean | undefined;
+}>;
+declare const getMediaSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    _embed: z.ZodOptional<z.ZodBoolean>;
+    _fields: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+    _embed?: boolean | undefined;
+    _fields?: string | undefined;
+}, {
+    id: number;
+    _embed?: boolean | undefined;
+    _fields?: string | undefined;
+}>;
+declare const createMediaSchema: z.ZodObject<{
+    title: z.ZodString;
+    alt_text: z.ZodOptional<z.ZodString>;
+    caption: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    source_url: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    title: string;
+    source_url: string;
+    description?: string | undefined;
+    alt_text?: string | undefined;
+    caption?: string | undefined;
+}, {
+    title: string;
+    source_url: string;
+    description?: string | undefined;
+    alt_text?: string | undefined;
+    caption?: string | undefined;
+}>;
+declare const editMediaSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    title: z.ZodOptional<z.ZodString>;
+    alt_text: z.ZodOptional<z.ZodString>;
+    caption: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+    title?: string | undefined;
+    description?: string | undefined;
+    alt_text?: string | undefined;
+    caption?: string | undefined;
+}, {
+    id: number;
+    title?: string | undefined;
+    description?: string | undefined;
+    alt_text?: string | undefined;
+    caption?: string | undefined;
+}>;
+declare const deleteMediaSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    force: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    id: number;
+    force?: boolean | undefined;
+}, {
+    id: number;
+    force?: boolean | undefined;
+}>;
+export declare const mediaTools: Tool[];
+export declare const mediaHandlers: {
+    list_media: (params: z.infer<typeof listMediaSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    get_media: (params: z.infer<typeof getMediaSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    create_media: (params: z.infer<typeof createMediaSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    edit_media: (params: z.infer<typeof editMediaSchema>) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    delete_media: (params: z.infer<typeof deleteMediaSchema>) => 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/media.js

@@ -0,0 +1,247 @@
+import { makeWordPressRequest } from '../wordpress.js';
+import { z } from 'zod';
+// MIME type to file extension map
+const MIME_EXT_MAP = {
+    'image/jpeg': 'jpg',
+    'image/png': 'png',
+    'image/gif': 'gif',
+    'image/webp': 'webp',
+    'image/svg+xml': 'svg',
+    'image/bmp': 'bmp',
+    'image/tiff': 'tiff',
+    'video/mp4': 'mp4',
+    'video/webm': 'webm',
+    'audio/mpeg': 'mp3',
+    'audio/ogg': 'ogg',
+    'application/pdf': 'pdf',
+};
+function getExtFromMime(contentType) {
+    if (!contentType)
+        return undefined;
+    // Strip charset and params: "image/jpeg; charset=utf-8" → "image/jpeg"
+    const mime = contentType.split(';')[0].trim().toLowerCase();
+    return MIME_EXT_MAP[mime];
+}
+function getExtFromUrl(url) {
+    try {
+        const pathname = new URL(url).pathname;
+        const match = pathname.match(/\.(\w{2,5})$/);
+        return match ? match[1].toLowerCase() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// Schema for listing media items
+const listMediaSchema = z.object({
+    page: z.number().optional().describe("Page number"),
+    per_page: z.number().min(1).max(100).optional().describe("Items per page"),
+    search: z.string().optional().describe("Search term for media"),
+    _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")
+}).strict();
+// Schema for getting a single media item
+const getMediaSchema = z.object({
+    id: z.number().describe("Media ID"),
+    _embed: z.boolean().optional().describe("Inline related resources"),
+    _fields: z.string().optional().describe("Comma-separated list of fields to return")
+}).strict();
+// Schema for creating a new media item
+const createMediaSchema = z.object({
+    title: z.string().describe("Media title"),
+    alt_text: z.string().optional().describe("Alternate text for the media"),
+    caption: z.string().optional().describe("Caption of the media"),
+    description: z.string().optional().describe("Description of the media"),
+    source_url: z.string().describe("Source URL of the media file")
+}).strict();
+// Schema for editing an existing media item
+const editMediaSchema = z.object({
+    id: z.number().describe("Media ID to edit"),
+    title: z.string().optional().describe("Media title"),
+    alt_text: z.string().optional().describe("Alternate text for the media"),
+    caption: z.string().optional().describe("Caption of the media"),
+    description: z.string().optional().describe("Description of the media")
+}).strict();
+// Schema for deleting a media item
+const deleteMediaSchema = z.object({
+    id: z.number().describe("Media ID to delete"),
+    force: z.boolean().optional().describe("Force deletion bypassing trash")
+}).strict();
+// Define the tool set for media operations
+export const mediaTools = [
+    {
+        name: "list_media",
+        description: "Lists media items with filtering and pagination options",
+        inputSchema: { type: "object", properties: listMediaSchema.shape }
+    },
+    {
+        name: "get_media",
+        description: "Gets a single media item by ID",
+        inputSchema: { type: "object", properties: getMediaSchema.shape }
+    },
+    {
+        name: "create_media",
+        description: "Creates a new media item",
+        inputSchema: { type: "object", properties: createMediaSchema.shape }
+    },
+    {
+        name: "edit_media",
+        description: "Updates an existing media item",
+        inputSchema: { type: "object", properties: editMediaSchema.shape }
+    },
+    {
+        name: "delete_media",
+        description: "Deletes a media item",
+        inputSchema: { type: "object", properties: deleteMediaSchema.shape }
+    }
+];
+// Define handlers for each media operation
+export const mediaHandlers = {
+    list_media: async (params) => {
+        try {
+            const { include_pagination, ...queryParams } = params;
+            const response = await makeWordPressRequest("GET", "media", queryParams, {
+                includePagination: include_pagination,
+            });
+            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 media: ${errorMessage}` }]
+                }
+            };
+        }
+    },
+    get_media: async (params) => {
+        try {
+            const queryParams = {};
+            if (params._embed)
+                queryParams._embed = true;
+            if (params._fields)
+                queryParams._fields = params._fields;
+            const response = await makeWordPressRequest("GET", `media/${params.id}`, queryParams);
+            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 getting media: ${errorMessage}` }]
+                }
+            };
+        }
+    },
+    create_media: async (params) => {
+        try {
+            if (params.source_url && params.source_url.startsWith('http')) {
+                // Download the media file from the URL and upload as multipart form-data
+                const axios = (await import('axios')).default;
+                const FormData = (await import('form-data')).default;
+                const fileRes = await axios.get(params.source_url, { responseType: 'arraybuffer' });
+                // Derive extension from content-type header or source URL
+                const ext = getExtFromMime(fileRes.headers['content-type'])
+                    || getExtFromUrl(params.source_url)
+                    || 'jpg';
+                const basename = params.title ? params.title.replace(/\s+/g, '_') : 'upload';
+                const filename = `${basename}.${ext}`;
+                const form = new FormData();
+                form.append('file', Buffer.from(fileRes.data), {
+                    filename: filename,
+                    contentType: fileRes.headers['content-type'] || 'application/octet-stream'
+                });
+                // Append additional fields if provided
+                if (params.title)
+                    form.append('title', params.title);
+                if (params.alt_text)
+                    form.append('alt_text', params.alt_text);
+                if (params.caption)
+                    form.append('caption', params.caption);
+                if (params.description)
+                    form.append('description', params.description);
+                // Use the enhanced makeWordPressRequest function with FormData support
+                // Media uploads get a longer timeout (120s)
+                const response = await makeWordPressRequest('POST', 'media', form, {
+                    isFormData: true,
+                    headers: form.getHeaders(),
+                    rawResponse: true,
+                    timeout: 120000
+                });
+                return {
+                    toolResult: {
+                        content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }]
+                    }
+                };
+            }
+            else {
+                const response = await makeWordPressRequest("POST", "media", 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 media: ${errorMessage}` }]
+                }
+            };
+        }
+    },
+    edit_media: async (params) => {
+        try {
+            const { id, ...updateData } = params;
+            const response = await makeWordPressRequest("POST", `media/${id}`, updateData);
+            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 editing media: ${errorMessage}` }]
+                }
+            };
+        }
+    },
+    delete_media: async (params) => {
+        try {
+            const { id, ...deleteData } = params;
+            const response = await makeWordPressRequest("DELETE", `media/${id}`, deleteData);
+            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 media: ${errorMessage}` }]
+                }
+            };
+        }
+    }
+};

package/servers/wp-rest-bridge/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/servers/wp-rest-bridge/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}` }],
+                },
+            };
+        }
+    }
+};