@datanimbus/dnio-mcp 1.0.0

package/src/stdio-bridge.js

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * stdio-bridge.js
+ *
+ * A lightweight stdio ↔ Streamable HTTP bridge for MCP.
+ * Claude Desktop runs this as a stdio server, and it forwards
+ * all JSON-RPC messages to the remote HTTP MCP server.
+ *
+ * Usage in claude_desktop_config.json:
+ * {
+ *   "dnio-remote": {
+ *     "command": "node",
+ *     "args": ["/path/to/stdio-bridge.js"],
+ *     "env": {
+ *       "MCP_REMOTE_URL": "http://localhost:3100/mcp",
+ *       "MCP_AUTH_HEADER": "Basic YWRtaW46UWFhZG1pbkAxMjM="
+ *     }
+ *   }
+ * }
+ */
+
+const http = require('http');
+const https = require('https');
+
+const REMOTE_URL = process.env.MCP_REMOTE_URL || 'http://localhost:3100/mcp';
+const AUTH_HEADER = process.env.MCP_AUTH_HEADER || '';
+const parsed = new URL(REMOTE_URL);
+const transport = parsed.protocol === 'https:' ? https : http;
+
+let sessionId = null;
+
+// ─── Read stdin as newline-delimited JSON-RPC ─────────────────────────────────
+
+let buffer = '';
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', (chunk) => {
+    buffer += chunk;
+
+    // MCP stdio protocol: each message is a complete JSON object followed by newline
+    let newlineIndex;
+    while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+        const line = buffer.slice(0, newlineIndex).trim();
+        buffer = buffer.slice(newlineIndex + 1);
+
+        if (line.length === 0) continue;
+
+        try {
+            const message = JSON.parse(line);
+            forwardToRemote(message);
+        } catch (err) {
+            log(`Failed to parse stdin: ${err.message}`);
+        }
+    }
+});
+
+process.stdin.on('end', () => {
+    log('stdin closed, exiting');
+    process.exit(0);
+});
+
+// ─── Forward JSON-RPC message to HTTP server ──────────────────────────────────
+
+function forwardToRemote(message) {
+    const body = JSON.stringify(message);
+
+    const headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json, text/event-stream',
+        'Content-Length': Buffer.byteLength(body),
+    };
+
+    if (AUTH_HEADER) {
+        headers['Authorization'] = AUTH_HEADER;
+    }
+
+    if (sessionId) {
+        headers['Mcp-Session-Id'] = sessionId;
+    }
+
+    const options = {
+        hostname: parsed.hostname,
+        port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+        path: parsed.pathname + parsed.search,
+        method: 'POST',
+        headers,
+    };
+
+    const req = transport.request(options, (res) => {
+        // Capture session ID from first response
+        const newSessionId = res.headers['mcp-session-id'];
+        if (newSessionId) {
+            sessionId = newSessionId;
+        }
+
+        let responseBody = '';
+
+        res.on('data', (chunk) => {
+            responseBody += chunk;
+        });
+
+        res.on('end', () => {
+            if (res.statusCode >= 400) {
+                log(`HTTP ${res.statusCode}: ${responseBody}`);
+
+                // If this was an initialize request and it failed, we need to send an error back
+                if (message.id !== undefined) {
+                    const errorResponse = {
+                        jsonrpc: '2.0',
+                        id: message.id,
+                        error: {
+                            code: -32603,
+                            message: `Remote server error: HTTP ${res.statusCode}`
+                        }
+                    };
+                    writeToStdout(errorResponse);
+                }
+                return;
+            }
+
+            // Handle JSON response (may contain multiple messages for batch)
+            if (responseBody.trim()) {
+                // Check if it's SSE format
+                if (res.headers['content-type']?.includes('text/event-stream')) {
+                    // Parse SSE events
+                    const events = responseBody.split('\n\n');
+                    for (const event of events) {
+                        const dataLine = event.split('\n').find(l => l.startsWith('data: '));
+                        if (dataLine) {
+                            try {
+                                const data = JSON.parse(dataLine.slice(6));
+                                writeToStdout(data);
+                            } catch (_) {}
+                        }
+                    }
+                } else {
+                    // JSON response
+                    try {
+                        const data = JSON.parse(responseBody);
+                        if (Array.isArray(data)) {
+                            // Batch response
+                            data.forEach(msg => writeToStdout(msg));
+                        } else {
+                            writeToStdout(data);
+                        }
+                    } catch (err) {
+                        log(`Failed to parse response: ${err.message}`);
+                    }
+                }
+            }
+        });
+    });
+
+    req.on('error', (err) => {
+        log(`Request failed: ${err.message}`);
+        if (message.id !== undefined) {
+            writeToStdout({
+                jsonrpc: '2.0',
+                id: message.id,
+                error: { code: -32603, message: `Connection failed: ${err.message}` }
+            });
+        }
+    });
+
+    req.write(body);
+    req.end();
+}
+
+// ─── Write JSON-RPC message to stdout ─────────────────────────────────────────
+
+function writeToStdout(message) {
+    const json = JSON.stringify(message);
+    process.stdout.write(json + '\n');
+}
+
+// ─── Logging (stderr only, never stdout) ──────────────────────────────────────
+
+function log(msg) {
+    process.stderr.write(`[stdio-bridge] ${msg}\n`);
+}
+
+log(`Bridge started → ${REMOTE_URL}`);
+log(`Auth: ${AUTH_HEADER ? 'configured' : 'none'}`);

package/src/tools/_helpers.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const logger = require('../utils/logger');
+
+function toolError(message, error) {
+    const detail = error?.body?.message || error?.message || 'Unknown error';
+    logger.error(message, {error: detail, status: error?.status});
+    return {
+        content: [{type: 'text', text: `Error: ${message}. ${detail}`}],
+        isError: true
+    };
+}
+
+function resolveServiceOrError(registry, serviceName) {
+    if (!registry.selectedApp) {
+        return {
+            content: [{type: 'text', text: 'No app selected. Use list_apps → select_app first.'}],
+            isError: true
+        };
+    }
+    const svc = registry.resolveService(serviceName);
+    if (!svc) {
+        const available = registry.getServiceList().map(s => s.name).join(', ');
+        return {
+            content: [{type: 'text', text: `Service '${serviceName}' not found. Available: ${available || 'none'}`}],
+            isError: true
+        };
+    }
+    return svc;
+}
+
+module.exports = {toolError, resolveServiceOrError};

package/src/tools/api-keys.js

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

package/src/tools/apps.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const {z} = require('zod');
+const {toolError} = require('./_helpers');
+
+module.exports = function registerAppsTools({server, dnioClient, authManager, registry, userContext}) {
+    server.registerTool(
+        'list_apps',
+        {
+            title: 'List Available Apps',
+            description: `List all apps on the DataNimbus BaaS platform.
+Use this FIRST, then 'select_app' to choose one before using data tools.`,
+            inputSchema: {},
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async () => {
+            try {
+                const adminToken = await authManager.getAdminToken();
+                dnioClient.setToken(adminToken);
+                const apps = await dnioClient.apps.list();
+                const appList = (apps || []).map(a => ({appName: a._id, description: a.description || '—'}));
+                dnioClient.setToken(userContext.token);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            platform: 'DataNimbus BaaS',
+                            user: userContext.email,
+                            selectedApp: registry.selectedApp || 'None (use select_app)',
+                            apps: appList
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to list apps', error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'select_app',
+        {
+            title: 'Select App',
+            description: `Select a DataNimbus app to work with. Discovers services, verifies pods, loads schemas.
+You MUST select an app before using data tools (list_records, create_record, etc.).
+
+Args:
+  - appName (string, required): App name (e.g. 'DebuggerDNIO')`,
+            inputSchema: {
+                appName: z.string().min(1).describe('App name to select')
+            },
+            annotations: {readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async ({appName}) => {
+            try {
+                await authManager.ensureUserAppAccess(appName);
+                const userToken = await authManager.getUserToken();
+                userContext.token = userToken;
+
+                const adminToken = await authManager.getAdminToken();
+                const {loaded, skipped} = await registry.loadApp(appName, adminToken, userContext.token);
+
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            action: 'app_selected',
+                            appName,
+                            user: userContext.email,
+                            services: loaded.map(s => ({
+                                name: s.name,
+                                serviceId: s.serviceId,
+                                apiPath: s.apiPath,
+                            })),
+                            skipped: skipped.length > 0 ? skipped : undefined,
+                            totalLoaded: loaded.length,
+                            usage: 'Use list_records, get_record, create_record, update_record, delete_record, count_records with serviceName parameter.'
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError(`Failed to select app '${appName}'`, error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'list_services',
+        {
+            title: 'List Data Services',
+            description: 'List all loaded data services for the currently selected app.',
+            inputSchema: {},
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async () => {
+            if (!registry.selectedApp) {
+                return {
+                    content: [{type: 'text', text: 'No app selected. Use list_apps → select_app first.'}],
+                    isError: true
+                };
+            }
+            const services = registry.getServiceList();
+            return {
+                content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        appName: registry.selectedApp,
+                        services: services.map(s => ({
+                            name: s.name,
+                            serviceId: s.serviceId,
+                            apiPath: s.apiPath,
+                            schema: s.schemaDesc
+                        }))
+                    }, null, 2)
+                }]
+            };
+        }
+    );
+
+    server.registerTool(
+        'refresh_services',
+        {
+            title: 'Refresh Data Services',
+            description: 'Re-scan the selected app for new/changed services. Requires an app to be selected.',
+            inputSchema: {},
+            annotations: {readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async () => {
+            if (!registry.selectedApp) {
+                return {content: [{type: 'text', text: 'No app selected. Use select_app first.'}], isError: true};
+            }
+            try {
+                const adminToken = await authManager.getAdminToken();
+                const {loaded, skipped} = await registry.loadApp(registry.selectedApp, adminToken, userContext.token);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            action: 'refreshed',
+                            appName: registry.selectedApp,
+                            loaded: loaded.map(s => s.name),
+                            skipped
+                        })
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to refresh services', error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'get_service_schema',
+        {
+            title: 'Get Service Schema',
+            description: `Get the full schema of a data service. Use before creating or querying data.
+Args: serviceName (string, required)`,
+            inputSchema: {serviceName: z.string().min(1).describe('Service name, prefix, or ID')},
+            annotations: {readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false}
+        },
+        async ({serviceName}) => {
+            if (!registry.selectedApp) return {content: [{type: 'text', text: 'No app selected.'}], isError: true};
+            const svc = registry.resolveService(serviceName);
+            if (!svc) return {content: [{type: 'text', text: `Service '${serviceName}' not found.`}], isError: true};
+            try {
+                const adminToken = await authManager.getAdminToken();
+                dnioClient.setToken(adminToken);
+                const schema = await dnioClient.services.getSchema(registry.selectedApp, svc.serviceId);
+                dnioClient.setToken(userContext.token);
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            serviceId: schema._id, name: schema.name, api: schema.api,
+                            attributeCount: schema.attributeCount, status: schema.status,
+                            definition: schema.definition
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError(`Failed to fetch schema for '${serviceName}'`, error);
+            }
+        }
+    );
+};

package/src/tools/bots.js

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

package/src/tools/connectors.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const {z} = require('zod');
+const {toolError} = require('./_helpers');
+
+module.exports = function registerConnectorsTools({server, dnioClient, registry, userContext}) {
+    server.registerTool(
+        'list_connectors',
+        {
+            title: 'List Connectors',
+            description: `List connectors available in the selected app. Connectors define WHERE a data service stores records (DB) and uploaded files (STORAGE). Call this BEFORE create_data_service so the user can confirm which connectors to use; if they don't specify, create_data_service will auto-attach the platform defaults.
+
+Args:
+  - category (optional): Filter by 'DB' (record storage) or 'STORAGE' (file storage). Omit for all.`,
+            inputSchema: {
+                category: z.enum(['DB', 'STORAGE']).optional().describe("Filter: 'DB' or 'STORAGE'. Omit for all.")
+            },
+            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.connectors.list(registry.selectedApp, {category: params.category});
+                const connectors = (Array.isArray(result) ? result : []).map(c => ({
+                    _id: c._id,
+                    name: c.name,
+                    category: c.category,
+                    subCategory: c.subCategory,
+                    type: c.type,
+                    isDefault: !!c.options?.default,
+                    isValid: !!c.options?.isValid
+                }));
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            app: registry.selectedApp,
+                            count: connectors.length,
+                            connectors,
+                            usage: "Pick a DB connector (category=DB) for 'connectors.data' and a STORAGE connector for 'connectors.file' when calling create_data_service."
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to list connectors', error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'list_connector_types',
+        {
+            title: 'List Available Connector Types',
+            description: `List all connector types available in the marketplace (e.g. MongoDB, S3, SFTP, ActiveMQ, SMTP). Each item shows the marketplace _id (use as 'marketItemId' for create_connector), label, type, category (DB / STORAGE / MESSAGING / etc.), tags, and the 'fields' schema describing what credentials each connector type requires.
+
+Call this BEFORE create_connector. Workflow: list types → user picks one → ask user for values for each entry in that type's 'fields' (use field 'key' as the JSON key) → call create_connector.
+
+Args:
+  - category (optional): Filter by category (e.g. 'DB', 'STORAGE', 'MESSAGING'). Omit for all.
+  - search (optional): Substring match against label, type, or tags. Omit for all.`,
+            inputSchema: {
+                category: z.string().optional().describe("Filter by category, e.g. 'DB' or 'STORAGE'."),
+                search: z.string().optional().describe('Substring match against label, type, or tags.')
+            },
+            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.connectors.listMarketTypes(registry.selectedApp);
+                let items = Array.isArray(result) ? result : [];
+                if (params.category) {
+                    const cat = params.category.toUpperCase();
+                    items = items.filter(i => (i.category || '').toUpperCase() === cat);
+                }
+                if (params.search) {
+                    const q = params.search.toLowerCase();
+                    items = items.filter(i =>
+                        (i.label || '').toLowerCase().includes(q) ||
+                        (i.type || '').toLowerCase().includes(q) ||
+                        (i.tags || '').toLowerCase().includes(q)
+                    );
+                }
+                const summary = items.map(i => ({
+                    marketItemId: i._id,
+                    type: i.type,
+                    label: i.label,
+                    category: i.category,
+                    tags: i.tags,
+                    version: i.version,
+                    fields: (i.fields || []).map(f => ({
+                        key: f.key,
+                        label: f.label,
+                        type: f.type,
+                        htmlInputType: f.htmlInputType,
+                        required: !!f.required,
+                        encrypted: !!f.encrypted
+                    }))
+                }));
+                return {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            app: registry.selectedApp,
+                            count: summary.length,
+                            types: summary,
+                            usage: "Pick a marketItemId and call create_connector with: name (display name) + values (object keyed by each field's 'key' from this type's fields config)."
+                        }, null, 2)
+                    }]
+                };
+            } catch (error) {
+                return toolError('Failed to list connector types', error);
+            }
+        }
+    );
+
+    server.registerTool(
+        'create_connector',
+        {
+            title: 'Create Connector',
+            description: `Create a new connector instance. Call list_connector_types FIRST to discover available types and their required field schemas.
+
+The platform's POST payload shape is:
+  { "name": "<display name>", "app": "<app>", "marketItemId": "<from list_connector_types>", "values": { <field key>: <value>, ... } }
+
+The tool injects 'app' from the currently selected app — you don't need to set it. Required fields ('required: true' in the type's fields config) MUST be present in 'values'; optional fields can be omitted. Encrypted fields ('encrypted: true', e.g. passwords/secrets) are sent as-is — the platform encrypts at rest.
+
+Args:
+  - name (required): Display name for the connector (e.g. 'My MongoDB Prod').
+  - marketItemId (required): _id of the connector type, from list_connector_types.
+  - values (required): JSON string keyed by each field's 'key' (e.g. '{"host":"...","port":1883,"username":"...","password":"..."}').`,
+            inputSchema: {
+                name: z.string().min(1).describe('Display name for the connector instance'),
+                marketItemId: z.string().min(1).describe("Marketplace item _id from list_connector_types (the connector type)"),
+                values: z.string().describe("JSON string of field values keyed by field 'key' from the type's fields config")
+            },
+            annotations: {destructiveHint: false, idempotentHint: false}
+        },
+        async (params) => {
+            if (!registry.selectedApp) {
+                return {content: [{type: 'text', text: 'No app selected. Use list_apps → select_app first.'}], isError: true};
+            }
+            try {
+                const values = JSON.parse(params.values);
+                const payload = {
+                    values,
+                    name: params.name,
+                    app: registry.selectedApp,
+                    marketItemId: params.marketItemId
+                };
+                dnioClient.setToken(userContext.token);
+                const result = await dnioClient.connectors.create(registry.selectedApp, payload);
+                return {content: [{type: 'text', text: JSON.stringify(result, null, 2)}]};
+            } catch (error) {
+                return toolError('Failed to create connector', error);
+            }
+        }
+    );
+};