@datanimbus/dnio-mcp 1.0.0

package/src/tools/plugins.js

@@ -0,0 +1,250 @@
+'use strict';
+
+const {z} = require('zod');
+const {toolError} = require('./_helpers');
+
+// Default select strings: minimal for browsing, full for getting one plugin's details.
+const SUMMARY_SELECT = 'label,type,version,icon';
+const DETAIL_SELECT = '_id,app,nodeId,version,category,group,type,label,icon,connectorType,inputSchema,outputSchema,errorSchema,code';
+
+module.exports = function registerPluginsTools({server, dnioClient, registry, userContext}) {
+    server.registerTool(
+        'list_marketplace_plugins',
+        {
+            title: 'List Marketplace Plugins',
+            description: `List plugins (workflow nodes) available in the DataNimbus marketplace. Plugins are reusable code blocks used as nodes in data pipes — they aren't usable in this app until installed via 'install_plugins'.
+
+Each item shows the marketplace _id (use as 'marketIds' entry for install_plugins), label, type, version, and icon. Call this BEFORE install_plugins.
+
+Args:
+  - search (optional): Substring match against label or type. Omit for all.`,
+            inputSchema: {
+                search: z.string().optional().describe('Substring match against label or type.')
+            },
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async (params) => {
+            if (!registry.selectedApp) {
+                return {content: [{type: 'text', text: 'No app selected. Use list_apps → select_app first.'}], isError: true};
+            }
+            try {
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.plugins.listMarketplace(registry.selectedApp);
+                let items = Array.isArray(result) ? result : [];
+                if (params.search) {
+                    const q = params.search.toLowerCase();
+                    items = items.filter(i =>
+                        (i.label || '').toLowerCase().includes(q) ||
+                        (i.type || '').toLowerCase().includes(q)
+                    );
+                }
+                const summary = items.map(i => ({
+                    marketId: i._id,
+                    type: i.type,
+                    label: i.label,
+                    version: i.version,
+                    icon: i.icon
+                }));
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            app: registry.selectedApp,
+                            count: summary.length,
+                            plugins: summary,
+                            usage: "Pass an array of 'marketId' values to install_plugins to install them into this app."
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to list marketplace plugins', error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'install_plugins',
+        {
+            title: 'Install Plugins From Marketplace',
+            description: `Install one or more marketplace plugins into the currently selected app. After install, the plugins are available for use in data pipes built within this app.
+
+Call list_marketplace_plugins first to get the marketIds. The 'app' is auto-injected from the selected app context.
+
+Args:
+  - marketIds (required): Array of marketplace _id values to install (pass even a single one as an array).`,
+            inputSchema: {
+                marketIds: z.array(z.string().min(1)).min(1).describe('Array of marketplace plugin _id values to install')
+            },
+            annotations: {destructiveHint: false, idempotentHint: true}
+        },
+        async (params) => {
+            if (!registry.selectedApp) {
+                return {content: [{type: 'text', text: 'No app selected. Use list_apps → select_app first.'}], isError: true};
+            }
+            try {
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.plugins.install(registry.selectedApp, params.marketIds);
+                const items = Array.isArray(result) ? result : [];
+                const installed = items.filter(i => i.statusCode === 200 || i.statusCode === 201);
+                const failed = items.filter(i => i.statusCode && i.statusCode >= 400);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            app: registry.selectedApp,
+                            requested: params.marketIds.length,
+                            installed: installed.length,
+                            failed: failed.length,
+                            results: items
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to install plugins', error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'list_installed_plugins',
+        {
+            title: 'List or Get Installed Plugins',
+            description: `List plugins installed in the currently selected app, or fetch full details for a specific one.
+
+Behaviour:
+  - No args → returns a summary list of all installed plugins (label, type, version, icon).
+  - 'pluginId' set → returns just that plugin (single object). Combined with 'details: true' fetches full schema (inputSchema/outputSchema/errorSchema/code).
+  - 'details: true' (no pluginId) → returns the full schema for every installed plugin (potentially large).
+  - 'search' → substring filter on label/type.
+
+Args:
+  - pluginId (optional): Installed plugin _id (the long hex from install_plugins or list_installed_plugins).
+  - details (optional, default false): If true, include inputSchema, outputSchema, errorSchema, and code.
+  - search (optional): Substring match against label or type.`,
+            inputSchema: {
+                pluginId: z.string().optional().describe('Installed plugin _id; omit to list all.'),
+                details: z.boolean().optional().describe('If true, fetch full schemas + code. Default: false.'),
+                search: z.string().optional().describe('Substring match against label or type.')
+            },
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async (params) => {
+            if (!registry.selectedApp) {
+                return {content: [{type: 'text', text: 'No app selected. Use list_apps → select_app first.'}], isError: true};
+            }
+            try {
+                dnioClient.setToken(userContext.token);
+                const select = params.details ? DETAIL_SELECT : SUMMARY_SELECT;
+                const filter = params.pluginId ? {_id: params.pluginId} : undefined;
+                const result = await dnioClient.plugins.listInstalled(registry.selectedApp, {select, filter});
+                let items = Array.isArray(result) ? result : [];
+
+                if (params.search) {
+                    const q = params.search.toLowerCase();
+                    items = items.filter(i =>
+                        (i.label || '').toLowerCase().includes(q) ||
+                        (i.type || '').toLowerCase().includes(q)
+                    );
+                }
+
+                if (params.pluginId) {
+                    const plugin = items[0];
+                    if (!plugin) {
+                        return {content: [{type: 'text', text: `Plugin '${params.pluginId}' not installed in ${registry.selectedApp}.`}], isError: true};
+                    }
+                    return {content: [{type: 'text', text: JSON.stringify({app: registry.selectedApp, plugin}, null, 2)}]};
+                }
+
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            app: registry.selectedApp,
+                            count: items.length,
+                            details: !!params.details,
+                            plugins: items
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to list installed plugins', error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'update_plugins',
+        {
+            title: 'Refresh / Update Installed Plugins',
+            description: `Refresh installed plugins to the latest version from the marketplace. Use the installed plugin _id (the long hex from list_installed_plugins), NOT the marketplace _id.
+
+The 'app' field in the request body is auto-injected from the selected app.
+
+Args:
+  - ids (required): Array of installed plugin _id values to refresh.`,
+            inputSchema: {
+                ids: z.array(z.string().min(1)).min(1).describe('Array of installed plugin _id values to refresh')
+            },
+            annotations: {destructiveHint: false, idempotentHint: true}
+        },
+        async (params) => {
+            if (!registry.selectedApp) {
+                return {content: [{type: 'text', text: 'No app selected. Use list_apps → select_app first.'}], isError: true};
+            }
+            try {
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.plugins.update(registry.selectedApp, params.ids);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            app: registry.selectedApp,
+                            requested: params.ids.length,
+                            result
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to update plugins', error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'uninstall_plugins',
+        {
+            title: 'Uninstall Plugins From App',
+            description: `⚠️ Destructive. Uninstall plugins from the currently selected app. Data pipes that use uninstalled plugins may break.
+
+Use the installed plugin _id (from list_installed_plugins), NOT the marketplace _id. The 'app' field is auto-injected from the selected app.
+
+Args:
+  - ids (required): Array of installed plugin _id values to uninstall.`,
+            inputSchema: {
+                ids: z.array(z.string().min(1)).min(1).describe('Array of installed plugin _id values to uninstall')
+            },
+            annotations: {destructiveHint: true, idempotentHint: false}
+        },
+        async (params) => {
+            if (!registry.selectedApp) {
+                return {content: [{type: 'text', text: 'No app selected. Use list_apps → select_app first.'}], isError: true};
+            }
+            try {
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.plugins.uninstall(registry.selectedApp, params.ids);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            app: registry.selectedApp,
+                            requested: params.ids.length,
+                            result
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to uninstall plugins', error);
+            }
+        }
+    );
+};

package/src/tools/records.js

@@ -0,0 +1,217 @@
+'use strict';
+
+const {z} = require('zod');
+const {toolError, resolveServiceOrError} = require('./_helpers');
+
+module.exports = function registerRecordsTools({server, dnioClient, registry, userContext}) {
+    server.registerTool(
+        'list_records',
+        {
+            title: 'List Records',
+            description: `List/search records from a data service. Supports filtering, sorting, pagination.
+Args: serviceName (required), filter (optional, MongoDB JSON), sort, select, page, count`,
+            inputSchema: {
+                serviceName: z.string().min(1).describe('Service name'),
+                filter: z.string().optional().describe('MongoDB-style JSON filter'),
+                sort: z.string().optional().describe('Sort field (prefix - for desc)'),
+                select: z.string().optional().describe('Comma-separated fields'),
+                page: z.number().int().min(1).default(1).optional().describe('Page (default: 1)'),
+                count: z.number().int().min(1).max(100).default(20).optional().describe('Per page (default: 20)')
+            },
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async (params) => {
+            const svc = resolveServiceOrError(registry, params.serviceName);
+            if (svc.isError) return svc;
+            try {
+                dnioClient.setToken(userContext.token);
+                const filter = params.filter ? JSON.parse(params.filter) : undefined;
+                const result = await dnioClient.records.list(registry.selectedApp, svc.servicePath, {
+                    filter, sort: params.sort, select: params.select, page: params.page || 1, count: params.count || 20
+                });
+                const records = Array.isArray(result) ? result : (result.records || [result]);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            service: svc.name,
+                            count: records.length,
+                            page: params.page || 1,
+                            records
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError(`Failed to list ${svc.name} records`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'get_record',
+        {
+            title: 'Get Record',
+            description: 'Get a single record by ID.\nArgs: serviceName, recordId, expand (optional boolean)',
+            inputSchema: {
+                serviceName: z.string().min(1).describe('Service name'),
+                recordId: z.string().min(1).describe('Record ID'),
+                expand: z.boolean().default(false).optional().describe('Expand related records')
+            },
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async (params) => {
+            const svc = resolveServiceOrError(registry, params.serviceName);
+            if (svc.isError) return svc;
+            try {
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.records.get(registry.selectedApp, svc.servicePath, params.recordId, {expand: params.expand});
+                return {content: [{type: 'text', text: JSON.stringify({service: svc.name, record: result}, null, 2)}]};
+            } catch (error) {
+                if (error.status === 404) return {
+                    content: [{
+                        type: 'text',
+                        text: `Record '${params.recordId}' not found in ${svc.name}`
+                    }]
+                };
+                return toolError(`Failed to get record from ${svc.name}`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'create_record',
+        {
+            title: 'Create Record',
+            description: 'Create a new record. Use get_service_schema first.\nArgs: serviceName, data (JSON string)',
+            inputSchema: {
+                serviceName: z.string().min(1).describe('Service name'),
+                data: z.string().min(2).describe('JSON string of record data')
+            },
+            annotations: {readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false}
+        },
+        async (params) => {
+            const svc = resolveServiceOrError(registry, params.serviceName);
+            if (svc.isError) return svc;
+            try {
+                dnioClient.setToken(userContext.token);
+                const data = JSON.parse(params.data);
+                const result = await dnioClient.records.create(registry.selectedApp, svc.servicePath, data);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({service: svc.name, action: 'created', record: result}, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError(`Failed to create record in ${svc.name}`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'update_record',
+        {
+            title: 'Update Record',
+            description: 'Update an existing record.\nArgs: serviceName, recordId, data (JSON string)',
+            inputSchema: {
+                serviceName: z.string().min(1).describe('Service name'),
+                recordId: z.string().min(1).describe('Record ID'),
+                data: z.string().min(2).describe('JSON string of fields to update')
+            },
+            annotations: {readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async (params) => {
+            const svc = resolveServiceOrError(registry, params.serviceName);
+            if (svc.isError) return svc;
+            try {
+                dnioClient.setToken(userContext.token);
+                const data = JSON.parse(params.data);
+                const result = await dnioClient.records.update(registry.selectedApp, svc.servicePath, params.recordId, data);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            service: svc.name,
+                            action: 'updated',
+                            recordId: params.recordId,
+                            record: result
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                if (error.status === 404) return {
+                    content: [{
+                        type: 'text',
+                        text: `Record '${params.recordId}' not found in ${svc.name}`
+                    }]
+                };
+                return toolError(`Failed to update record in ${svc.name}`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'delete_record',
+        {
+            title: 'Delete Record',
+            description: '⚠️ Destructive. Delete a record by ID.\nArgs: serviceName, recordId',
+            inputSchema: {
+                serviceName: z.string().min(1).describe('Service name'),
+                recordId: z.string().min(1).describe('Record ID to delete')
+            },
+            annotations: {readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false}
+        },
+        async (params) => {
+            const svc = resolveServiceOrError(registry, params.serviceName);
+            if (svc.isError) return svc;
+            try {
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.records.delete(registry.selectedApp, svc.servicePath, params.recordId);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            service: svc.name,
+                            action: 'deleted',
+                            recordId: params.recordId,
+                            result
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                if (error.status === 404) return {
+                    content: [{
+                        type: 'text',
+                        text: `Record '${params.recordId}' not found in ${svc.name}`
+                    }]
+                };
+                return toolError(`Failed to delete record from ${svc.name}`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'count_records',
+        {
+            title: 'Count Records',
+            description: 'Count records in a service, with optional filter.\nArgs: serviceName, filter (optional JSON)',
+            inputSchema: {
+                serviceName: z.string().min(1).describe('Service name'),
+                filter: z.string().optional().describe('MongoDB-style JSON filter')
+            },
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async (params) => {
+            const svc = resolveServiceOrError(registry, params.serviceName);
+            if (svc.isError) return svc;
+            try {
+                dnioClient.setToken(userContext.token);
+                const filter = params.filter ? JSON.parse(params.filter) : undefined;
+                const result = await dnioClient.records.count(registry.selectedApp, svc.servicePath, filter);
+                return {content: [{type: 'text', text: JSON.stringify({service: svc.name, count: result}, null, 2)}]};
+            } catch (error) {
+                return toolError(`Failed to count ${svc.name} records`, error);
+            }
+        }
+    );
+};