flowengine-mcp-app 1.0.0 → 1.1.1

package/build/index.js

@@ -1,201 +1,124 @@
 #!/usr/bin/env node
 /**
- * FlowEngine MCP App
- * Interactive UI for managing FlowEngine directly from Claude Code
+ * FlowEngine MCP Server
+ * Manage your white-label automation platform from Claude
+ *
+ * Core Features:
+ * 1. Instance Management - Provision and manage FlowEngine instances
+ * 2. Client Portals - Monitor and access client portals
+ * 3. AI FlowBuilder - Create forms, chatbots, and UI components
  */
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { FlowEngineClient } from './client.js';
 import { renderPortalsDashboard, renderPortalDetails } from './ui/portals.js';
-import { renderWorkflowsManager, renderWorkflowDetails } from './ui/workflows.js';
 import { renderWidgetBuilder, renderWidgetDetails } from './ui/widgets.js';
 import { renderInstancesManager, renderInstanceDetails } from './ui/instances.js';
-import { renderDemoShowcase } from './ui/demo.js';
 import { renderError } from './ui/base.js';
-// Get configuration from environment variables
+// Environment configuration
 const API_KEY = process.env.FLOWENGINE_API_KEY;
 const BASE_URL = process.env.FLOWENGINE_BASE_URL || 'https://flowengine.cloud';
-// Initialize FlowEngine client (will be undefined if no API key)
+// Initialize FlowEngine client
 const flowengine = API_KEY ? new FlowEngineClient({
     apiKey: API_KEY,
     baseUrl: BASE_URL,
 }) : null;
-// Helper to check if client is available
 function ensureClient() {
     if (!flowengine) {
-        throw new Error('FlowEngine API key not configured. Please set FLOWENGINE_API_KEY in your MCP server configuration.');
+        throw new Error('FlowEngine API key not configured. Set FLOWENGINE_API_KEY in your MCP config.');
     }
     return flowengine;
 }
 const server = new Server({
     name: 'flowengine-mcp',
-    version: '0.1.0',
+    version: '1.0.0',
 }, {
     capabilities: {
         resources: {},
         tools: {},
-        prompts: {},
     },
 });
 /**
- * List all available app resources
+ * Interactive UI Resources
  */
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
     return {
         resources: [
             {
-                uri: 'app://flowengine/demo',
-                name: 'n8n Demo & Templates',
-                description: 'Explore pre-built workflows and automation templates',
-                mimeType: 'text/html',
-            },
-            {
-                uri: 'app://flowengine/portals',
+                uri: 'ui://flowengine/portals',
                 name: 'Client Portals',
-                description: 'View and manage your client portals and instances',
-                mimeType: 'text/html',
-            },
-            {
-                uri: 'app://flowengine/workflows',
-                name: 'Workflows',
-                description: 'Manage automation workflows',
-                mimeType: 'text/html',
+                description: 'View and manage your client portals',
+                mimeType: 'text/html;profile=mcp-app',
             },
             {
-                uri: 'app://flowengine/ui-builder',
-                name: 'UI Builder',
-                description: 'Create and manage forms, chatbots, and interactive components',
-                mimeType: 'text/html',
+                uri: 'ui://flowengine/ui-builder',
+                name: 'AI FlowBuilder',
+                description: 'Build forms, chatbots, and UI components with AI',
+                mimeType: 'text/html;profile=mcp-app',
             },
             {
-                uri: 'app://flowengine/hosting',
-                name: 'Hosting',
+                uri: 'ui://flowengine/instances',
+                name: 'Instance Manager',
                 description: 'Manage FlowEngine instances and hosting',
-                mimeType: 'text/html',
+                mimeType: 'text/html;profile=mcp-app',
             },
         ],
     };
 });
 /**
- * Read and render app resources
+ * Render Resources
  */
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     const uri = request.params.uri;
     try {
-        if (uri === 'app://flowengine/demo') {
-            const html = renderDemoShowcase();
-            return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: 'text/html',
-                        text: html,
-                    },
-                ],
-            };
-        }
-        if (uri === 'app://flowengine/portals') {
+        // Client Portals Dashboard
+        if (uri === 'ui://flowengine/portals') {
             const instances = await ensureClient().getClientInstances();
             const html = renderPortalsDashboard(instances);
             return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: 'text/html',
-                        text: html,
-                    },
-                ],
-            };
-        }
-        if (uri === 'app://flowengine/workflows') {
-            const workflows = await ensureClient().getWorkflows();
-            const html = renderWorkflowsManager(workflows);
-            return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: 'text/html',
-                        text: html,
-                    },
-                ],
+                contents: [{ uri, mimeType: 'text/html', text: html }],
             };
         }
-        if (uri === 'app://flowengine/ui-builder') {
-            const widgets = await ensureClient().getWidgets();
-            const html = renderWidgetBuilder(widgets);
-            return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: 'text/html',
-                        text: html,
-                    },
-                ],
-            };
-        }
-        if (uri === 'app://flowengine/hosting') {
-            const instances = await ensureClient().getInstances();
-            const html = renderInstancesManager(instances);
-            return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: 'text/html',
-                        text: html,
-                    },
-                ],
-            };
-        }
-        // Handle detail views with query parameters
-        if (uri.startsWith('app://flowengine/portal/')) {
+        // Portal Details
+        if (uri.startsWith('ui://flowengine/portal/')) {
             const instanceId = uri.split('/').pop() || '';
             const client = ensureClient();
-            const [workflows, widgets] = await Promise.all([
-                client.getClientPanelWorkflows(instanceId),
-                client.getClientPanelWidgets(instanceId),
-            ]);
+            // Fetch data sequentially to avoid API concurrency issues
+            const workflows = await client.getClientPanelWorkflows(instanceId);
+            const widgets = await client.getClientPanelWidgets(instanceId);
             const html = renderPortalDetails(instanceId, workflows, widgets);
             return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: 'text/html',
-                        text: html,
-                    },
-                ],
+                contents: [{ uri, mimeType: 'text/html', text: html }],
             };
         }
-        if (uri.startsWith('app://flowengine/workflow/')) {
-            const workflowId = uri.split('/').pop() || '';
-            const workflow = await ensureClient().getWorkflowParameters(workflowId);
-            const executions = await ensureClient().getWorkflowExecutions(workflowId);
-            const html = renderWorkflowDetails(workflow, executions);
+        // AI FlowBuilder (UI Components)
+        if (uri === 'ui://flowengine/ui-builder') {
+            const widgets = await ensureClient().getWidgets();
+            const html = renderWidgetBuilder(widgets);
             return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: 'text/html',
-                        text: html,
-                    },
-                ],
+                contents: [{ uri, mimeType: 'text/html', text: html }],
             };
         }
-        if (uri.startsWith('app://flowengine/widget/')) {
+        // Widget Details
+        if (uri.startsWith('ui://flowengine/widget/')) {
             const widgetId = uri.split('/').pop() || '';
             const widget = await ensureClient().getWidget(widgetId);
             const html = renderWidgetDetails(widget);
             return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: 'text/html',
-                        text: html,
-                    },
-                ],
+                contents: [{ uri, mimeType: 'text/html', text: html }],
             };
         }
-        if (uri.startsWith('app://flowengine/instance/')) {
+        // Instance Manager
+        if (uri === 'ui://flowengine/instances') {
+            const instances = await ensureClient().getInstances();
+            const html = renderInstancesManager(instances);
+            return {
+                contents: [{ uri, mimeType: 'text/html', text: html }],
+            };
+        }
+        // Instance Details
+        if (uri.startsWith('ui://flowengine/instance/')) {
             const instanceId = uri.split('/').pop() || '';
             const instances = await ensureClient().getInstances();
             const instance = instances.find((i) => i.id === instanceId);
@@ -205,122 +128,130 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
             const status = await ensureClient().getInstanceStatus(instanceId);
             const html = renderInstanceDetails(instance, status);
             return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: 'text/html',
-                        text: html,
-                    },
-                ],
+                contents: [{ uri, mimeType: 'text/html', text: html }],
             };
         }
-        throw new Error(`Unknown resource URI: ${uri}`);
+        throw new Error(`Unknown resource: ${uri}`);
     }
     catch (error) {
         const html = renderError(error.message || 'An error occurred');
         return {
-            contents: [
-                {
-                    uri,
-                    mimeType: 'text/html',
-                    text: html,
-                },
-            ],
+            contents: [{ uri, mimeType: 'text/html', text: html }],
         };
     }
 });
 /**
- * List available tools
+ * Available Tools
  */
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
-            // Workflow tools
+            // Instance Management Tools
             {
-                name: 'flowengine_toggle_workflow',
-                description: 'Enable or disable a workflow',
+                name: 'flowengine_list_instances',
+                description: 'List all FlowEngine instances you have access to',
                 inputSchema: {
                     type: 'object',
-                    properties: {
-                        workflowId: {
-                            type: 'string',
-                            description: 'The workflow ID',
-                        },
-                        enabled: {
-                            type: 'boolean',
-                            description: 'Whether to enable (true) or disable (false) the workflow',
-                        },
+                    properties: {},
+                },
+                _meta: {
+                    ui: {
+                        resourceUri: 'ui://flowengine/instances',
                     },
-                    required: ['workflowId', 'enabled'],
                 },
             },
             {
-                name: 'flowengine_list_workflows',
-                description: 'List all workflows',
+                name: 'flowengine_get_instance_status',
+                description: 'Get health and status information for a specific instance',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         instanceId: {
                             type: 'string',
-                            description: 'Optional instance ID to filter workflows',
+                            description: 'The instance ID to check',
                         },
                     },
+                    required: ['instanceId'],
                 },
             },
             {
-                name: 'flowengine_get_workflow_executions',
-                description: 'Get recent executions for a workflow',
+                name: 'flowengine_create_instance',
+                description: 'Provision a new FlowEngine instance for a client',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        workflowId: {
-                            type: 'string',
-                            description: 'The workflow ID',
+                        data: {
+                            type: 'object',
+                            description: 'Instance configuration with client info and settings',
                         },
                     },
-                    required: ['workflowId'],
+                    required: ['data'],
                 },
             },
-            // Instance tools
             {
-                name: 'flowengine_list_instances',
-                description: 'List all instances',
+                name: 'flowengine_update_instance',
+                description: 'Update instance settings and configuration',
                 inputSchema: {
                     type: 'object',
-                    properties: {},
+                    properties: {
+                        data: {
+                            type: 'object',
+                            description: 'Updated instance configuration',
+                        },
+                    },
+                    required: ['data'],
                 },
             },
             {
-                name: 'flowengine_get_instance_status',
-                description: 'Get status and health information for an instance',
+                name: 'flowengine_delete_instance',
+                description: 'Permanently delete a FlowEngine instance',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         instanceId: {
                             type: 'string',
-                            description: 'The instance ID',
+                            description: 'The instance ID to delete',
                         },
                     },
                     required: ['instanceId'],
                 },
             },
-            // UI Builder tools
+            // Portal Tools
+            {
+                name: 'flowengine_list_portals',
+                description: 'List all client portals and their access URLs',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+                _meta: {
+                    ui: {
+                        resourceUri: 'ui://flowengine/portals',
+                    },
+                },
+            },
+            // UI Component Tools (AI FlowBuilder)
             {
-                name: 'flowengine_list_ui_components',
-                description: 'List all forms, chatbots, and UI components',
+                name: 'flowengine_list_components',
+                description: 'List all UI components (forms, chatbots, widgets)',
                 inputSchema: {
                     type: 'object',
                     properties: {
                         instanceId: {
                             type: 'string',
-                            description: 'Optional instance ID to filter components',
+                            description: 'Optional: Filter by instance ID',
                         },
                     },
                 },
+                _meta: {
+                    ui: {
+                        resourceUri: 'ui://flowengine/ui-builder',
+                    },
+                },
             },
             {
                 name: 'flowengine_get_component',
-                description: 'Get details about a specific UI component',
+                description: 'Get detailed configuration for a specific UI component',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -332,141 +263,144 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ['componentId'],
                 },
             },
-            // Portal tools
-            {
-                name: 'flowengine_list_portals',
-                description: 'List all client portals',
-                inputSchema: {
-                    type: 'object',
-                    properties: {},
-                },
-            },
-            // Template tools
             {
-                name: 'flowengine_list_templates',
-                description: 'List all available workflow templates',
+                name: 'flowengine_create_component',
+                description: 'Create a new UI component using AI FlowBuilder (form, chatbot, or widget)',
                 inputSchema: {
                     type: 'object',
-                    properties: {},
+                    properties: {
+                        data: {
+                            type: 'object',
+                            description: 'Component configuration with type, name, and settings',
+                        },
+                    },
+                    required: ['data'],
                 },
             },
             {
-                name: 'flowengine_import_template',
-                description: 'Import a workflow template to an instance',
+                name: 'flowengine_update_component',
+                description: 'Update an existing UI component configuration',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        templateId: {
+                        componentId: {
                             type: 'string',
-                            description: 'The template ID to import',
+                            description: 'The component ID to update',
                         },
-                        instanceId: {
-                            type: 'string',
-                            description: 'The instance ID to import to',
+                        data: {
+                            type: 'object',
+                            description: 'Updated component configuration',
                         },
                     },
-                    required: ['templateId', 'instanceId'],
+                    required: ['componentId', 'data'],
                 },
             },
             {
-                name: 'flowengine_create_workflow',
-                description: 'Create a new workflow from JSON in an instance',
+                name: 'flowengine_delete_component',
+                description: 'Delete a UI component',
                 inputSchema: {
                     type: 'object',
                     properties: {
-                        instanceId: {
-                            type: 'string',
-                            description: 'The instance ID to create the workflow in',
-                        },
-                        workflowJSON: {
-                            type: 'object',
-                            description: 'The workflow JSON definition',
-                        },
-                        workflowTitle: {
+                        componentId: {
                             type: 'string',
-                            description: 'Optional title for the workflow',
+                            description: 'The component ID to delete',
                         },
                     },
-                    required: ['instanceId', 'workflowJSON'],
+                    required: ['componentId'],
                 },
             },
         ],
     };
 });
 /**
- * Handle tool calls
+ * Handle Tool Calls
  */
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
         switch (name) {
-            case 'flowengine_toggle_workflow': {
-                if (!args)
-                    throw new Error('Missing arguments');
-                const workflowId = args.workflowId;
-                const enabled = args.enabled;
-                const result = await ensureClient().toggleWorkflow(workflowId, enabled);
+            // Instance Management
+            case 'flowengine_list_instances': {
+                const instances = await ensureClient().getInstances();
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: `Workflow ${enabled ? 'enabled' : 'disabled'} successfully`,
+                            text: JSON.stringify(instances, null, 2),
                         },
                     ],
                 };
             }
-            case 'flowengine_list_workflows': {
-                const instanceId = args ? args.instanceId : undefined;
-                const workflows = await ensureClient().getWorkflows(instanceId);
+            case 'flowengine_get_instance_status': {
+                if (!args)
+                    throw new Error('Missing arguments');
+                const instanceId = args.instanceId;
+                const status = await ensureClient().getInstanceStatus(instanceId);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify(workflows, null, 2),
+                            text: JSON.stringify(status, null, 2),
                         },
                     ],
                 };
             }
-            case 'flowengine_get_workflow_executions': {
+            case 'flowengine_create_instance': {
                 if (!args)
                     throw new Error('Missing arguments');
-                const workflowId = args.workflowId;
-                const executions = await ensureClient().getWorkflowExecutions(workflowId);
+                const data = args.data;
+                const result = await ensureClient().provisionInstance(data);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify(executions, null, 2),
+                            text: `Instance created successfully. ID: ${result.instanceId || result.id || 'N/A'}`,
                         },
                     ],
                 };
             }
-            case 'flowengine_list_instances': {
-                const instances = await ensureClient().getInstances();
+            case 'flowengine_update_instance': {
+                if (!args)
+                    throw new Error('Missing arguments');
+                const data = args.data;
+                await ensureClient().updateInstance(data);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify(instances, null, 2),
+                            text: 'Instance updated successfully',
                         },
                     ],
                 };
             }
-            case 'flowengine_get_instance_status': {
+            case 'flowengine_delete_instance': {
                 if (!args)
                     throw new Error('Missing arguments');
                 const instanceId = args.instanceId;
-                const status = await ensureClient().getInstanceStatus(instanceId);
+                await ensureClient().deleteInstance(instanceId);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify(status, null, 2),
+                            text: 'Instance deleted successfully',
                         },
                     ],
                 };
             }
-            case 'flowengine_list_ui_components': {
+            // Portals
+            case 'flowengine_list_portals': {
+                const portals = await ensureClient().getClientInstances();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(portals, null, 2),
+                        },
+                    ],
+                };
+            }
+            // UI Components (AI FlowBuilder)
+            case 'flowengine_list_components': {
                 const instanceId = args ? args.instanceId : undefined;
                 const widgets = await ensureClient().getWidgets(instanceId);
                 return {
@@ -492,59 +426,45 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
-            case 'flowengine_list_portals': {
-                const portals = await ensureClient().getClientInstances();
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(portals, null, 2),
-                        },
-                    ],
-                };
-            }
-            case 'flowengine_list_templates': {
-                const templates = await ensureClient().listTemplates();
+            case 'flowengine_create_component': {
+                if (!args)
+                    throw new Error('Missing arguments');
+                const data = args.data;
+                const result = await ensureClient().createWidget(data);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify(templates, null, 2),
+                            text: `Component created successfully. ID: ${result.id || result.widgetId || 'N/A'}`,
                         },
                     ],
                 };
             }
-            case 'flowengine_import_template': {
+            case 'flowengine_update_component': {
                 if (!args)
                     throw new Error('Missing arguments');
-                const templateId = args.templateId;
-                const instanceId = args.instanceId;
-                const result = await ensureClient().importTemplate({ templateId, instanceId });
+                const componentId = args.componentId;
+                const data = args.data;
+                await ensureClient().updateWidget(componentId, data);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: `Template imported successfully. Workflow ID: ${result.workflowId || 'N/A'}`,
+                            text: 'Component updated successfully',
                         },
                     ],
                 };
             }
-            case 'flowengine_create_workflow': {
+            case 'flowengine_delete_component': {
                 if (!args)
                     throw new Error('Missing arguments');
-                const instanceId = args.instanceId;
-                const workflowJSON = args.workflowJSON;
-                const workflowTitle = args.workflowTitle;
-                const result = await ensureClient().importWorkflowToInstance({
-                    instanceId,
-                    workflowJSON,
-                    workflowTitle,
-                });
+                const componentId = args.componentId;
+                await ensureClient().deleteWidget(componentId);
                 return {
                     content: [
                         {
                             type: 'text',
-                            text: `Workflow created successfully. Workflow ID: ${result.workflowId || result.id || 'N/A'}`,
+                            text: 'Component deleted successfully',
                         },
                     ],
                 };
@@ -566,82 +486,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     }
 });
 /**
- * List available prompts
- */
-server.setRequestHandler(ListPromptsRequestSchema, async () => {
-    return {
-        prompts: [
-            {
-                name: 'check_workflow_status',
-                description: 'Check the status of your workflows',
-            },
-            {
-                name: 'view_recent_executions',
-                description: 'View recent workflow executions',
-            },
-            {
-                name: 'manage_portals',
-                description: 'Manage your client portals',
-            },
-        ],
-    };
-});
-/**
- * Handle prompt requests
- */
-server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    const { name } = request.params;
-    switch (name) {
-        case 'check_workflow_status':
-            return {
-                description: 'Check the status of your workflows',
-                messages: [
-                    {
-                        role: 'user',
-                        content: {
-                            type: 'text',
-                            text: 'Please show me the status of all my workflows and highlight any that are inactive or having issues.',
-                        },
-                    },
-                ],
-            };
-        case 'view_recent_executions':
-            return {
-                description: 'View recent workflow executions',
-                messages: [
-                    {
-                        role: 'user',
-                        content: {
-                            type: 'text',
-                            text: 'Show me the most recent workflow executions and highlight any failures.',
-                        },
-                    },
-                ],
-            };
-        case 'manage_portals':
-            return {
-                description: 'Manage your client portals',
-                messages: [
-                    {
-                        role: 'user',
-                        content: {
-                            type: 'text',
-                            text: 'Show me all my client portals and their current status.',
-                        },
-                    },
-                ],
-            };
-        default:
-            throw new Error(`Unknown prompt: ${name}`);
-    }
-});
-/**
- * Start the server
+ * Start Server
  */
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('FlowEngine MCP App server started');
+    console.error('FlowEngine MCP Server running');
 }
 main().catch((error) => {
     console.error('Fatal error:', error);