@wplaunchify/ml-mcp-server 1.0.0

package/build/tools/index.js

@@ -0,0 +1,54 @@
+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 { fluentCommunityTools, fluentCommunityHandlers } from './fluent-community.js';
+import { fluentCommunityDesignTools, fluentCommunityDesignHandlers } from './fluent-community-design.js';
+import { fluentCommunityLayoutTools, fluentCommunityLayoutHandlers } from './fluent-community-layout.js';
+import { fluentCartTools, fluentCartHandlers } from './fluent-cart.js';
+import { fluentCRMTools, fluentCRMHandlers } from './fluent-crm.js';
+import { mlCanvasTools, mlCanvasHandlers } from './ml-canvas.js';
+import { mlImageEditorTools, mlImageEditorHandlers } from './ml-image-editor.js';
+import { fluentAffiliateTools, fluentAffiliateHandlers } from './fluent-affiliate.js';
+import { mlMediaHubTools, mlMediaHubHandlers } from './ml-media-hub.js';
+// Combine all tools - WordPress + FluentCommunity + FluentCRM + FluentCart + ML Plugins = 145 tools
+export const allTools = [
+    ...unifiedContentTools, // 8 tools (unified content management)
+    ...unifiedTaxonomyTools, // 8 tools (unified taxonomy management)
+    ...pluginTools, // 5 tools (WordPress plugin management)
+    ...mediaTools, // 4 tools (WordPress media library)
+    ...userTools, // 5 tools (WordPress user management)
+    ...pluginRepositoryTools, // 2 tools (WordPress.org plugin repository)
+    ...commentTools, // 5 tools (WordPress comments)
+    ...fluentCommunityTools, // 21 tools (FluentCommunity spaces, posts, members)
+    ...fluentCommunityDesignTools, // 6 tools (FluentCommunity colors, branding, CSS)
+    ...fluentCommunityLayoutTools, // 2 tools (FluentCommunity layout control)
+    ...fluentCRMTools, // 19 tools (FluentCRM contacts, lists, campaigns)
+    ...fluentCartTools, // 31 tools (FluentCart products, orders, customers)
+    ...fluentAffiliateTools, // 0 tools (FluentAffiliate - coming soon)
+    ...mlCanvasTools, // 3 tools (ML Canvas Block surgical HTML editing)
+    ...mlImageEditorTools, // 8 tools (ML Image Editor AI generation/editing)
+    ...mlMediaHubTools // 18 tools (ML Media Hub: basic + advanced search/filters)
+];
+// Combine all handlers
+export const toolHandlers = {
+    ...unifiedContentHandlers,
+    ...unifiedTaxonomyHandlers,
+    ...pluginHandlers,
+    ...mediaHandlers,
+    ...userHandlers,
+    ...pluginRepositoryHandlers,
+    ...commentHandlers,
+    ...fluentCommunityHandlers,
+    ...fluentCommunityDesignHandlers,
+    ...fluentCommunityLayoutHandlers,
+    ...fluentCRMHandlers,
+    ...fluentCartHandlers,
+    ...fluentAffiliateHandlers,
+    ...mlCanvasHandlers,
+    ...mlImageEditorHandlers,
+    ...mlMediaHubHandlers
+};

package/build/tools/media.d.ts

@@ -0,0 +1,135 @@
+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>;
+}, "strict", z.ZodTypeAny, {
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search?: string | undefined;
+}, {
+    page?: number | undefined;
+    per_page?: number | undefined;
+    search?: 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;
+            }[];
+        };
+    }>;
+    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/build/tools/media.js

@@ -0,0 +1,168 @@
+import { makeWordPressRequest } from '../wordpress.js';
+import { z } from 'zod';
+// 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")
+}).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: "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 response = await makeWordPressRequest("GET", "wp/v2/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 listing 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 a filename from the title or fallback
+                const filename = params.title ? `${params.title.replace(/\s+/g, '_')}.jpg` : 'upload.jpg';
+                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
+                const response = await makeWordPressRequest('POST', 'wp/v2/media', form, {
+                    isFormData: true,
+                    headers: form.getHeaders(),
+                    rawResponse: true
+                });
+                return {
+                    toolResult: {
+                        content: [{ type: "text", text: JSON.stringify(response.data, null, 2) }]
+                    }
+                };
+            }
+            else {
+                const response = await makeWordPressRequest("POST", "wp/v2/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", `wp/v2/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", `wp/v2/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/build/tools/ml-canvas.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+export declare const mlCanvasTools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            title: z.ZodString;
+            html: z.ZodOptional<z.ZodString>;
+            css: z.ZodOptional<z.ZodString>;
+            hideHeader: z.ZodOptional<z.ZodBoolean>;
+            hideFooter: z.ZodOptional<z.ZodBoolean>;
+            canvasMode: z.ZodOptional<z.ZodBoolean>;
+            hideTitle: z.ZodOptional<z.ZodBoolean>;
+            status: z.ZodOptional<z.ZodEnum<["draft", "publish"]>>;
+        };
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            page_id: z.ZodNumber;
+            find_html: z.ZodOptional<z.ZodString>;
+            replace_html: z.ZodOptional<z.ZodString>;
+            find_css: z.ZodOptional<z.ZodString>;
+            replace_css: z.ZodOptional<z.ZodString>;
+        };
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+    };
+})[];
+export declare const mlCanvasHandlers: {
+    mlcanvas_create_page: (args: any) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    mlcanvas_edit_page: (args: any) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    mlcanvas_get_docs: (args: any) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+};

package/build/tools/ml-canvas.js

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+import { makeWordPressRequest } from '../wordpress.js';
+// ML Canvas Block Tools - Custom HTML/CSS Page Creation & Surgical Editing
+export const mlCanvasTools = [
+    {
+        name: 'mlcanvas_create_page',
+        description: 'Create a custom HTML/CSS page using ML Canvas Block. Perfect for landing pages, full-width designs, and custom layouts. No block recovery needed!',
+        inputSchema: { type: 'object', properties: z.object({
+                title: z.string().describe('Page title (required)'),
+                html: z.string().optional().describe('Custom HTML content'),
+                css: z.string().optional().describe('Custom CSS styles'),
+                hideHeader: z.boolean().optional().describe('Hide site header'),
+                hideFooter: z.boolean().optional().describe('Hide site footer'),
+                canvasMode: z.boolean().optional().describe('Full-width canvas mode (100% width, zero padding)'),
+                hideTitle: z.boolean().optional().describe('Hide page title/hero section'),
+                status: z.enum(['draft', 'publish']).optional().describe('Page status (default: draft)'),
+            }).shape },
+    },
+    {
+        name: 'mlcanvas_edit_page',
+        description: 'Surgical editing for ML Canvas pages - find/replace specific HTML/CSS snippets without rewriting entire page. Works on ANY post type with ML Canvas block.',
+        inputSchema: { type: 'object', properties: z.object({
+                page_id: z.number().describe('Page/Post ID to edit (required)'),
+                find_html: z.string().optional().describe('HTML string to find and replace'),
+                replace_html: z.string().optional().describe('New HTML to replace with'),
+                find_css: z.string().optional().describe('CSS string to find and replace'),
+                replace_css: z.string().optional().describe('New CSS to replace with'),
+            }).shape },
+    },
+    {
+        name: 'mlcanvas_get_docs',
+        description: 'Get ML Canvas Block API documentation',
+        inputSchema: { type: 'object', properties: {} },
+    },
+];
+export const mlCanvasHandlers = {
+    mlcanvas_create_page: async (args) => {
+        try {
+            const response = await makeWordPressRequest('POST', 'fc-manager/v1/canvas/create-page', args);
+            return {
+                toolResult: {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(response, null, 2)
+                        }]
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{
+                            type: 'text',
+                            text: `Error creating canvas page: ${error.message}`
+                        }]
+                }
+            };
+        }
+    },
+    mlcanvas_edit_page: async (args) => {
+        try {
+            const response = await makeWordPressRequest('POST', 'fc-manager/v1/canvas/edit-page', args);
+            return {
+                toolResult: {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(response, null, 2)
+                        }]
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{
+                            type: 'text',
+                            text: `Error editing canvas page: ${error.message}`
+                        }]
+                }
+            };
+        }
+    },
+    mlcanvas_get_docs: async (args) => {
+        try {
+            const response = await makeWordPressRequest('GET', 'fc-manager/v1/canvas/api-docs');
+            return {
+                toolResult: {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(response, null, 2)
+                        }]
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{
+                            type: 'text',
+                            text: `Error getting canvas docs: ${error.message}`
+                        }]
+                }
+            };
+        }
+    },
+};