@wplaunchify/ml-mcp-server 1.0.0

package/build/tools/fluent-community-MINIMAL.d.ts

@@ -0,0 +1,69 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const listPostsSchema: z.ZodObject<{
+    space_id: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    space_id?: number | undefined;
+    limit?: number | undefined;
+}, {
+    space_id?: number | undefined;
+    limit?: number | undefined;
+}>;
+declare const listSpacesSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    search: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
+    limit?: number | undefined;
+}, {
+    search?: string | undefined;
+    limit?: number | undefined;
+}>;
+declare const createPostSchema: z.ZodObject<{
+    space_id: z.ZodNumber;
+    user_id: z.ZodNumber;
+    message: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    space_id: number;
+    user_id: number;
+}, {
+    message: string;
+    space_id: number;
+    user_id: number;
+}>;
+type ListPostsParams = z.infer<typeof listPostsSchema>;
+type ListSpacesParams = z.infer<typeof listSpacesSchema>;
+type CreatePostParams = z.infer<typeof createPostSchema>;
+export declare const fluentCommunityTools: Tool[];
+export declare const fluentCommunityHandlers: {
+    fc_list_posts: (params: ListPostsParams) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError: boolean;
+        };
+    }>;
+    fc_list_spaces: (params: ListSpacesParams) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError: boolean;
+        };
+    }>;
+    fc_create_post: (params: CreatePostParams) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError: boolean;
+        };
+    }>;
+};
+export {};

package/build/tools/fluent-community-MINIMAL.js

@@ -0,0 +1,92 @@
+import { makeWordPressRequest } from '../wordpress.js';
+import { z } from 'zod';
+// Zod Schema Definitions
+const listPostsSchema = z.object({
+    space_id: z.number().optional().describe('Filter posts by space ID'),
+    limit: z.number().optional().describe('Number of posts to return')
+});
+const listSpacesSchema = z.object({
+    limit: z.number().optional().describe('Number of spaces to return'),
+    search: z.string().optional().describe('Search term')
+});
+const createPostSchema = z.object({
+    space_id: z.number().describe('The space ID where the post will be created'),
+    user_id: z.number().describe('The user ID who creates the post'),
+    message: z.string().describe('Post content/message')
+});
+export const fluentCommunityTools = [
+    {
+        name: 'fc_list_posts',
+        description: 'List all posts from FluentCommunity with optional filtering',
+        inputSchema: { type: 'object', properties: listPostsSchema.shape }
+    },
+    {
+        name: 'fc_list_spaces',
+        description: 'List all spaces in FluentCommunity',
+        inputSchema: { type: 'object', properties: listSpacesSchema.shape }
+    },
+    {
+        name: 'fc_create_post',
+        description: 'Create a new post in FluentCommunity',
+        inputSchema: { type: 'object', properties: createPostSchema.shape }
+    }
+];
+export const fluentCommunityHandlers = {
+    fc_list_posts: async (params) => {
+        try {
+            const response = await makeWordPressRequest('GET', 'fc-manager/v1/posts', params);
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+                    isError: false
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: `Error listing posts: ${error.message}` }],
+                    isError: true
+                }
+            };
+        }
+    },
+    fc_list_spaces: async (params) => {
+        try {
+            const response = await makeWordPressRequest('GET', 'fc-manager/v1/spaces', params);
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+                    isError: false
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: `Error listing spaces: ${error.message}` }],
+                    isError: true
+                }
+            };
+        }
+    },
+    fc_create_post: async (params) => {
+        try {
+            const response = await makeWordPressRequest('POST', 'fc-manager/v1/posts', params);
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+                    isError: false
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    content: [{ type: 'text', text: `Error creating post: ${error.message}` }],
+                    isError: true
+                }
+            };
+        }
+    }
+};

package/build/tools/fluent-community-design.d.ts

@@ -0,0 +1,3 @@
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+export declare const fluentCommunityDesignTools: Tool[];
+export declare const fluentCommunityDesignHandlers: Record<string, (args: any) => Promise<any>>;

package/build/tools/fluent-community-design.js

@@ -0,0 +1,150 @@
+import { z } from 'zod';
+import { makeWordPressRequest } from '../wordpress.js';
+// ==================== ZOD SCHEMA DEFINITIONS ====================
+const getColorsSchema = z.object({
+    mode: z.enum(['light', 'dark']).optional().default('light').describe('Color mode (light or dark)')
+});
+const updateColorsSchema = z.object({
+    mode: z.enum(['light', 'dark']).optional().default('light').describe('Color mode (light or dark)'),
+    colors: z.object({
+        navbar_bg: z.string().optional().describe('Navbar background color (hex)'),
+        navbar_text: z.string().optional().describe('Navbar text color (hex)'),
+        sidebar_bg: z.string().optional().describe('Sidebar background color (hex)'),
+        sidebar_text: z.string().optional().describe('Sidebar text color (hex)'),
+        feed_bg: z.string().optional().describe('Feed background color (hex)'),
+        button_primary: z.string().optional().describe('Primary button color (hex)'),
+        button_secondary: z.string().optional().describe('Secondary button color (hex)'),
+        link_color: z.string().optional().describe('Link color (hex)'),
+        accent_color: z.string().optional().describe('Accent color (hex)')
+    }).describe('Color values to update')
+});
+const updatePortalSettingsSchema = z.object({
+    settings: z.object({
+        dark_mode_enabled: z.boolean().optional().describe('Enable dark mode'),
+        sticky_header: z.boolean().optional().describe('Enable sticky header'),
+        post_layout: z.enum(['card', 'list', 'grid']).optional().describe('Post layout style'),
+        sidebar_position: z.enum(['left', 'right']).optional().describe('Sidebar position'),
+        show_member_count: z.boolean().optional().describe('Show member count'),
+        show_post_count: z.boolean().optional().describe('Show post count'),
+        enable_reactions: z.boolean().optional().describe('Enable post reactions'),
+        enable_comments: z.boolean().optional().describe('Enable comments')
+    }).describe('Portal settings to update')
+});
+const updateBrandingSchema = z.object({
+    branding: z.object({
+        logo_url: z.string().optional().describe('Logo URL'),
+        logo_width: z.number().optional().describe('Logo width in pixels'),
+        favicon_url: z.string().optional().describe('Favicon URL'),
+        site_title: z.string().optional().describe('Site title'),
+        site_tagline: z.string().optional().describe('Site tagline'),
+        custom_css: z.string().optional().describe('Custom CSS code'),
+        custom_header_code: z.string().optional().describe('Custom header HTML/JS'),
+        custom_footer_code: z.string().optional().describe('Custom footer HTML/JS')
+    }).describe('Branding data to update')
+});
+// ==================== TOOL DEFINITIONS ====================
+export const fluentCommunityDesignTools = [
+    {
+        name: 'fc_get_colors',
+        description: 'Get FluentCommunity color scheme (light or dark mode)',
+        inputSchema: { type: 'object', properties: getColorsSchema.shape }
+    },
+    {
+        name: 'fc_update_colors',
+        description: 'Update FluentCommunity color scheme for light or dark mode',
+        inputSchema: { type: 'object', properties: updateColorsSchema.shape }
+    },
+    {
+        name: 'fc_get_portal_settings',
+        description: 'Get FluentCommunity portal display settings',
+        inputSchema: { type: 'object', properties: {} }
+    },
+    {
+        name: 'fc_update_portal_settings',
+        description: 'Update FluentCommunity portal display settings (layout, sidebar, features)',
+        inputSchema: { type: 'object', properties: updatePortalSettingsSchema.shape }
+    },
+    {
+        name: 'fc_get_branding',
+        description: 'Get FluentCommunity branding settings (logo, favicon, custom CSS)',
+        inputSchema: { type: 'object', properties: {} }
+    },
+    {
+        name: 'fc_update_branding',
+        description: 'Update FluentCommunity branding (logo, favicon, custom CSS/HTML)',
+        inputSchema: { type: 'object', properties: updateBrandingSchema.shape }
+    }
+];
+// ==================== TOOL HANDLERS ====================
+export const fluentCommunityDesignHandlers = {
+    fc_get_colors: async (args) => {
+        try {
+            // Use FluentCommunity's NATIVE color-config endpoint
+            const response = await makeWordPressRequest('GET', 'fluent-community/v2/settings/color-config');
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_update_colors: async (args) => {
+        try {
+            // Use FluentCommunity's NATIVE color-config endpoint
+            const data = {
+                mode: args.mode || 'light',
+                colors: args.colors
+            };
+            const response = await makeWordPressRequest('POST', 'fluent-community/v2/settings/color-config', data);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_get_portal_settings: async (args) => {
+        try {
+            // Use FluentCommunity's NATIVE customization-settings endpoint
+            const response = await makeWordPressRequest('GET', 'fluent-community/v2/settings/customization-settings');
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_update_portal_settings: async (args) => {
+        try {
+            // Use FluentCommunity's NATIVE customization-settings endpoint
+            const data = {
+                settings: args.settings
+            };
+            const response = await makeWordPressRequest('POST', 'fluent-community/v2/settings/customization-settings', data);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_get_branding: async (args) => {
+        try {
+            // Use FluentCommunity's NATIVE customization-settings endpoint (branding is part of customization)
+            const response = await makeWordPressRequest('GET', 'fluent-community/v2/settings/customization-settings');
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    },
+    fc_update_branding: async (args) => {
+        try {
+            // Use FluentCommunity's NATIVE customization-settings endpoint (branding is part of customization)
+            const data = {
+                branding: args.branding
+            };
+            const response = await makeWordPressRequest('POST', 'fluent-community/v2/settings/customization-settings', data);
+            return { toolResult: { content: [{ type: 'text', text: JSON.stringify(response, null, 2) }] } };
+        }
+        catch (error) {
+            return { toolResult: { isError: true, content: [{ type: 'text', text: `Error: ${error.message}` }] } };
+        }
+    }
+};

package/build/tools/fluent-community-layout.d.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+export declare const fluentCommunityLayoutTools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            layout: z.ZodObject<{
+                menu_position: z.ZodOptional<z.ZodEnum<["top", "side"]>>;
+                sidebar_position: z.ZodOptional<z.ZodEnum<["left", "right"]>>;
+                hide_members_list: z.ZodOptional<z.ZodBoolean>;
+                hide_spaces_list: z.ZodOptional<z.ZodBoolean>;
+                hide_activity_feed: z.ZodOptional<z.ZodBoolean>;
+                hide_search: z.ZodOptional<z.ZodBoolean>;
+                custom_header_content: z.ZodOptional<z.ZodString>;
+                custom_sidebar_content: z.ZodOptional<z.ZodString>;
+                custom_footer_content: z.ZodOptional<z.ZodString>;
+                hide_home_feed: z.ZodOptional<z.ZodBoolean>;
+                custom_home_content: z.ZodOptional<z.ZodString>;
+                home_feed_label: z.ZodOptional<z.ZodString>;
+                embed_post_id: z.ZodOptional<z.ZodNumber>;
+                social_links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    platform: z.ZodString;
+                    url: z.ZodString;
+                    icon: z.ZodOptional<z.ZodString>;
+                }, "strip", z.ZodTypeAny, {
+                    url: string;
+                    platform: string;
+                    icon?: string | undefined;
+                }, {
+                    url: string;
+                    platform: string;
+                    icon?: string | undefined;
+                }>, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                sidebar_position?: "left" | "right" | undefined;
+                menu_position?: "top" | "side" | undefined;
+                hide_members_list?: boolean | undefined;
+                hide_spaces_list?: boolean | undefined;
+                hide_activity_feed?: boolean | undefined;
+                hide_search?: boolean | undefined;
+                custom_header_content?: string | undefined;
+                custom_sidebar_content?: string | undefined;
+                custom_footer_content?: string | undefined;
+                hide_home_feed?: boolean | undefined;
+                custom_home_content?: string | undefined;
+                home_feed_label?: string | undefined;
+                embed_post_id?: number | undefined;
+                social_links?: {
+                    url: string;
+                    platform: string;
+                    icon?: string | undefined;
+                }[] | undefined;
+            }, {
+                sidebar_position?: "left" | "right" | undefined;
+                menu_position?: "top" | "side" | undefined;
+                hide_members_list?: boolean | undefined;
+                hide_spaces_list?: boolean | undefined;
+                hide_activity_feed?: boolean | undefined;
+                hide_search?: boolean | undefined;
+                custom_header_content?: string | undefined;
+                custom_sidebar_content?: string | undefined;
+                custom_footer_content?: string | undefined;
+                hide_home_feed?: boolean | undefined;
+                custom_home_content?: string | undefined;
+                home_feed_label?: string | undefined;
+                embed_post_id?: number | undefined;
+                social_links?: {
+                    url: string;
+                    platform: string;
+                    icon?: string | undefined;
+                }[] | undefined;
+            }>;
+        };
+    };
+})[];
+export declare const fluentCommunityLayoutHandlers: {
+    fc_get_layout: (args: any) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+    fc_update_layout: (args: any) => Promise<{
+        toolResult: {
+            content: {
+                type: string;
+                text: string;
+            }[];
+            isError?: undefined;
+        };
+    } | {
+        toolResult: {
+            isError: boolean;
+            content: {
+                type: string;
+                text: string;
+            }[];
+        };
+    }>;
+};

package/build/tools/fluent-community-layout.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { makeWordPressRequest } from '../wordpress.js';
+// Layout Control Tools for FluentCommunity Manager
+export const fluentCommunityLayoutTools = [
+    {
+        name: 'fc_get_layout',
+        description: 'Get FluentCommunity layout settings (menu position, sidebar placement, component visibility, content injection)',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    {
+        name: 'fc_update_layout',
+        description: 'Update FluentCommunity layout settings. Control menu positioning (top/side), sidebar placement (left/right), component visibility (hide/show members, spaces, etc.), and inject custom content (header, sidebar, footer with HTML/shortcodes)',
+        inputSchema: { type: 'object', properties: z.object({
+                layout: z.object({
+                    menu_position: z.enum(['top', 'side']).optional().describe('Menu position: top or side'),
+                    sidebar_position: z.enum(['left', 'right']).optional().describe('Sidebar position: left or right'),
+                    hide_members_list: z.boolean().optional().describe('Hide members list component'),
+                    hide_spaces_list: z.boolean().optional().describe('Hide spaces list component'),
+                    hide_activity_feed: z.boolean().optional().describe('Hide activity feed component'),
+                    hide_search: z.boolean().optional().describe('Hide search component'),
+                    custom_header_content: z.string().optional().describe('Custom header content (HTML/shortcodes)'),
+                    custom_sidebar_content: z.string().optional().describe('Custom sidebar content (HTML/shortcodes)'),
+                    custom_footer_content: z.string().optional().describe('Custom footer content (HTML/shortcodes)'),
+                    hide_home_feed: z.boolean().optional().describe('Hide the default home feed'),
+                    custom_home_content: z.string().optional().describe('Custom home page content (HTML/shortcodes)'),
+                    home_feed_label: z.string().optional().describe('Custom label for home feed'),
+                    embed_post_id: z.number().optional().describe('Post ID to embed on home page'),
+                    social_links: z.array(z.object({
+                        platform: z.string().describe('Social platform name (e.g., twitter, linkedin, github)'),
+                        url: z.string().describe('Profile URL'),
+                        icon: z.string().optional().describe('Icon class or SVG'),
+                    })).optional().describe('Social profile links for user profiles'),
+                }).describe('Layout settings object'),
+            }).shape },
+    },
+];
+export const fluentCommunityLayoutHandlers = {
+    fc_get_layout: async (args) => {
+        try {
+            const response = await makeWordPressRequest('GET', 'fc-manager/v1/settings/layout');
+            return {
+                toolResult: {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(response, null, 2)
+                        }]
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{
+                            type: 'text',
+                            text: `Error getting layout settings: ${error.message}`
+                        }]
+                }
+            };
+        }
+    },
+    fc_update_layout: async (args) => {
+        try {
+            const response = await makeWordPressRequest('PUT', 'fc-manager/v1/settings/layout', {
+                layout: args.layout
+            });
+            return {
+                toolResult: {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(response, null, 2)
+                        }]
+                }
+            };
+        }
+        catch (error) {
+            return {
+                toolResult: {
+                    isError: true,
+                    content: [{
+                            type: 'text',
+                            text: `Error updating layout settings: ${error.message}`
+                        }]
+                }
+            };
+        }
+    },
+};