@datanimbus/dnio-mcp 1.0.0

package/src/tools/deployment-groups.js

@@ -0,0 +1,511 @@
+'use strict';
+
+const {z} = require('zod');
+const {toolError} = require('./_helpers');
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function buildDeploymentEntry(flow) {
+    return {
+        _id: flow._id,
+        name: flow.name,
+        type: 'FLOW',
+        version: flow.version || 1,
+        inputNode: flow.inputNode || {}
+    };
+}
+
+function dedupeArray(arr) {
+    const seen = new Set();
+    const dups = [];
+    for (const x of arr) {
+        if (seen.has(x)) dups.push(x);
+        seen.add(x);
+    }
+    return {unique: [...seen], duplicates: dups};
+}
+
+async function fetchFlowsForDeployment(dnioClient, appName, flowIds) {
+    const results = await Promise.all(flowIds.map(id => dnioClient.dataPipes.get(appName, id)));
+    return results.map(buildDeploymentEntry);
+}
+
+async function validateAvailability(dnioClient, appName, flowIds) {
+    const available = await dnioClient.deploymentGroups.listAvailableFlows(appName);
+    const availSet = new Set((Array.isArray(available) ? available : []).map(f => f._id));
+    const unavailable = flowIds.filter(id => !availSet.has(id));
+    return {availableSet: availSet, unavailable};
+}
+
+// ─── Tool registrations ─────────────────────────────────────────────────────
+
+module.exports = function registerDeploymentGroupsTools({server, dnioClient, registry, userContext}) {
+    const requireApp = () => {
+        if (!registry.selectedApp) {
+            return {content: [{type: 'text', text: 'No app selected. Use list_apps → select_app first.'}], isError: true};
+        }
+        return null;
+    };
+
+    // ─── Discovery ──────────────────────────────────────────────────────────
+
+    server.registerTool(
+        'list_available_flows',
+        {
+            title: 'List Flows Available For Deployment',
+            description: `List flows in the selected app that can be added to a deployment group right now. A flow is "available" only when it is published AND not currently bound to any other deployment group.
+
+This is the source of truth for create_deployment_group / add_flows_to_deployment_group — call it first.`,
+            inputSchema: {},
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async () => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.deploymentGroups.listAvailableFlows(registry.selectedApp);
+                const flows = Array.isArray(result) ? result : [];
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            app: registry.selectedApp,
+                            count: flows.length,
+                            flows: flows.map(f => ({_id: f._id, name: f.name, type: f.type || 'FLOW'})),
+                            usage: 'Pass these _id values to create_deployment_group.flowIds or add_flows_to_deployment_group.flowIds.'
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to list available flows', error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'list_deployment_groups',
+        {
+            title: 'List Deployment Groups',
+            description: `List deployment groups in the selected app. Each item shows status (Running/Stopped/Pending/etc.) and the flows currently bound to the group.
+
+Args:
+  - name (optional): Substring filter on group name (client-side).
+  - status (optional): Filter by status field.`,
+            inputSchema: {
+                name: z.string().optional().describe('Substring filter on group name'),
+                status: z.string().optional().describe("Status filter, e.g. 'Running' or 'Stopped'")
+            },
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async (params) => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                dnioClient.setToken(userContext.token);
+                const filter = {};
+                if (params.status) filter.status = params.status;
+                const result = await dnioClient.deploymentGroups.list(registry.selectedApp, {filter});
+                let groups = Array.isArray(result) ? result : [];
+                if (params.name) {
+                    const q = params.name.toLowerCase();
+                    groups = groups.filter(g => (g.name || '').toLowerCase().includes(q));
+                }
+                const summary = groups.map(g => ({
+                    groupId: g._id,
+                    name: g.name,
+                    status: g.status,
+                    deploymentCount: (g.deployments || []).length,
+                    deployments: (g.deployments || []).map(d => ({_id: d._id, name: d.name, version: d.version, type: d.type}))
+                }));
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({app: registry.selectedApp, count: summary.length, groups: summary}, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to list deployment groups', error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'get_deployment_group',
+        {
+            title: 'Get Deployment Group',
+            description: `Fetch the full deployment group document by groupId. Always returns latest server state — mutating tools fetch internally too, so this is purely for inspection.
+
+Args:
+  - groupId (required): e.g. 'DG2943'.`,
+            inputSchema: {
+                groupId: z.string().min(1).describe("Deployment group _id (e.g. 'DG2943')")
+            },
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async (params) => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                dnioClient.setToken(userContext.token);
+                const group = await dnioClient.deploymentGroups.get(registry.selectedApp, params.groupId);
+                return {content: [{type: 'text', text: JSON.stringify(group, null, 2)}]};
+            } catch (error) {
+                return toolError(`Failed to get deployment group ${params.groupId}`, error);
+            }
+        }
+    );
+
+    // ─── Create / Mutate ────────────────────────────────────────────────────
+
+    server.registerTool(
+        'create_deployment_group',
+        {
+            title: 'Create Deployment Group',
+            description: `Create a new deployment group bundling one or more published flows. Validates atomically:
+  - every flow must be in list_available_flows (rejects with explicit guidance if not)
+  - flowIds must contain no duplicates
+
+A flow can belong to AT MOST ONE deployment group. If a requested flow is unavailable, it's already bound elsewhere — call list_deployment_groups to find which group, then either remove it from there or pick a different flow.
+
+Args:
+  - name (required): Display name for the group.
+  - flowIds (required): Array of flow _id values to include (length ≥ 1).`,
+            inputSchema: {
+                name: z.string().min(1).describe('Group name'),
+                flowIds: z.array(z.string().min(1)).min(1).describe('Array of flow _id values to bundle')
+            },
+            annotations: {destructiveHint: false, idempotentHint: false}
+        },
+        async (params) => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                const app = registry.selectedApp;
+                const {unique, duplicates} = dedupeArray(params.flowIds);
+                if (duplicates.length > 0) {
+                    return toolError(`flowIds contains duplicates: [${duplicates.join(', ')}]. A flow cannot be added twice to the same group.`, new Error(''));
+                }
+
+                dnioClient.setToken(userContext.token);
+                const {unavailable} = await validateAvailability(dnioClient, app, unique);
+                if (unavailable.length > 0) {
+                    return toolError(
+                        `Cannot create group — these flows are not available: [${unavailable.join(', ')}]. A flow can belong to only one deployment group; check list_deployment_groups to find where these flows are currently bound.`,
+                        new Error('')
+                    );
+                }
+
+                const deployments = await fetchFlowsForDeployment(dnioClient, app, unique);
+                const result = await dnioClient.deploymentGroups.create(app, {
+                    name: params.name,
+                    deployments
+                });
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({groupId: result._id, status: result.status, group: result}, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to create deployment group', error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'add_flows_to_deployment_group',
+        {
+            title: 'Add Flows To Deployment Group',
+            description: `Append flows to an existing group. Atomic — rejects the whole call if any requested flow is unavailable, already in this group, or duplicated in the request.
+
+Args:
+  - groupId (required)
+  - flowIds (required): Array of flow _id values to add.`,
+            inputSchema: {
+                groupId: z.string().min(1),
+                flowIds: z.array(z.string().min(1)).min(1)
+            },
+            annotations: {destructiveHint: false, idempotentHint: false}
+        },
+        async (params) => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                const app = registry.selectedApp;
+                const {unique, duplicates} = dedupeArray(params.flowIds);
+                if (duplicates.length > 0) {
+                    return toolError(`flowIds contains duplicates: [${duplicates.join(', ')}].`, new Error(''));
+                }
+
+                dnioClient.setToken(userContext.token);
+                const group = await dnioClient.deploymentGroups.get(app, params.groupId);
+
+                const alreadyInGroup = unique.filter(id => (group.deployments || []).some(d => d._id === id));
+                if (alreadyInGroup.length > 0) {
+                    return toolError(`Already in this group: [${alreadyInGroup.join(', ')}].`, new Error(''));
+                }
+
+                const {unavailable} = await validateAvailability(dnioClient, app, unique);
+                if (unavailable.length > 0) {
+                    return toolError(
+                        `Cannot add — these flows are not available: [${unavailable.join(', ')}]. A flow can belong to only one deployment group.`,
+                        new Error('')
+                    );
+                }
+
+                const newEntries = await fetchFlowsForDeployment(dnioClient, app, unique);
+                group.deployments = [...(group.deployments || []), ...newEntries];
+
+                const result = await dnioClient.deploymentGroups.update(app, params.groupId, group);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({groupId: params.groupId, addedFlowIds: unique, group: result}, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError(`Failed to add flows to group ${params.groupId}`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'remove_flows_from_deployment_group',
+        {
+            title: 'Remove Flows From Deployment Group',
+            description: `Detach flows from a group. Removed flows become available again (will appear in list_available_flows).
+
+If removing all flows would leave the group empty, the response includes a warning. Removing all flows from a Running group will cause the next start to fail — set force=true to acknowledge and proceed silently.
+
+Args:
+  - groupId (required)
+  - flowIds (required): Array of flow _id values to remove.
+  - force (optional, default false): Skip the empty-group warning.`,
+            inputSchema: {
+                groupId: z.string().min(1),
+                flowIds: z.array(z.string().min(1)).min(1),
+                force: z.boolean().optional()
+            },
+            annotations: {destructiveHint: false, idempotentHint: false}
+        },
+        async (params) => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                const app = registry.selectedApp;
+                dnioClient.setToken(userContext.token);
+                const group = await dnioClient.deploymentGroups.get(app, params.groupId);
+
+                const removeSet = new Set(params.flowIds);
+                const before = (group.deployments || []).length;
+                group.deployments = (group.deployments || []).filter(d => !removeSet.has(d._id));
+                const removed = before - group.deployments.length;
+
+                if (removed === 0) {
+                    return toolError(`None of the requested flowIds [${params.flowIds.join(', ')}] are in group ${params.groupId}.`, new Error(''));
+                }
+
+                const result = await dnioClient.deploymentGroups.update(app, params.groupId, group);
+                const response = {
+                    groupId: params.groupId,
+                    removedCount: removed,
+                    remainingCount: group.deployments.length,
+                    group: result
+                };
+                if (group.deployments.length === 0 && !params.force) {
+                    response.warning = 'Group is now empty. If it is currently Running, the next start_deployment_group will fail. Pass force=true to suppress this warning.';
+                }
+                return {content: [{type: 'text', text: JSON.stringify(response, null, 2)}]};
+            } catch (error) {
+                return toolError(`Failed to remove flows from group ${params.groupId}`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'rename_deployment_group',
+        {
+            title: 'Rename Deployment Group',
+            description: `Change the name of a deployment group. Does not affect deployments or running pods.
+
+Args:
+  - groupId (required)
+  - name (required): New name.`,
+            inputSchema: {
+                groupId: z.string().min(1),
+                name: z.string().min(1)
+            },
+            annotations: {destructiveHint: false, idempotentHint: true}
+        },
+        async (params) => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                const app = registry.selectedApp;
+                dnioClient.setToken(userContext.token);
+                const group = await dnioClient.deploymentGroups.get(app, params.groupId);
+                group.name = params.name;
+                const result = await dnioClient.deploymentGroups.update(app, params.groupId, group);
+                return {content: [{type: 'text', text: JSON.stringify({groupId: params.groupId, name: params.name, group: result}, null, 2)}]};
+            } catch (error) {
+                return toolError(`Failed to rename group ${params.groupId}`, error);
+            }
+        }
+    );
+
+    // ─── K8s lifecycle ──────────────────────────────────────────────────────
+
+    server.registerTool(
+        'start_deployment_group',
+        {
+            title: 'Start Deployment Group (K8s up)',
+            description: `Spin up Kubernetes pods + services for every flow in the group.
+
+⚠️ This triggers a real Kubernetes deployment and may take ~10 seconds to become healthy. The tool returns as soon as the platform accepts the request — it does NOT wait for pod readiness. Poll get_deployment_group separately if you need to confirm.
+
+Args:
+  - groupId (required)`,
+            inputSchema: {groupId: z.string().min(1)},
+            annotations: {destructiveHint: false, idempotentHint: true}
+        },
+        async (params) => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.deploymentGroups.start(registry.selectedApp, params.groupId);
+                return {content: [{type: 'text', text: JSON.stringify({groupId: params.groupId, action: 'start', note: 'Kubernetes deployment initiated; may take ~10s to settle.', result}, null, 2)}]};
+            } catch (error) {
+                return toolError(`Failed to start group ${params.groupId}`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'stop_deployment_group',
+        {
+            title: 'Stop Deployment Group (K8s down)',
+            description: `Tear down the Kubernetes pods for this group. Group definition and deployments[] are preserved — flows stay bound to the group and remain unavailable to other groups until the group is deleted or the flows are explicitly removed.
+
+The tool returns as soon as the platform accepts the request; actual pod teardown is async.
+
+Args:
+  - groupId (required)`,
+            inputSchema: {groupId: z.string().min(1)},
+            annotations: {destructiveHint: false, idempotentHint: true}
+        },
+        async (params) => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.deploymentGroups.stop(registry.selectedApp, params.groupId);
+                return {content: [{type: 'text', text: JSON.stringify({groupId: params.groupId, action: 'stop', result}, null, 2)}]};
+            } catch (error) {
+                return toolError(`Failed to stop group ${params.groupId}`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'sync_deployment_group',
+        {
+            title: 'Sync Deployment Group (re-pull latest published flows)',
+            description: `Re-pull the latest PUBLISHED version of every flow in the group and reconcile the running pods. Use this after editing + republishing a flow that is already bound to a running group.
+
+⚠️ Drafts are ignored — only the latest publish is synced. If you forget to publish_flow, your edits won't propagate.
+
+Args:
+  - groupId (required)`,
+            inputSchema: {groupId: z.string().min(1)},
+            annotations: {destructiveHint: false, idempotentHint: true}
+        },
+        async (params) => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.deploymentGroups.sync(registry.selectedApp, params.groupId);
+                return {content: [{type: 'text', text: JSON.stringify({groupId: params.groupId, action: 'sync', result}, null, 2)}]};
+            } catch (error) {
+                return toolError(`Failed to sync group ${params.groupId}`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'delete_deployment_group',
+        {
+            title: 'Delete Deployment Group',
+            description: `⚠️ Destructive. Permanently delete a deployment group. Tears down K8s pods AND removes the group definition. Bound flows become available again to be added to other groups.
+
+Two-phase confirmation:
+  - confirm: false (default) → returns the group document and the list of flows that WOULD be freed; nothing is deleted.
+  - confirm: true → actually deletes.
+
+Args:
+  - groupId (required)
+  - confirm (required, default false): Set to true to actually delete.`,
+            inputSchema: {
+                groupId: z.string().min(1),
+                confirm: z.boolean().optional()
+            },
+            annotations: {destructiveHint: true, idempotentHint: false}
+        },
+        async (params) => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                const app = registry.selectedApp;
+                dnioClient.setToken(userContext.token);
+
+                if (!params.confirm) {
+                    const group = await dnioClient.deploymentGroups.get(app, params.groupId);
+                    return {
+                        content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'confirmation required',
+                                message: 'Pass confirm=true to actually delete this group. The flows listed in freedFlows will become available to add to other groups.',
+                                groupId: params.groupId,
+                                freedFlows: (group.deployments || []).map(d => ({_id: d._id, name: d.name, version: d.version})),
+                                group
+                            }, null, 2)
+                        }],
+                        isError: true
+                    };
+                }
+
+                const result = await dnioClient.deploymentGroups.delete(app, params.groupId);
+                return {content: [{type: 'text', text: JSON.stringify({groupId: params.groupId, action: 'deleted', result}, null, 2)}]};
+            } catch (error) {
+                return toolError(`Failed to delete group ${params.groupId}`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'get_deployment_group_yamls',
+        {
+            title: 'Get Deployment Group K8s YAMLs',
+            description: `Fetch the actual Kubernetes Deployment + Service YAMLs the platform generated for this group. Read-only; useful for debugging or showing the user what's running.
+
+Args:
+  - groupId (required)`,
+            inputSchema: {groupId: z.string().min(1)},
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async (params) => {
+            const guard = requireApp();
+            if (guard) return guard;
+            try {
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.deploymentGroups.getYamls(registry.selectedApp, params.groupId);
+                return {content: [{type: 'text', text: JSON.stringify({groupId: params.groupId, yamls: result}, null, 2)}]};
+            } catch (error) {
+                return toolError(`Failed to fetch YAMLs for group ${params.groupId}`, error);
+            }
+        }
+    );
+};

package/src/tools/formulas.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function registerFormulasTools(_ctx) {
+    // TODO: register DNIO formulas tools
+};

package/src/tools/functions.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function registerFunctionsTools(_ctx) {
+    // TODO: register DNIO functions tools
+};

package/src/tools/mcp-tools-registry.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const registerAppsTools        = require('./apps');
+const registerServicesTools    = require('./services');
+const registerRecordsTools     = require('./records');
+const registerConnectorsTools  = require('./connectors');
+const registerDataPipesTools   = require('./data-pipes');
+const registerPluginsTools     = require('./plugins');
+const registerFunctionsTools   = require('./functions');
+const registerDataFormatsTools = require('./data-formats');
+const registerFormulasTools    = require('./formulas');
+const registerUsersTools       = require('./users');
+const registerUserGroupsTools  = require('./user-groups');
+const registerApiKeysTools     = require('./api-keys');
+const registerBotsTools        = require('./bots');
+const registerDeploymentGroupsTools = require('./deployment-groups');
+
+function registerAllTools(server, dnioClient, authManager, registry, userContext) {
+    const ctx = {server, dnioClient, authManager, registry, userContext};
+
+    registerAppsTools(ctx);
+    registerServicesTools(ctx);
+    registerRecordsTools(ctx);
+    registerConnectorsTools(ctx);
+
+    registerDataPipesTools(ctx);
+    registerPluginsTools(ctx);
+    registerFunctionsTools(ctx);
+    registerDataFormatsTools(ctx);
+    registerFormulasTools(ctx);
+    registerUsersTools(ctx);
+    registerUserGroupsTools(ctx);
+    registerApiKeysTools(ctx);
+    registerBotsTools(ctx);
+    registerDeploymentGroupsTools(ctx);
+}
+
+module.exports = registerAllTools;