@wplaunchify/ml-mcp-server 2.5.6 → 2.5.7

package/build/server.js

@@ -5,7 +5,6 @@ import * as dotenv from 'dotenv';
 dotenv.config({ path: '.env' });
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { allTools, toolHandlers } from './tools/index.js';
 import { z } from 'zod';
 // Generate server name from WordPress URL
 function generateServerName() {
@@ -40,66 +39,50 @@ function generateServerName() {
         return 'wordpress';
     }
 }
-// Create MCP server instance
-const server = new McpServer({
-    name: generateServerName(),
-    version: "1.0.7"
-}, {
-    capabilities: {
-        tools: allTools.reduce((acc, tool) => {
-            acc[tool.name] = tool;
-            return acc;
-        }, {})
-    }
-});
-// Register each tool from our tools list with its corresponding handler
-let registeredCount = 0;
-for (const tool of allTools) {
-    const handler = toolHandlers[tool.name];
-    if (!handler) {
-        console.error(`⚠️  No handler for tool: ${tool.name}`);
-        continue;
-    }
-    const wrappedHandler = async (args) => {
-        try {
-            // The handler functions are already typed with their specific parameter types
-            const result = await handler(args);
-            return {
-                content: result.toolResult.content.map((item) => ({
-                    ...item,
-                    type: "text"
-                })),
-                isError: result.toolResult.isError
-            };
-        }
-        catch (error) {
-            // Return error as tool result instead of throwing
-            return {
-                content: [{
-                        type: "text",
-                        text: `Error executing ${tool.name}: ${error.message || String(error)}`
-                    }],
-                isError: true
-            };
+/**
+ * Register tools with the MCP server
+ * This function is called after async tool loading completes
+ */
+function registerTools(server, loadedTools, handlers) {
+    let registeredCount = 0;
+    for (const tool of loadedTools) {
+        const handler = handlers[tool.name];
+        if (!handler) {
+            console.error(`⚠️  No handler for tool: ${tool.name}`);
+            continue;
         }
-    };
-    // console.log(`Registering tool: ${tool.name}`);
-    // console.log(`Input schema: ${JSON.stringify(tool.inputSchema)}`);
-    // const zodSchema = z.any().optional();
-    // const jsonSchema = zodToJsonSchema(z.object(tool.inputSchema.properties as z.ZodRawShape));
-    // const schema = z.object(tool.inputSchema as z.ZodRawShape).catchall(z.unknown());
-    // The inputSchema is already in JSON Schema format with properties
-    // server.tool(tool.name, tool.inputSchema.shape, wrappedHandler);
-    // const zodSchema = z.any().optional();
-    // const jsonSchema = zodToJsonSchema(z.object(tool.inputSchema.properties as z.ZodRawShape));
-    // const parsedSchema = z.any().optional().parse(jsonSchema);
-    const zodSchema = z.object(tool.inputSchema.properties);
-    server.tool(tool.name, zodSchema.shape, wrappedHandler);
-    registeredCount++;
+        const wrappedHandler = async (args) => {
+            try {
+                // The handler functions are already typed with their specific parameter types
+                const result = await handler(args);
+                return {
+                    content: result.toolResult.content.map((item) => ({
+                        ...item,
+                        type: "text"
+                    })),
+                    isError: result.toolResult.isError
+                };
+            }
+            catch (error) {
+                // Return error as tool result instead of throwing
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error executing ${tool.name}: ${error.message || String(error)}`
+                        }],
+                    isError: true
+                };
+            }
+        };
+        const zodSchema = z.object(tool.inputSchema.properties);
+        server.tool(tool.name, zodSchema.shape, wrappedHandler);
+        registeredCount++;
+    }
+    console.error(`✅ Registered ${registeredCount} of ${loadedTools.length} tools`);
+    return registeredCount;
 }
-console.error(`✅ Registered ${registeredCount} of ${allTools.length} tools`);
 async function main() {
-    const { logToFile } = await import('./wordpress.js');
+    const { logToFile, initWordPress } = await import('./wordpress.js');
     logToFile('Starting WordPress MCP server...');
     // Environment variables are passed by MCP client (Claude Desktop, Cursor, etc.)
     // Don't exit here - let initWordPress() handle the validation
@@ -108,9 +91,28 @@ async function main() {
     }
     try {
         logToFile('Initializing WordPress client...');
-        const { initWordPress } = await import('./wordpress.js');
         await initWordPress();
         logToFile('WordPress client initialized successfully.');
+        // Load tools with graceful plugin detection
+        logToFile('Loading tools with plugin detection...');
+        const { getFilteredToolsAsync, getFilteredHandlersAsync } = await import('./tools/index.js');
+        const loadedTools = await getFilteredToolsAsync();
+        const loadedHandlers = await getFilteredHandlersAsync(loadedTools);
+        logToFile(`Loaded ${loadedTools.length} tools based on installed plugins`);
+        // Create MCP server instance with loaded tools
+        const server = new McpServer({
+            name: generateServerName(),
+            version: "1.0.7"
+        }, {
+            capabilities: {
+                tools: loadedTools.reduce((acc, tool) => {
+                    acc[tool.name] = tool;
+                    return acc;
+                }, {})
+            }
+        });
+        // Register tools with handlers
+        registerTools(server, loadedTools, loadedHandlers);
         logToFile('Setting up server transport...');
         const transport = new StdioServerTransport();
         await server.connect(transport);

package/build/tools/index.d.ts

@@ -1,3 +1,13 @@
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Async version of getFilteredTools() that detects installed plugins
+ * and only loads tools for installed plugins when ENABLED_TOOLS='all' or not set
+ */
+declare function getFilteredToolsAsync(): Promise<Tool[]>;
+/**
+ * Async version that returns handlers matching the tools loaded by getFilteredToolsAsync()
+ */
+declare function getFilteredHandlersAsync(loadedTools: Tool[]): Promise<Record<string, any>>;
 export declare const allTools: Tool[];
 export declare const toolHandlers: Record<string, any>;
+export { getFilteredToolsAsync, getFilteredHandlersAsync };

package/build/tools/index.js

@@ -1,3 +1,4 @@
+import { detectInstalledPlugins } from '../wordpress.js';
 import { unifiedContentTools, unifiedContentHandlers } from './unified-content.js';
 import { unifiedTaxonomyTools, unifiedTaxonomyHandlers } from './unified-taxonomies.js';
 import { pluginTools, pluginHandlers } from './plugins.js';
@@ -129,46 +130,55 @@ const handlerCategories = {
         ...debugHandlers
     }
 };
+// Plugin slug mappings - which plugin slugs indicate which tool categories should load
+const pluginRequirements = {
+    fluentcommunity: ['fluent-community', 'fluentcommunity'],
+    'fluentcommunity-core': ['fluent-community', 'fluentcommunity'],
+    'fluentcommunity-learning': ['fluent-community', 'fluentcommunity'],
+    fluentcart: ['fluent-cart', 'fluentcart', 'wp-payment-form'],
+    fluentcrm: ['fluent-crm', 'fluentcrm'],
+    mlplugins: ['ml-image-editor', 'ml-media-hub', 'fluent-affiliate'],
+    pro: ['fluent-mcp-pro', 'fluentmcp-pro']
+};
+/**
+ * Check if any of the required plugin slugs are installed
+ */
+function hasAnyPlugin(installedPlugins, requiredSlugs) {
+    return requiredSlugs.some(slug => installedPlugins.has(slug));
+}
 // Filter tools based on ENABLED_TOOLS environment variable
 function getFilteredTools() {
     const enabledTools = process.env.ENABLED_TOOLS?.toLowerCase();
-    if (!enabledTools || enabledTools === 'all') {
-        // No filter or 'all' - load all tools
-        return [
-            ...toolCategories.wordpress,
-            ...toolCategories.fluentcommunity,
-            ...toolCategories.fluentcart,
-            ...toolCategories.fluentcrm,
-            ...toolCategories.mlplugins,
-            ...toolCategories.pro,
-            ...toolCategories.debug
-        ];
-    }
-    // Map user-friendly names to internal category names
-    const categoryMap = {
-        'wordpress': 'wordpress',
-        'fluent-community': 'fluentcommunity',
-        'fluentcommunity': 'fluentcommunity',
-        'fluentcommunity-core': 'fluentcommunity-core',
-        'fluent-community-core': 'fluentcommunity-core',
-        'fluentcommunity-learning': 'fluentcommunity-learning',
-        'fluent-community-learning': 'fluentcommunity-learning',
-        'fluent-cart': 'fluentcart',
-        'fluentcart': 'fluentcart',
-        'fluent-crm': 'fluentcrm',
-        'fluentcrm': 'fluentcrm',
-        'mlplugins': 'mlplugins',
-        'pro': 'pro',
-        'fluentmcp-pro': 'pro',
-        'fluent-mcp-pro': 'pro',
-        'debug': 'debug'
-    };
-    const category = categoryMap[enabledTools];
-    if (category && toolCategories[category]) {
-        console.error(`📦 Loading only: ${enabledTools} (${toolCategories[category].length} tools)`);
-        return toolCategories[category];
+    // If specific category requested, honor it (no detection needed)
+    if (enabledTools && enabledTools !== 'all') {
+        // Map user-friendly names to internal category names
+        const categoryMap = {
+            'wordpress': 'wordpress',
+            'fluent-community': 'fluentcommunity',
+            'fluentcommunity': 'fluentcommunity',
+            'fluentcommunity-core': 'fluentcommunity-core',
+            'fluent-community-core': 'fluentcommunity-core',
+            'fluentcommunity-learning': 'fluentcommunity-learning',
+            'fluent-community-learning': 'fluentcommunity-learning',
+            'fluent-cart': 'fluentcart',
+            'fluentcart': 'fluentcart',
+            'fluent-crm': 'fluentcrm',
+            'fluentcrm': 'fluentcrm',
+            'mlplugins': 'mlplugins',
+            'pro': 'pro',
+            'fluentmcp-pro': 'pro',
+            'fluent-mcp-pro': 'pro',
+            'debug': 'debug'
+        };
+        const category = categoryMap[enabledTools];
+        if (category && toolCategories[category]) {
+            console.error(`📦 Loading only: ${enabledTools} (${toolCategories[category].length} tools)`);
+            return toolCategories[category];
+        }
+        console.error(`⚠️  Unknown ENABLED_TOOLS value: ${enabledTools}. Loading all tools.`);
     }
-    console.error(`⚠️  Unknown ENABLED_TOOLS value: ${enabledTools}. Loading all tools.`);
+    // ENABLED_TOOLS not set or 'all' - load all tools without detection
+    // Detection will happen async in getFilteredToolsAsync()
     return [
         ...toolCategories.wordpress,
         ...toolCategories.fluentcommunity,
@@ -179,6 +189,51 @@ function getFilteredTools() {
         ...toolCategories.debug
     ];
 }
+/**
+ * Async version of getFilteredTools() that detects installed plugins
+ * and only loads tools for installed plugins when ENABLED_TOOLS='all' or not set
+ */
+async function getFilteredToolsAsync() {
+    const enabledTools = process.env.ENABLED_TOOLS?.toLowerCase();
+    // If specific category requested, use sync version (no detection needed)
+    if (enabledTools && enabledTools !== 'all') {
+        return getFilteredTools();
+    }
+    // Detect installed plugins
+    console.error('🔍 Detecting installed plugins...');
+    const installedPlugins = await detectInstalledPlugins();
+    if (installedPlugins.size === 0) {
+        // Detection failed - fall back to loading all tools (safe default)
+        console.error('⚠️  Plugin detection failed. Loading all tools as fallback.');
+        return getFilteredTools();
+    }
+    // Always include WordPress core tools and debug tools
+    const tools = [...toolCategories.wordpress, ...toolCategories.debug];
+    let loadedCategories = ['wordpress', 'debug'];
+    // Conditionally add plugin tools based on detection
+    if (hasAnyPlugin(installedPlugins, pluginRequirements.fluentcommunity)) {
+        tools.push(...toolCategories.fluentcommunity);
+        loadedCategories.push('fluentcommunity');
+    }
+    if (hasAnyPlugin(installedPlugins, pluginRequirements.fluentcart)) {
+        tools.push(...toolCategories.fluentcart);
+        loadedCategories.push('fluentcart');
+    }
+    if (hasAnyPlugin(installedPlugins, pluginRequirements.fluentcrm)) {
+        tools.push(...toolCategories.fluentcrm);
+        loadedCategories.push('fluentcrm');
+    }
+    if (hasAnyPlugin(installedPlugins, pluginRequirements.mlplugins)) {
+        tools.push(...toolCategories.mlplugins);
+        loadedCategories.push('mlplugins');
+    }
+    if (hasAnyPlugin(installedPlugins, pluginRequirements.pro)) {
+        tools.push(...toolCategories.pro);
+        loadedCategories.push('pro');
+    }
+    console.error(`✅ Loaded ${tools.length} tools from categories: ${loadedCategories.join(', ')}`);
+    return tools;
+}
 function getFilteredHandlers() {
     const enabledTools = process.env.ENABLED_TOOLS?.toLowerCase();
     if (!enabledTools || enabledTools === 'all') {
@@ -226,6 +281,45 @@ function getFilteredHandlers() {
         ...handlerCategories.debug
     };
 }
-// Export filtered tools and handlers
+/**
+ * Async version that returns handlers matching the tools loaded by getFilteredToolsAsync()
+ */
+async function getFilteredHandlersAsync(loadedTools) {
+    const enabledTools = process.env.ENABLED_TOOLS?.toLowerCase();
+    // If specific category requested, use sync version
+    if (enabledTools && enabledTools !== 'all') {
+        return getFilteredHandlers();
+    }
+    // Build handlers object based on which tools were loaded
+    const handlers = {
+        ...handlerCategories.wordpress,
+        ...handlerCategories.debug
+    };
+    // Check which tool categories are present in loadedTools
+    const hasFluentCommunity = loadedTools.some(t => t.name.startsWith('fc_'));
+    const hasFluentCart = loadedTools.some(t => t.name.startsWith('fcart_'));
+    const hasFluentCRM = loadedTools.some(t => t.name.startsWith('fcrm_'));
+    const hasMLPlugins = loadedTools.some(t => t.name.startsWith('mlimg_') || t.name.startsWith('mlmh_') || t.name.startsWith('faf_'));
+    const hasPro = loadedTools.some(t => t.name.startsWith('fmcp_pro_'));
+    if (hasFluentCommunity) {
+        Object.assign(handlers, handlerCategories.fluentcommunity);
+    }
+    if (hasFluentCart) {
+        Object.assign(handlers, handlerCategories.fluentcart);
+    }
+    if (hasFluentCRM) {
+        Object.assign(handlers, handlerCategories.fluentcrm);
+    }
+    if (hasMLPlugins) {
+        Object.assign(handlers, handlerCategories.mlplugins);
+    }
+    if (hasPro) {
+        Object.assign(handlers, handlerCategories.pro);
+    }
+    return handlers;
+}
+// Export filtered tools and handlers (sync versions for backward compatibility)
 export const allTools = getFilteredTools();
 export const toolHandlers = getFilteredHandlers();
+// Export async versions for graceful plugin detection
+export { getFilteredToolsAsync, getFilteredHandlersAsync };

package/build/wordpress.d.ts

@@ -16,6 +16,11 @@ export declare function makeWordPressRequest(method: string, endpoint: string, d
     isFormData?: boolean;
     rawResponse?: boolean;
 }): Promise<any>;
+/**
+ * Detect which plugins are installed and active
+ * Returns a set of plugin slugs that are active
+ */
+export declare function detectInstalledPlugins(): Promise<Set<string>>;
 /**
  * Make a request to the WordPress.org Plugin Repository API
  * @param searchQuery Search query string

package/build/wordpress.js

@@ -145,6 +145,32 @@ Data: ${JSON.stringify(error.response?.data || {}, null, 2)}
         throw error;
     }
 }
+/**
+ * Detect which plugins are installed and active
+ * Returns a set of plugin slugs that are active
+ */
+export async function detectInstalledPlugins() {
+    const installedPlugins = new Set();
+    try {
+        // Get list of active plugins
+        const response = await makeWordPressRequest('GET', 'wp/v2/plugins', { status: 'active' });
+        if (Array.isArray(response)) {
+            response.forEach((plugin) => {
+                // Extract plugin slug from plugin path (e.g., "fluent-crm/fluent-crm.php" -> "fluent-crm")
+                const slug = plugin.plugin?.split('/')[0] || plugin.slug;
+                if (slug) {
+                    installedPlugins.add(slug);
+                }
+            });
+        }
+        logToFile(`Detected active plugins: ${Array.from(installedPlugins).join(', ')}`);
+    }
+    catch (error) {
+        // Silently fail - if we can't detect plugins, we'll load all tools
+        logToFile(`Plugin detection failed (will load all tools): ${error.message}`);
+    }
+    return installedPlugins;
+}
 /**
  * Make a request to the WordPress.org Plugin Repository API
  * @param searchQuery Search query string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wplaunchify/ml-mcp-server",
-  "version": "2.5.6",
+  "version": "2.5.7",
   "description": "Universal MCP Server for WordPress + Fluent Suite (Community, CRM, Cart) + FluentMCP Pro. Comprehensive tools for AI-powered WordPress management via Claude, Cursor, and other MCP clients.",
   "type": "module",
   "main": "./build/server.js",