flowengine-mcp-app 2.0.0 → 3.0.0

package/build/index.js

@@ -6,35 +6,85 @@
  * 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
+ * 3. AI FlowBuilder - Create forms, chatbots, and UI embeds
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { registerAppTool, registerAppResource, RESOURCE_MIME_TYPE } from '@modelcontextprotocol/ext-apps/server';
+import { z } from 'zod';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+import { createServer } from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { FlowEngineClient } from './client.js';
-import { renderUnifiedDashboard } from './ui/dashboard.js';
-import { renderWidgetBuilder } from './ui/widgets.js';
-import { renderN8nViewer } from './ui/n8n-viewer.js';
-import { renderComponentViewer } from './ui/component-viewer.js';
-import { renderError } from './ui/base.js';
+import { registerFunctionsTools } from './tools/functions.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const UI_DIR = join(__dirname, 'ui', 'ui'); // Vite outputs to build/ui/ui/
 // Environment configuration
 const API_KEY = process.env.FLOWENGINE_API_KEY;
 const BASE_URL = process.env.FLOWENGINE_BASE_URL || 'https://flowengine.cloud';
-// Initialize FlowEngine client
-const flowengine = API_KEY ? new FlowEngineClient({
-    apiKey: API_KEY,
-    baseUrl: BASE_URL,
-}) : null;
+const MCP_MODE = (process.env.FLOWENGINE_MCP_MODE || 'all');
+// Per-request API key context (HTTP mode - each user's key is isolated)
+const requestApiKey = new AsyncLocalStorage();
 function ensureClient() {
-    if (!flowengine) {
+    const apiKey = requestApiKey.getStore() || API_KEY;
+    if (!apiKey) {
         throw new Error('FlowEngine API key not configured. Set FLOWENGINE_API_KEY in your MCP config.');
     }
-    return flowengine;
+    return new FlowEngineClient({ apiKey, baseUrl: BASE_URL });
+}
+function parseBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', (chunk) => { body += chunk; });
+        req.on('end', () => {
+            try {
+                resolve(body ? JSON.parse(body) : undefined);
+            }
+            catch {
+                resolve(undefined);
+            }
+        });
+        req.on('error', reject);
+    });
+}
+// Store latest tool results for UI to retrieve
+const toolResults = new Map();
+function storeToolResult(type, data) {
+    const key = `${type}-${Date.now()}`;
+    toolResults.set(key, data);
+    // Keep only last 10 results to prevent memory leaks
+    if (toolResults.size > 10) {
+        const firstKey = toolResults.keys().next().value;
+        if (firstKey) {
+            toolResults.delete(firstKey);
+        }
+    }
+    return key;
+}
+function getLatestToolResult(type) {
+    // Get most recent result of given type (or any type if not specified)
+    let latest = null;
+    let latestKey = '';
+    for (const [key, value] of toolResults) {
+        if (!type || value.type?.includes(type)) {
+            if (!latestKey || key > latestKey) {
+                latest = value;
+                latestKey = key;
+            }
+        }
+    }
+    return latest;
 }
 // Initialize MCP Server with modern API
 const server = new McpServer({
     name: 'flowengine-mcp',
-    version: '2.0.0',
+    version: '2.0.9',
 }, {
     capabilities: {
         resources: {},
@@ -43,364 +93,875 @@ const server = new McpServer({
 });
 /**
  * ===========================
- * APP RESOURCES (UI Components)
- * ===========================
- */
-// Dashboard Resource (Portals + Instances)
-registerAppResource(server, 'FlowEngine Dashboard', 'ui://flowengine/dashboard', {
-    description: 'INTERACTIVE UI APP: Shows live dashboard with all portals, instances, storage stats, and management controls. USE THIS UI when user asks for: dashboard, portals, instances, client accounts, portal management, or "show me FlowEngine". This provides a rich visual interface instead of JSON data.',
-}, async () => {
-    try {
-        const portals = await ensureClient().getClientInstances();
-        const html = renderUnifiedDashboard(portals);
-        return {
-            contents: [{
-                    uri: 'ui://flowengine/dashboard',
-                    mimeType: RESOURCE_MIME_TYPE,
-                    text: html,
-                }],
-        };
-    }
-    catch (error) {
-        const html = renderError(error.message || 'Failed to load dashboard');
-        return {
-            contents: [{
-                    uri: 'ui://flowengine/dashboard',
-                    mimeType: RESOURCE_MIME_TYPE,
-                    text: html,
-                }],
-        };
-    }
-});
-// n8n Workflow Viewer Resource
-registerAppResource(server, 'n8n Workflow Viewer', 'ui://flowengine/workflow-viewer', {
-    description: 'INTERACTIVE UI APP: Full-screen n8n workflow visualization with interactive demo. USE THIS UI when user asks to: view workflow, show n8n workflow, visualize automation, or preview workflow. Shows live workflow editor with share/export capabilities.',
-}, async () => {
-    const html = renderN8nViewer();
-    return {
-        contents: [{
-                uri: 'ui://flowengine/workflow-viewer',
-                mimeType: RESOURCE_MIME_TYPE,
-                text: html,
-            }],
-    };
-});
-// UI Component Viewer Resource
-registerAppResource(server, 'UI Component Viewer', 'ui://flowengine/component-viewer', {
-    description: 'INTERACTIVE UI APP: Live preview of forms, chatbots, widgets and UI components. USE THIS UI when user asks to: preview component, show chatbot, view form, see widget, or display UI component. Interactive preview with embed codes.',
-}, async () => {
-    const html = renderComponentViewer();
-    return {
-        contents: [{
-                uri: 'ui://flowengine/component-viewer',
-                mimeType: RESOURCE_MIME_TYPE,
-                text: html,
-            }],
-    };
-});
-// AI FlowBuilder Dashboard Resource
-registerAppResource(server, 'AI FlowBuilder Dashboard', 'ui://flowengine/ui-builder', {
-    description: 'INTERACTIVE UI APP: Dashboard for building and managing all UI components (forms, chatbots, widgets). USE THIS UI when user asks for: UI builder, component builder, create form, build chatbot, or manage components. Shows component gallery with creation tools.',
-}, async () => {
-    try {
-        const widgets = await ensureClient().getWidgets();
-        const html = renderWidgetBuilder(widgets);
-        return {
-            contents: [{
-                    uri: 'ui://flowengine/ui-builder',
-                    mimeType: RESOURCE_MIME_TYPE,
-                    text: html,
-                }],
-        };
-    }
-    catch (error) {
-        const html = renderError(error.message || 'Failed to load UI builder');
-        return {
-            contents: [{
-                    uri: 'ui://flowengine/ui-builder',
-                    mimeType: RESOURCE_MIME_TYPE,
-                    text: html,
-                }],
-        };
-    }
-});
-/**
- * ===========================
- * TOOLS WITH UI (MCP Apps)
+ * APP RESOURCES (3 Focused UIs)
  * ===========================
  */
-// Instance Management - List with UI
-registerAppTool(server, 'flowengine_list_instances', {
-    description: 'Show the FlowEngine Dashboard with interactive UI displaying all portals, instances, storage stats, and management controls. Use this when user wants to see the dashboard, view portals, check instances, or get an overview of FlowEngine. Renders a visual dashboard interface instead of JSON.',
-    inputSchema: {
-        type: 'object',
-        properties: {},
-    },
-    _meta: {
-        ui: {
-            resourceUri: 'ui://flowengine/dashboard',
+if (MCP_MODE !== 'functions') {
+    // 1. n8n Workflow Preview - ONLY workflow builder
+    registerAppResource(server, 'n8n Workflow Preview', 'ui://flowengine/n8n', {
+        description: 'n8n workflow builder preview. Simple, focused UI showing only the n8n workflow editor.',
+        mimeType: RESOURCE_MIME_TYPE,
+    }, async () => {
+        try {
+            let html = await readFile(join(UI_DIR, 'n8n.html'), 'utf-8');
+            // Inject latest tool result into HTML as a global variable
+            const latestResult = getLatestToolResult('workflow');
+            if (latestResult) {
+                const dataScript = `<script>window.__flowengineToolResult = ${JSON.stringify(latestResult)};</script>`;
+                html = html.replace('</head>', `${dataScript}</head>`);
+            }
+            return {
+                contents: [{
+                        uri: 'ui://flowengine/n8n',
+                        mimeType: RESOURCE_MIME_TYPE,
+                        text: html,
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                contents: [{
+                        uri: 'ui://flowengine/n8n',
+                        mimeType: RESOURCE_MIME_TYPE,
+                        text: `<!DOCTYPE html><html><body><h1>Error loading n8n preview</h1><p>${error.message}</p></body></html>`,
+                    }],
+            };
+        }
+    });
+    // 2. UI Embed Builder - ONLY component management
+    registerAppResource(server, 'UI Embed Builder', 'ui://flowengine/components', {
+        description: 'UI embed builder and manager. Simple, focused UI for creating and managing forms, chatbots, and widgets.',
+        mimeType: RESOURCE_MIME_TYPE,
+    }, async () => {
+        try {
+            let html = await readFile(join(UI_DIR, 'components.html'), 'utf-8');
+            // Inject latest tool result into HTML as a global variable
+            const latestResult = getLatestToolResult('component');
+            if (latestResult) {
+                const dataScript = `<script>window.__flowengineToolResult = ${JSON.stringify(latestResult)};</script>`;
+                html = html.replace('</head>', `${dataScript}</head>`);
+            }
+            return {
+                contents: [{
+                        uri: 'ui://flowengine/components',
+                        mimeType: RESOURCE_MIME_TYPE,
+                        text: html,
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                contents: [{
+                        uri: 'ui://flowengine/components',
+                        mimeType: RESOURCE_MIME_TYPE,
+                        text: `<!DOCTYPE html><html><body><h1>Error loading component builder</h1><p>${error.message}</p></body></html>`,
+                    }],
+            };
+        }
+    });
+    // 3. Portals Dashboard - ONLY portal management
+    registerAppResource(server, 'Portals Dashboard', 'ui://flowengine/portals', {
+        description: 'Portal management dashboard. Simple, focused UI for managing client portals, instances, and storage.',
+        mimeType: RESOURCE_MIME_TYPE,
+    }, async () => {
+        try {
+            const html = await readFile(join(UI_DIR, 'portals.html'), 'utf-8');
+            return {
+                contents: [{
+                        uri: 'ui://flowengine/portals',
+                        mimeType: RESOURCE_MIME_TYPE,
+                        text: html,
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                contents: [{
+                        uri: 'ui://flowengine/portals',
+                        mimeType: RESOURCE_MIME_TYPE,
+                        text: `<!DOCTYPE html><html><body><h1>Error loading portals dashboard</h1><p>${error.message}</p></body></html>`,
+                    }],
+            };
+        }
+    });
+    /**
+     * ===========================
+     * SIMPLE TOOLS (3 Tools Only)
+     * ===========================
+     * 1. flowengine_create_workflow - Create n8n workflow, return preview
+     * 2. flowengine_create_component - Create UI embed (form/chatbot/widget), return preview(s)
+     * 3. flowengine_get_instances - List portals/instances (read-only, links to website)
+     */
+    // 1. Create Workflow - Creates n8n workflow and returns preview
+    registerAppTool(server, 'flowengine_create_workflow', {
+        description: 'Create and show a sample n8n workflow instantly. Returns interactive workflow preview with a pre-made workflow template. Use when user asks to create/show workflows, automations, or n8n examples.',
+        inputSchema: {
+            name: z.string().describe('Workflow name or description'),
         },
-    },
-}, async () => {
-    const instances = await ensureClient().getInstances();
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(instances, null, 2),
-            }],
-    };
-});
-// Portal Management - List with UI
-registerAppTool(server, 'flowengine_list_portals', {
-    description: 'Show the FlowEngine Dashboard with interactive UI displaying all client portals, instances, and management controls. Use this when user wants to see portals, view client accounts, check portal status, or manage portals. Renders a visual dashboard interface instead of JSON.',
-    inputSchema: {
-        type: 'object',
-        properties: {},
-    },
-    _meta: {
-        ui: {
-            resourceUri: 'ui://flowengine/dashboard',
-        },
-    },
-}, async () => {
-    const portals = await ensureClient().getClientInstances();
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(portals, null, 2),
-            }],
-    };
-});
-// UI Components - List with UI
-registerAppTool(server, 'flowengine_list_components', {
-    description: 'Show the AI FlowBuilder Dashboard with interactive UI displaying all forms, chatbots, widgets, and UI components. Use this when user wants to see the UI builder, view components, manage forms/chatbots, or build UI elements. Renders a component gallery interface instead of JSON. Optionally filter by instanceId.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            instanceId: {
-                type: 'string',
-                description: 'Optional: Filter by instance ID',
+        _meta: {
+            ui: {
+                resourceUri: 'ui://flowengine/n8n',
             },
         },
-    },
-    _meta: {
-        ui: {
-            resourceUri: 'ui://flowengine/ui-builder',
-        },
-    },
-}, async (args) => {
-    const instanceId = args ? args.instanceId : undefined;
-    const widgets = await ensureClient().getWidgets(instanceId);
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(widgets, null, 2),
-            }],
-    };
-});
-/**
- * ===========================
- * REGULAR TOOLS (No UI)
- * ===========================
- */
-// Get Instance Status
-server.registerTool('flowengine_get_instance_status', {
-    description: 'Get health and status information for a specific instance',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            instanceId: {
-                type: 'string',
-                description: 'The instance ID to check',
+    }, async (args) => {
+        const client = ensureClient();
+        const name = args.name;
+        // Create sample workflow object
+        const sampleWorkflow = {
+            "name": name || "Sample Workflow",
+            "nodes": [
+                {
+                    "parameters": {
+                        "path": "webhook",
+                        "responseMode": "onReceived",
+                        "options": {}
+                    },
+                    "id": "webhook-1",
+                    "name": "Webhook",
+                    "type": "n8n-nodes-base.webhook",
+                    "typeVersion": 1,
+                    "position": [250, 300],
+                    "webhookId": "sample-webhook"
+                },
+                {
+                    "parameters": {
+                        "values": {
+                            "string": [
+                                {
+                                    "name": "message",
+                                    "value": "Received data from webhook"
+                                }
+                            ]
+                        },
+                        "options": {}
+                    },
+                    "id": "set-1",
+                    "name": "Process Data",
+                    "type": "n8n-nodes-base.set",
+                    "typeVersion": 1,
+                    "position": [450, 300]
+                },
+                {
+                    "parameters": {
+                        "conditions": {
+                            "string": [
+                                {
+                                    "value1": "={{$json.email}}",
+                                    "operation": "isNotEmpty"
+                                }
+                            ]
+                        }
+                    },
+                    "id": "if-1",
+                    "name": "Check Email",
+                    "type": "n8n-nodes-base.if",
+                    "typeVersion": 1,
+                    "position": [650, 300]
+                },
+                {
+                    "parameters": {
+                        "fromEmail": "noreply@example.com",
+                        "toEmail": "={{$json.email}}",
+                        "subject": "Notification",
+                        "text": "={{$json.message}}"
+                    },
+                    "id": "email-1",
+                    "name": "Send Email",
+                    "type": "n8n-nodes-base.emailSend",
+                    "typeVersion": 1,
+                    "position": [850, 250]
+                }
+            ],
+            "connections": {
+                "Webhook": {
+                    "main": [[{ "node": "Process Data", "type": "main", "index": 0 }]]
+                },
+                "Process Data": {
+                    "main": [[{ "node": "Check Email", "type": "main", "index": 0 }]]
+                },
+                "Check Email": {
+                    "main": [[{ "node": "Send Email", "type": "main", "index": 0 }]]
+                }
             },
+            "settings": {
+                "executionOrder": "v1"
+            }
+        };
+        try {
+            // Try to save workflow to n8n instance
+            const createResult = await client.createWorkflow(sampleWorkflow);
+            const workflowPreview = {
+                type: 'workflow_preview',
+                workflow: sampleWorkflow,
+                workflowId: createResult?.workflowId,
+                workflowUrl: createResult?.workflowUrl,
+                message: `✓ Created workflow: ${sampleWorkflow.name}`,
+                nodes: sampleWorkflow.nodes.length,
+                description: `Workflow created and saved to ${createResult?.instanceName || 'n8n instance'}. Ready to activate and deploy.`,
+                instanceName: createResult?.instanceName,
+            };
+            // Store for UI to retrieve
+            storeToolResult('workflow', workflowPreview);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(workflowPreview, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            // Fallback: return sample workflow for preview if creation fails
+            console.warn('Failed to create workflow in n8n:', error.message);
+            const fallbackWorkflow = {
+                type: 'workflow_preview',
+                workflow: sampleWorkflow,
+                message: `✓ Workflow preview created: ${sampleWorkflow.name}`,
+                nodes: sampleWorkflow.nodes.length,
+                description: `Preview ready. Note: Workflow could not be saved to n8n (${error.message}). Configure API key to enable persistence.`,
+                warning: error.message,
+            };
+            storeToolResult('workflow', fallbackWorkflow);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(fallbackWorkflow, null, 2),
+                    }],
+            };
+        }
+    });
+    // 2. Create Component - Creates UI embed and returns preview(s)
+    registerAppTool(server, 'flowengine_create_component', {
+        description: 'Create a UI embed (form, chatbot, widget) in FlowEngine and show preview. Use when user asks to create forms, chatbots, contact forms, etc. Returns component preview and workflow preview if component needs automation (like chatbot).',
+        inputSchema: {
+            type: z.enum(['form', 'chatbot', 'widget']).describe('Component type'),
+            name: z.string().describe('Component name or description'),
+            config: z.any().optional().describe('Optional configuration'),
         },
-        required: ['instanceId'],
-    },
-}, async (args) => {
-    const instanceId = args.instanceId;
-    const status = await ensureClient().getInstanceStatus(instanceId);
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(status, null, 2),
-            }],
-    };
-});
-// Create Instance
-server.registerTool('flowengine_create_instance', {
-    description: 'Provision a new FlowEngine instance for a client',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            data: {
-                type: 'object',
-                description: 'Instance configuration with client info and settings',
+        _meta: {
+            ui: {
+                resourceUri: 'ui://flowengine/components',
             },
         },
-        required: ['data'],
-    },
-}, async (args) => {
-    const data = args.data;
-    const result = await ensureClient().provisionInstance(data);
-    return {
-        content: [{
-                type: 'text',
-                text: `Instance created successfully. ID: ${result.instanceId || result.id || 'N/A'}`,
-            }],
-    };
-});
-// Update Instance
-server.registerTool('flowengine_update_instance', {
-    description: 'Update instance settings and configuration',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            data: {
-                type: 'object',
-                description: 'Updated instance configuration',
+    }, async (args) => {
+        const client = ensureClient();
+        const type = args.type;
+        const name = args.name;
+        const config = args.config;
+        // Create component data
+        const componentData = {
+            type: type,
+            name: name || `Sample ${type}`,
+            config: config || {},
+        };
+        try {
+            // Create component in database
+            const createResult = await client.createComponent(componentData);
+            const componentPreview = {
+                type: 'component_preview',
+                component: {
+                    id: createResult?.component?.id,
+                    ...componentData,
+                    slug: createResult?.component?.slug,
+                },
+                componentId: createResult?.component?.id,
+                componentUrl: createResult?.componentUrl,
+                message: `✓ Created ${type}: ${componentData.name}`,
+                componentType: type,
+                description: `${type.charAt(0).toUpperCase() + type.slice(1)} component created successfully. Ready to customize and embed.`,
+            };
+            // Store for UI to retrieve
+            storeToolResult('component', componentPreview);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(componentPreview, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            // Fallback: return component preview if creation fails
+            console.warn('Failed to create component:', error.message);
+            const fallbackComponent = {
+                type: 'component_preview',
+                component: {
+                    id: `component-${Date.now()}`,
+                    ...componentData,
+                },
+                message: `✓ Component preview created: ${componentData.name}`,
+                componentType: type,
+                description: `Preview ready. Note: Component could not be saved (${error.message}). Configure API key to enable persistence.`,
+                warning: error.message,
+            };
+            storeToolResult('component', fallbackComponent);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(fallbackComponent, null, 2),
+                    }],
+            };
+        }
+    });
+    // 3. Get Instances - Lists portals/instances (read-only, no create/delete)
+    registerAppTool(server, 'flowengine_get_instances', {
+        description: 'Show list of FlowEngine portals and hosting instances. Use when user asks to see their instances, portals, or hosting. Returns simple list with basic info and links to website. Read-only - all actions (create/delete) link to website.',
+        inputSchema: {},
+        _meta: {
+            ui: {
+                resourceUri: 'ui://flowengine/portals',
             },
         },
-        required: ['data'],
-    },
-}, async (args) => {
-    const data = args.data;
-    await ensureClient().updateInstance(data);
-    return {
-        content: [{
-                type: 'text',
-                text: 'Instance updated successfully',
-            }],
-    };
-});
-// Delete Instance
-server.registerTool('flowengine_delete_instance', {
-    description: 'Permanently delete a FlowEngine instance',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            instanceId: {
-                type: 'string',
-                description: 'The instance ID to delete',
+    }, async () => {
+        try {
+            const instances = await ensureClient().getInstances();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            type: 'instances_list',
+                            instances: instances,
+                            message: `Found ${instances.length} instance(s). Click links to manage on flowengine.cloud`,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            type: 'instances_list',
+                            instances: [],
+                            error: error.message,
+                            apiKey: API_KEY ? `${API_KEY.substring(0, 10)}...` : 'NOT SET',
+                            baseUrl: BASE_URL,
+                        }, null, 2),
+                    }],
+            };
+        }
+    });
+    // 4. Get Components - Lists all UI embeds (forms, chatbots, widgets)
+    registerAppTool(server, 'flowengine_get_components', {
+        description: 'Show list of UI embeds (forms, chatbots, widgets) with share links. Use when user asks to see their components, forms, chatbots, or widgets. Returns embed list with embed codes and share options.',
+        inputSchema: {},
+        _meta: {
+            ui: {
+                resourceUri: 'ui://flowengine/components',
             },
         },
-        required: ['instanceId'],
-    },
-}, async (args) => {
-    const instanceId = args.instanceId;
-    await ensureClient().deleteInstance(instanceId);
-    return {
-        content: [{
-                type: 'text',
-                text: 'Instance deleted successfully',
-            }],
-    };
-});
-// Get Component
-server.registerTool('flowengine_get_component', {
-    description: 'Get detailed configuration for a specific UI component',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            componentId: {
-                type: 'string',
-                description: 'The component ID',
+    }, async () => {
+        try {
+            const components = await ensureClient().getWidgets();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(components, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            // Return empty list if not authenticated
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify([], null, 2),
+                    }],
+            };
+        }
+    });
+    // 5. Deploy Instance - Deploy a docker image or GitHub repo to a hosting instance
+    registerAppTool(server, 'flowengine_deploy_instance', {
+        description: 'Deploy a Docker image or GitHub repo to a FlowEngine hosting instance. Saves config then triggers deployment. Use when user wants to deploy, redeploy, or change what is running on an instance. Provide EITHER dockerImage OR githubRepo (not both). Port defaults to 3000.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID to deploy to'),
+            dockerImage: z.string().optional().describe('Docker image to deploy (e.g. "nginx:latest", "ghcr.io/owner/repo:latest"). Use this OR githubRepo.'),
+            githubRepo: z.string().optional().describe('GitHub repo to build and deploy (e.g. "owner/repo"). Requires GitHub App installed. Use this OR dockerImage.'),
+            port: z.number().optional().describe('Container port your app listens on (default: 3000)'),
+            envVars: z.record(z.string()).optional().describe('Environment variables as key-value pairs (e.g. {"NODE_ENV": "production"})'),
+        },
+        _meta: { ui: { resourceUri: 'ui://flowengine/portals' } },
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId, dockerImage, githubRepo, port, envVars } = args;
+        if (!dockerImage && !githubRepo) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Provide either dockerImage or githubRepo.' }, null, 2) }] };
+        }
+        if (dockerImage && githubRepo) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Provide either dockerImage or githubRepo, not both.' }, null, 2) }] };
+        }
+        try {
+            await client.updateInstanceConfig(instanceId, {
+                ...(dockerImage ? { dockerImage } : { githubRepo }),
+                ...(port ? { port } : {}),
+                ...(envVars ? { envVars } : {}),
+            });
+            const result = await client.manageInstance(instanceId, 'redeploy');
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            instanceId,
+                            source: githubRepo ? 'github' : 'docker',
+                            ...(githubRepo ? { githubRepo } : { dockerImage }),
+                            port: port || 3000,
+                            message: result.message || 'Deployment started. Check status with flowengine_get_instance_status.',
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error.message }, null, 2) }] };
+        }
+    });
+    // 5b. Provision n8n - Provision an n8n automation instance on an empty slot
+    registerAppTool(server, 'flowengine_provision_n8n', {
+        description: 'Provision an n8n automation instance on an empty FlowEngine hosting slot. Use when user wants to deploy n8n to an existing empty instance. This is a full n8n provisioning - separate from docker deployments.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID of the empty slot to provision n8n on'),
+        },
+        _meta: { ui: { resourceUri: 'ui://flowengine/portals' } },
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId } = args;
+        try {
+            const result = await client.deployService(instanceId, 'n8n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            instanceId,
+                            serviceType: 'n8n',
+                            message: result.message || 'n8n provisioning started. Check status with flowengine_get_instance_status.',
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error.message }, null, 2) }] };
+        }
+    });
+    // 5c. Provision OpenClaw - Provision an OpenClaw AI agent on an empty slot
+    registerAppTool(server, 'flowengine_provision_openclaw', {
+        description: 'Provision an OpenClaw AI agent on an empty FlowEngine hosting slot. Requires instance with 30GB+ storage. Use when user wants to deploy OpenClaw to an existing empty instance. This is a full OpenClaw provisioning with browser and gateway components - separate from docker deployments.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID of the empty slot to provision OpenClaw on (must have 30GB+ storage)'),
+        },
+        _meta: { ui: { resourceUri: 'ui://flowengine/portals' } },
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId } = args;
+        try {
+            const result = await client.deployService(instanceId, 'openclaw');
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            instanceId,
+                            serviceType: 'openclaw',
+                            message: result.message || 'OpenClaw provisioning started. Check status with flowengine_get_instance_status.',
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error.message }, null, 2) }] };
+        }
+    });
+    // 5b. List GitHub Repos - List repos available for deployment
+    registerAppTool(server, 'flowengine_list_github_repos', {
+        description: 'List GitHub repositories accessible for deployment via the connected GitHub App. Use when user wants to deploy from GitHub and needs to choose a repo. Requires GitHub App to be installed on flowengine.cloud.',
+        inputSchema: {},
+        _meta: { ui: { resourceUri: 'ui://flowengine/portals' } },
+    }, async () => {
+        try {
+            const result = await ensureClient().listGithubRepos();
+            if (!result.success) {
+                return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: result.error, installUrl: result.installUrl }, null, 2) }] };
+            }
+            const repos = (result.repos || []).map((r) => ({
+                full_name: r.full_name,
+                name: r.name,
+                private: r.private,
+                default_branch: r.default_branch,
+                html_url: r.html_url,
+            }));
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, repos, count: repos.length, tip: 'Use full_name (e.g. "owner/repo") with flowengine_deploy_instance.' }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error.message }, null, 2) }] };
+        }
+    });
+    // 5c. Manage Instance - Start/stop/restart a hosting instance
+    registerAppTool(server, 'flowengine_manage_instance', {
+        description: 'Start, stop, or restart a FlowEngine hosting instance. Use when user asks to start/stop/restart a container. For deploying a new image or repo, use flowengine_deploy_instance instead.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID'),
+            action: z.enum(['start', 'stop', 'restart', 'redeploy']).describe('Action: start (boot stopped container), stop (halt container), restart (stop + start), redeploy (rebuild + restart with current config)'),
+        },
+        _meta: {
+            ui: {
+                resourceUri: 'ui://flowengine/portals',
             },
         },
-        required: ['componentId'],
-    },
-}, async (args) => {
-    const componentId = args.componentId;
-    const widget = await ensureClient().getWidget(componentId);
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(widget, null, 2),
-            }],
-    };
-});
-// Create Component
-server.registerTool('flowengine_create_component', {
-    description: 'Create a new UI component using AI FlowBuilder (form, chatbot, or widget)',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            data: {
-                type: 'object',
-                description: 'Component configuration with type, name, and settings',
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId, action } = args;
+        try {
+            const result = await client.manageInstance(instanceId, action);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: true, action, instanceId, message: result.message || `Instance ${action} triggered`, ...result }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: error.message }, null, 2),
+                    }],
+            };
+        }
+    });
+    // 6. Get Instance Logs - Fetch container logs
+    registerAppTool(server, 'flowengine_get_instance_logs', {
+        description: 'Get container logs for a FlowEngine hosting instance (docker, OpenClaw, n8n). Returns recent log output. Use when user asks to see logs, debug issues, or check what a container is doing.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID'),
+            lines: z.number().optional().describe('Number of log lines to return (default 200, max 1000)'),
+        },
+        _meta: {
+            ui: {
+                resourceUri: 'ui://flowengine/portals',
             },
         },
-        required: ['data'],
-    },
-}, async (args) => {
-    const data = args.data;
-    const result = await ensureClient().createWidget(data);
-    return {
-        content: [{
-                type: 'text',
-                text: `Component created successfully. ID: ${result.id || result.widgetId || 'N/A'}`,
-            }],
-    };
-});
-// Update Component
-server.registerTool('flowengine_update_component', {
-    description: 'Update an existing UI component configuration',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            componentId: {
-                type: 'string',
-                description: 'The component ID to update',
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId, lines = 200 } = args;
+        try {
+            const result = await client.getInstanceLogs(instanceId, lines);
+            return {
+                content: [{
+                        type: 'text',
+                        text: result.logs || '(no logs available)',
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error fetching logs: ${error.message}`,
+                    }],
+            };
+        }
+    });
+    // 7. Get Instance Deployments - Deployment history
+    registerAppTool(server, 'flowengine_get_instance_deployments', {
+        description: 'Get deployment history for a FlowEngine hosting instance. Shows past deploys with timestamps and status. Use when user asks about deployment history, when something was last deployed, or deployment status.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID'),
+        },
+        _meta: {
+            ui: {
+                resourceUri: 'ui://flowengine/portals',
             },
-            data: {
-                type: 'object',
-                description: 'Updated component configuration',
+        },
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId } = args;
+        try {
+            const result = await client.getInstanceDeployments(instanceId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ instanceId, deployments: result.deployments || [], message: result.message }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: error.message }, null, 2),
+                    }],
+            };
+        }
+    });
+    // 8. Get Instance Status - Live status check
+    registerAppTool(server, 'flowengine_get_instance_status', {
+        description: 'Get live status of a specific FlowEngine instance. Returns running/stopped/provisioning state and instance details. Use when user asks if an instance is running or wants to check its current state.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID'),
+        },
+        _meta: {
+            ui: {
+                resourceUri: 'ui://flowengine/portals',
             },
         },
-        required: ['componentId', 'data'],
-    },
-}, async (args) => {
-    const componentId = args.componentId;
-    const data = args.data;
-    await ensureClient().updateWidget(componentId, data);
-    return {
-        content: [{
-                type: 'text',
-                text: 'Component updated successfully',
-            }],
-    };
-});
-// Delete Component
-server.registerTool('flowengine_delete_component', {
-    description: 'Delete a UI component',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            componentId: {
-                type: 'string',
-                description: 'The component ID to delete',
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId } = args;
+        try {
+            const result = await client.getInstanceStatus(instanceId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            instanceId,
+                            status: result.containerStatus || result.status,
+                            coolifyStatus: result.coolifyStatus,
+                            instance: result.instance,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: error.message }, null, 2),
+                    }],
+            };
+        }
+    });
+    // 9. List Instance Backups
+    registerAppTool(server, 'flowengine_list_instance_backups', {
+        description: 'List backups for an OpenClaw instance. Returns backup history with status, file size, and timestamps.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID'),
+        },
+        _meta: { ui: { resourceUri: 'ui://flowengine/portals' } },
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId } = args;
+        try {
+            const result = await client.listInstanceBackups(instanceId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ instanceId, backups: result.backups || [] }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error.message }, null, 2) }] };
+        }
+    });
+    // 10. Create Instance Backup
+    registerAppTool(server, 'flowengine_create_instance_backup', {
+        description: 'Create a manual backup of an OpenClaw instance. Backs up Docker volumes to the server. Takes up to a few minutes.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID'),
+        },
+        _meta: { ui: { resourceUri: 'ui://flowengine/portals' } },
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId } = args;
+        try {
+            const result = await client.createInstanceBackup(instanceId);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error.message }, null, 2) }] };
+        }
+    });
+    // 11. Update Instance Config
+    registerAppTool(server, 'flowengine_update_instance_config', {
+        description: 'Update the docker image, port, or environment variables for a docker/website instance. Does not redeploy automatically - call flowengine_manage_instance with action=redeploy after to apply changes.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID'),
+            dockerImage: z.string().optional().describe('New Docker image (e.g. nginx:latest)'),
+            githubRepo: z.string().optional().describe('GitHub repo to build from (e.g. "owner/repo"). Requires GitHub App to be installed.'),
+            port: z.number().optional().describe('Container port to expose'),
+            envVars: z.record(z.string()).optional().describe('Environment variables as key-value object'),
+        },
+        _meta: { ui: { resourceUri: 'ui://flowengine/portals' } },
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId, dockerImage, githubRepo, port, envVars } = args;
+        try {
+            const result = await client.updateInstanceConfig(instanceId, { dockerImage, githubRepo, port, envVars });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error.message }, null, 2) }] };
+        }
+    });
+    // 12. Update Instance Type - Reclassify between docker and website
+    registerAppTool(server, 'flowengine_update_instance_type', {
+        description: 'Change the type of a FlowEngine instance between "docker" (full management) and "website" (URL + notes tracking). Use when user wants to reclassify an instance.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID'),
+            serviceType: z.enum(['docker', 'website']).describe('New type: "docker" for full management, "website" for URL/notes tracking'),
+        },
+        _meta: { ui: { resourceUri: 'ui://flowengine/portals' } },
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId, serviceType } = args;
+        try {
+            await client.updateInstanceConfig(instanceId, { serviceType });
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ success: true, instanceId, serviceType, message: `Instance type updated to "${serviceType}"` }, null, 2) }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error.message }, null, 2) }] };
+        }
+    });
+    // 13. Update Instance Domain - Update tracked URL for a website/docker instance
+    registerAppTool(server, 'flowengine_update_instance_domain', {
+        description: 'Update the tracked URL/domain for a website or docker instance. Updates the instance URL in FlowEngine (does not configure Coolify/DNS - do that separately). Use after setting up a custom domain.',
+        inputSchema: {
+            instanceId: z.string().describe('Instance ID'),
+            domain: z.string().describe('New domain (e.g. "app.yourdomain.com" or "https://app.yourdomain.com")'),
+        },
+        _meta: { ui: { resourceUri: 'ui://flowengine/portals' } },
+    }, async (args) => {
+        const client = ensureClient();
+        const { instanceId, domain } = args;
+        try {
+            const result = await client.updateInstanceDomain(instanceId, domain);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error.message }, null, 2) }] };
+        }
+    });
+    // 15. List Enrichment Providers - returns available providers with config schemas
+    registerAppTool(server, 'flowengine_list_enrichment_providers', {
+        description: 'List available enrichment providers (FlowEngine, Apollo, Bright Data) with their config schemas and connection status. Use this to see which providers the user can configure for visitor intelligence.',
+        inputSchema: {},
+        _meta: { ui: { resourceUri: 'ui://flowengine/n8n' } },
+    }, async () => {
+        const client = ensureClient();
+        try {
+            const result = await client.listEnrichmentProviders();
+            storeToolResult('enrichment', result);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error.message }, null, 2) }] };
+        }
+    });
+    // 16. Configure Enrichment - update provider config on a site (NEVER sets enrichment_provider - user choice only)
+    registerAppTool(server, 'flowengine_configure_enrichment', {
+        description: 'Configure enrichment and auto-push settings for a visitor intel site. Can update provider config, enrichment level, and auto-push to Smartlead/Instantly. IMPORTANT: Cannot change enrichment_provider or deanon_provider - those are user-only choices.',
+        inputSchema: {
+            siteId: z.string().describe('Visitor site ID'),
+            providerConfig: z.record(z.unknown()).optional().describe('Provider-specific configuration options (e.g. Apollo seniority filters, Bright Data dataset ID)'),
+            enrichmentLevel: z.enum(['basic', 'standard', 'full']).optional().describe('Enrichment depth: basic (3 contacts), standard (5), full (10)'),
+            autoPushTo: z.enum(['smartlead', 'instantly']).optional().describe('Auto-push new leads to this outreach platform. Set to empty string to disable.'),
+            autoPushCampaignId: z.string().optional().describe('Campaign ID to push leads to (required if autoPushTo is set)'),
+        },
+        _meta: { ui: { resourceUri: 'ui://flowengine/n8n' } },
+    }, async (args) => {
+        const client = ensureClient();
+        const { siteId, providerConfig, enrichmentLevel, autoPushTo, autoPushCampaignId } = args;
+        try {
+            const result = await client.configureEnrichment(siteId, { providerConfig, enrichmentLevel, autoPushTo, autoPushCampaignId });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: error.message }, null, 2) }] };
+        }
+    });
+    // 17. Get Latest Tool Result - Used by UI to fetch the result of the last tool call
+    registerAppTool(server, 'flowengine_get_latest_result', {
+        description: 'Internal: Get the latest tool result (used by UI to fetch preview data)',
+        inputSchema: {},
+        _meta: {
+            ui: {
+                resourceUri: 'ui://flowengine/internal',
             },
         },
-        required: ['componentId'],
-    },
-}, async (args) => {
-    const componentId = args.componentId;
-    await ensureClient().deleteWidget(componentId);
-    return {
-        content: [{
-                type: 'text',
-                text: 'Component deleted successfully',
-            }],
-    };
-});
+    }, async () => {
+        const latest = getLatestToolResult();
+        if (!latest) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: 'No result available' }, null, 2),
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(latest, null, 2),
+                }],
+        };
+    });
+} // end MCP_MODE !== 'functions'
+if (MCP_MODE !== 'hosting') {
+    registerFunctionsTools(server, {
+        baseUrl: BASE_URL,
+        getApiKey: () => {
+            const apiKey = requestApiKey.getStore() || API_KEY;
+            if (!apiKey) {
+                throw new Error('FlowEngine API key not configured. Set FLOWENGINE_API_KEY in your MCP config.');
+            }
+            return apiKey;
+        },
+    });
+}
 /**
  * ===========================
  * SERVER STARTUP
  * ===========================
  */
 async function main() {
-    const transport = new StdioServerTransport();
-    await server.server.connect(transport);
-    console.error('FlowEngine MCP Server (Modern API) running on stdio');
+    const port = process.env.PORT ? parseInt(process.env.PORT, 10) : null;
+    if (port) {
+        // HTTP mode - for Claude.ai online "Add custom connector"
+        // API key is read from Authorization: Bearer <fe_...> header per request
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+        });
+        await server.server.connect(transport);
+        const httpServer = createServer(async (req, res) => {
+            const authHeader = req.headers['authorization'] ?? '';
+            const token = authHeader.startsWith('Bearer ') ? authHeader.slice(7).trim() : '';
+            let body;
+            if (req.method === 'POST') {
+                body = await parseBody(req);
+            }
+            await requestApiKey.run(token, () => transport.handleRequest(req, res, body));
+        });
+        httpServer.listen(port, () => {
+            console.error(`FlowEngine MCP Server running on HTTP port ${port}`);
+        });
+    }
+    else {
+        // Stdio mode - for Claude Desktop / Claude Code CLI
+        const transport = new StdioServerTransport();
+        await server.server.connect(transport);
+        console.error('FlowEngine MCP Server running on stdio');
+    }
 }
 main().catch((error) => {
     console.error('Fatal error in MCP server:', error);