@datanimbus/dnio-mcp 1.0.0

package/src/examples/express-integration.js

@@ -0,0 +1,181 @@
+'use strict';
+
+/**
+ * Express Agent Route Integration
+ *
+ * Shows how to integrate the DNIO MCP server tools into your existing
+ * Express-based agent service (the one using streamText + SSE).
+ *
+ * This is the bridge between your current architecture and MCP.
+ * You can use it alongside your existing tool-registry pattern.
+ */
+
+const {createMCPClient} = require('@ai-sdk/mcp');
+const logger = require('../utils/logger');
+
+// ─── MCP Client Singleton ────────────────────────────────────────────────────
+
+let _mcpClient = null;
+let _mcpTools = null;
+
+/**
+ * Get or create a singleton MCP client connected to the DNIO MCP server.
+ * For HTTP transport: connects to a running MCP server.
+ * For stdio: spawns the MCP server as a subprocess.
+ */
+async function getMCPTools() {
+    if (_mcpTools) return _mcpTools;
+
+    const mcpUrl = process.env.MCP_SERVER_URL;
+
+    if (mcpUrl) {
+        // Remote HTTP MCP server
+        _mcpClient = await createMCPClient({
+            transport: {type: 'http', url: mcpUrl}
+        });
+    } else {
+        // Local stdio MCP server (spawn as child process)
+        const {Experimental_StdioMCPTransport} = require('@ai-sdk/mcp/mcp-stdio');
+        const path = require('path');
+
+        _mcpClient = await createMCPClient({
+            transport: new Experimental_StdioMCPTransport({
+                command: 'node',
+                args: [path.resolve(__dirname, '../index.js')],
+                env: {...process.env, TRANSPORT: 'stdio'}
+            })
+        });
+    }
+
+    _mcpTools = await _mcpClient.tools();
+    logger.info(`Loaded ${Object.keys(_mcpTools).length} DNIO MCP tools`);
+    return _mcpTools;
+}
+
+/**
+ * Refresh MCP tools (call after data services change).
+ */
+async function refreshMCPTools() {
+    if (_mcpClient) {
+        await _mcpClient.close();
+        _mcpClient = null;
+        _mcpTools = null;
+    }
+    return getMCPTools();
+}
+
+/**
+ * Graceful shutdown.
+ */
+async function closeMCPClient() {
+    if (_mcpClient) {
+        await _mcpClient.close();
+        _mcpClient = null;
+        _mcpTools = null;
+    }
+}
+
+// ─── Integration with your existing agent service ────────────────────────────
+
+/**
+ * Example: Merge MCP tools with your existing tool registry.
+ *
+ * In your existing agent code, you have:
+ *   const {buildAISDKTools} = require('../tools/tool-registry');
+ *
+ * Replace or augment it with:
+ *   const allTools = await buildCombinedTools(existingTools);
+ */
+async function buildCombinedTools(existingTools = {}) {
+    try {
+        const mcpTools = await getMCPTools();
+        return {
+            ...existingTools,
+            ...mcpTools
+        };
+    } catch (error) {
+        logger.error('Failed to load MCP tools, using existing tools only', {error: error.message});
+        return existingTools;
+    }
+}
+
+// ─── Example: Drop-in agent route handler ────────────────────────────────────
+
+/**
+ * Example Express route handler that uses MCP tools with streamText.
+ *
+ * Mount this in your Express app:
+ *   const {agentHandler} = require('./mcp-integration/express-integration');
+ *   app.post('/api/agent/chat', agentHandler);
+ */
+async function agentHandler(req, res) {
+    const {streamText} = require('ai');
+    const model = _getModel(); // Use your existing model setup
+
+    try {
+        const tools = await buildCombinedTools();
+
+        const result = streamText({
+            model,
+            tools,
+            maxSteps: 10,
+            system: `You are a helpful assistant for the DataNimbus BaaS platform.
+You can manage data across multiple data services using the available tools.
+Use list_data_services to discover available services.
+Always explain what you're doing before making changes.`,
+            messages: req.body.messages || [{role: 'user', content: req.body.prompt}]
+        });
+
+        // SSE streaming response
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+
+        for await (const chunk of result.textStream) {
+            res.write(`data: ${JSON.stringify({type: 'text', content: chunk})}\n\n`);
+        }
+
+        res.write(`data: ${JSON.stringify({type: 'done'})}\n\n`);
+        res.end();
+
+    } catch (error) {
+        logger.error('Agent handler error', {error: error.message});
+        if (!res.headersSent) {
+            res.status(500).json({error: error.message});
+        }
+    }
+}
+
+// Helper: create model based on env (mirrors your existing config pattern)
+function _getModel() {
+    const provider = process.env.AI_PROVIDER || 'vertex';
+
+    switch (provider) {
+        case 'vertex': {
+            const {createVertex} = require('@ai-sdk/google-vertex');
+            return createVertex({
+                project: process.env.GOOGLE_VERTEX_PROJECT || process.env.GOOGLE_CLOUD_PROJECT,
+                location: process.env.GOOGLE_VERTEX_LOCATION || 'us-central1'
+            })(process.env.AI_MODEL || 'gemini-2.5-flash');
+        }
+        case 'openai': {
+            const {createOpenAI} = require('@ai-sdk/openai');
+            return createOpenAI({apiKey: process.env.OPENAI_API_KEY})(process.env.AI_MODEL || 'gpt-4o');
+        }
+        case 'ollama': {
+            const {createOpenAI} = require('@ai-sdk/openai');
+            return createOpenAI({
+                baseURL: process.env.OLLAMA_BASE_URL || 'http://localhost:11434/v1',
+                apiKey: 'ollama'
+            })(process.env.AI_MODEL || 'llama3.1');
+        }
+    }
+}
+
+module.exports = {
+    getMCPTools,
+    refreshMCPTools,
+    closeMCPClient,
+    buildCombinedTools,
+    agentHandler
+};

package/src/index.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+'use strict';
+
+require('dotenv').config({quiet: true});
+
+// Catch unhandled errors before they hit stdout
+process.on('uncaughtException', (err) => {
+    process.stderr.write(`[FATAL] Uncaught exception: ${err.message}\n${err.stack}\n`);
+    process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+    const msg = reason instanceof Error
+        ? `${reason.message}\n${reason.stack}`
+        : String(reason);
+    process.stderr.write(`[FATAL] Unhandled rejection: ${msg}\n`);
+});
+
+const {McpServer} = require('@modelcontextprotocol/sdk/server/mcp.js');
+const {StdioServerTransport} = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {StreamableHTTPServerTransport} = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+const express = require('express');
+
+const logger = require('./utils/logger');
+const DNIOClient = require('./services/dnio-client');
+const AuthManager = require('./services/auth-manager');
+const ServiceRegistry = require('./services/service-registry');
+const SessionManager = require('./services/session-manager');
+const registerAllTools = require('./tools/mcp-tools-registry');
+
+// Configuration — every credential is required from env, no hardcoded defaults.
+const required = (key) => {
+    const v = process.env[key];
+    if (!v) {
+        process.stderr.write(`[FATAL] Missing required env var: ${key}\n`);
+        process.exit(1);
+    }
+    return v;
+};
+
+const config = {
+    dnio: {
+        baseUrl: required('DNIO_BASE_URL'),
+        auth: {
+            username: required('DNIO_USERNAME'),
+            password: required('DNIO_PASSWORD'),
+        },
+        tokenTTL: parseInt(process.env.DNIO_TOKEN_TTL || '1800', 10),
+        namespace: process.env.DNIO_NAMESPACE || 'DNIO',
+    },
+    transport: process.env.TRANSPORT || 'stdio',
+    httpPort: parseInt(process.env.MCP_PORT || '3100'),
+};
+
+// MCP server factory
+function createMCPServer() {
+    return new McpServer({
+        name: 'dnio-mcp-server',
+        version: '2.0.0'
+    });
+}
+
+// STDIO transport
+async function runStdio() {
+
+    const dnioClient = new DNIOClient({baseUrl: config.dnio.baseUrl});
+
+    const authManager = new AuthManager(dnioClient, {
+        username: config.dnio.auth.username,
+        password: config.dnio.auth.password,
+        namespace: config.dnio.namespace,
+        tokenTTL: config.dnio.tokenTTL,
+    });
+
+    await authManager.initialize();
+
+    const userToken = await authManager.getUserToken();
+    const mcpCreds = authManager.getMcpUserCredentials();
+
+    const userContext = {
+        email: mcpCreds.email,
+        password: mcpCreds.password,
+        token: userToken,
+    };
+
+    const registry = new ServiceRegistry(dnioClient);
+    const server = createMCPServer();
+
+    registerAllTools(server, dnioClient, authManager, registry, userContext);
+
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+
+    logger.info('DNIO MCP server running on stdio');
+
+    process.on('SIGINT', () => {
+        authManager.destroy();
+        process.exit(0);
+    });
+}
+
+// HTTP transport
+async function runHTTP() {
+
+    const adminClient = new DNIOClient({baseUrl: config.dnio.baseUrl});
+
+    const authManager = new AuthManager(adminClient, {
+        username: config.dnio.auth.username,
+        password: config.dnio.auth.password,
+        namespace: config.dnio.namespace,
+        tokenTTL: config.dnio.tokenTTL,
+    });
+
+    await authManager.initialize();
+
+    const sessionManager = new SessionManager();
+    const app = express();
+    app.use(express.json());
+
+    // CORS
+    app.use((req, res, next) => {
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, DELETE');
+        res.header(
+            'Access-Control-Allow-Headers',
+            'Content-Type, Authorization, Mcp-Session-Id, x-dnio-username, x-dnio-password, x-mcp-proxy-auth'
+        );
+        res.header('Access-Control-Expose-Headers', 'Mcp-Session-Id');
+        if (req.method === 'OPTIONS') return res.sendStatus(204);
+        next();
+    });
+
+    // ─── Skip OAuth discovery (server is authless) ─────────────
+    app.get('/.well-known/oauth-authorization-server', (req, res) => {
+        res.status(404).json({error: 'This server is authless. No OAuth required.'});
+    });
+    app.get('/.well-known/oauth-protected-resource', (req, res) => {
+        res.status(404).json({error: 'This server is authless. No OAuth required.'});
+    });
+
+    // Health
+    app.get('/health', (req, res) => {
+        res.json({
+            status: 'ok',
+            server: 'dnio-mcp-server',
+            version: '2.0.0',
+            transport: 'http',
+            activeSessions: sessionManager.activeCount,
+        });
+    });
+
+    // Sessions debug
+    app.get('/sessions', (req, res) => {
+        if (req.query.key !== config.dnio.auth.password) {
+            return res.status(401).json({error: 'Unauthorized'});
+        }
+        res.json({sessions: sessionManager.getSummary()});
+    });
+
+    // MCP POST
+    app.post('/mcp', async (req, res) => {
+        try {
+            const mcpSessionId = req.headers['mcp-session-id'];
+
+            if (mcpSessionId) {
+                const session = sessionManager.getSession(mcpSessionId);
+                if (session && session.transport) {
+                    await session.transport.handleRequest(req, res, req.body);
+                    return;
+                }
+            }
+
+            const userToken = await authManager.getUserToken();
+            const mcpCreds = authManager.getMcpUserCredentials();
+
+            const session = sessionManager.createSession({
+                email: mcpCreds.email,
+                dnioToken: userToken,
+                tokenExpiresAt: authManager.userExpiresAt,
+            });
+
+            const userClient = new DNIOClient({
+                baseUrl: config.dnio.baseUrl,
+                token: userToken
+            });
+
+            const registry = new ServiceRegistry(userClient);
+
+            const userContext = {
+                email: mcpCreds.email,
+                password: mcpCreds.password,
+                token: userToken,
+            };
+
+            const mcpServer = createMCPServer();
+            registerAllTools(mcpServer, userClient, authManager, registry, userContext);
+
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => session.sessionId,
+                enableJsonResponse: true,
+            });
+
+            session.transport = transport;
+            session.server = mcpServer;
+            session.registry = registry;
+
+            transport.onclose = () => {
+                if (sessionManager.getSession(session.sessionId)) {
+                    sessionManager.destroySession(session.sessionId);
+                }
+            };
+
+            await mcpServer.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+
+        } catch (error) {
+            logger.error('MCP request failed', {error: error.message});
+            if (!res.headersSent) {
+                res.status(500).json({error: 'Internal server error'});
+            }
+        }
+    });
+
+    // MCP GET (SSE)
+    app.get('/mcp', async (req, res) => {
+        const sessionId = req.headers['mcp-session-id'];
+        if (!sessionId) {
+            return res.status(400).json({error: 'Mcp-Session-Id header required'});
+        }
+
+        const session = sessionManager.getSession(sessionId);
+        if (!session || !session.transport) {
+            return res.status(404).json({error: 'Session not found'});
+        }
+
+        await session.transport.handleRequest(req, res);
+    });
+
+    // MCP DELETE
+    app.delete('/mcp', async (req, res) => {
+        const sessionId = req.headers['mcp-session-id'];
+
+        if (sessionId) {
+            const session = sessionManager.getSession(sessionId);
+            if (session && session.transport) {
+                await session.transport.handleRequest(req, res);
+                sessionManager.destroySession(sessionId);
+                return;
+            }
+        }
+
+        res.status(404).json({error: 'Session not found'});
+    });
+
+    app.listen(config.httpPort, () => {
+        logger.info(`DNIO MCP server on http://localhost:${config.httpPort}/mcp`);
+    });
+
+    const shutdown = () => {
+        sessionManager.shutdown();
+        authManager.destroy();
+        process.exit(0);
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+
+// Start
+const transportType = config.transport;
+logger.info(`Starting DNIO MCP server v1.0.0 (transport: ${transportType})`);
+
+if (transportType === 'http') {
+    runHTTP().catch(err => {
+        logger.error('Startup failed', {error: err.message});
+        process.exit(1);
+    });
+} else {
+    runStdio().catch(err => {
+        logger.error('Startup failed', {error: err.message});
+        process.exit(1);
+    });
+}

package/src/schemas/schema-converter.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const {z} = require('zod');
+const logger = require('../utils/logger');
+
+/**
+ * Converts a DNIO Data Service schema definition into Zod schemas
+ * used by MCP tool inputSchema.
+ *
+ * DNIO schemas are JSON objects with a `definition` array, where each
+ * element has: { key, type, properties, definition (for nested) }
+ *
+ * Supported DNIO types: String, Number, Boolean, Date, Object, Array, Relation (Object)
+ */
+
+// ─── Primitive converters ────────────────────────────────────────────────────
+
+function dnioTypeToZod(field) {
+    const type = field.type;
+    const props = field.properties || {};
+    const desc = props.name || field.key;
+
+    switch (type) {
+        case 'String':
+            return z.string().optional().describe(desc);
+
+        case 'Number': {
+            let schema = z.number();
+            if (props.precision != null) {
+                schema = schema.describe(`${desc} (precision: ${props.precision})`);
+            } else {
+                schema = schema.describe(desc);
+            }
+            return schema.optional();
+        }
+
+        case 'Boolean':
+            return z.boolean().optional().describe(desc);
+
+        case 'Date':
+            return z.string().optional().describe(`${desc} (ISO 8601 date string)`);
+
+        case 'Object':
+            return buildObjectSchema(field.definition || []).optional().describe(desc);
+
+        case 'Array':
+            return buildArraySchema(field).optional().describe(desc);
+
+        default:
+            logger.warn(`Unknown DNIO type '${type}' for field '${field.key}', defaulting to string`);
+            return z.any().optional().describe(desc);
+    }
+}
+
+function buildObjectSchema(definition) {
+    const shape = {};
+    for (const field of definition) {
+        if (field.key === '_self') continue; // skip array wrapper markers
+        shape[field.key] = dnioTypeToZod(field);
+    }
+    return z.object(shape);
+}
+
+function buildArraySchema(field) {
+    const innerDef = field.definition || [];
+    if (innerDef.length === 0) {
+        return z.array(z.any());
+    }
+
+    // If the inner type is _self with a primitive, it's a simple array
+    const selfField = innerDef.find(f => f.key === '_self');
+    if (selfField) {
+        if (selfField.type === 'Object' && selfField.definition) {
+            // Array of objects
+            return z.array(buildObjectSchema(selfField.definition));
+        }
+        // Array of primitives
+        return z.array(dnioTypeToZod({...selfField, key: field.key}));
+    }
+
+    // Otherwise it's an array of objects
+    return z.array(buildObjectSchema(innerDef));
+}
+
+// ─── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Convert a DNIO service definition array into a Zod schema for record creation.
+ * Excludes _id (auto-generated) and internal fields.
+ *
+ * @param {Array} definition - DNIO service `definition` array
+ * @returns {z.ZodObject} Zod schema for creating a record
+ */
+function definitionToCreateSchema(definition) {
+    const shape = {};
+    for (const field of definition) {
+        // Skip _id (auto-generated), _metadata, __v, and internal fields
+        if (['_id', '_metadata', '__v'].includes(field.key)) continue;
+
+        // For Relation types (stored as Object with _id, _href), just accept the _id
+        if (field.properties?._typeChanged === 'Relation') {
+            shape[field.key] = z.object({
+                _id: z.string().describe(`${field.properties.name || field.key} - related record ID`)
+            }).optional().describe(field.properties.name || field.key);
+            continue;
+        }
+
+        // For secure/password fields, accept plain string (encryption handled server-side)
+        if (field.properties?.password) {
+            shape[field.key] = z.string().optional().describe(
+                `${field.properties.name || field.key} (secure field)`
+            );
+            continue;
+        }
+
+        shape[field.key] = dnioTypeToZod(field);
+    }
+    return z.object(shape);
+}
+
+/**
+ * Convert a DNIO service definition into a Zod schema for record updates.
+ * Same as create but all fields are optional (partial update).
+ *
+ * @param {Array} definition - DNIO service `definition` array
+ * @returns {z.ZodObject} Zod schema for updating a record
+ */
+function definitionToUpdateSchema(definition) {
+    return definitionToCreateSchema(definition).partial();
+}
+
+/**
+ * Generate a human-readable schema description string for LLM context.
+ *
+ * @param {Array} definition - DNIO service `definition` array
+ * @param {number} [indent=0] - indentation depth
+ * @returns {string} Formatted schema description
+ */
+function schemaToDescription(definition, indent = 0) {
+    const lines = [];
+    const pad = '  '.repeat(indent);
+
+    for (const field of definition) {
+        if (['_metadata', '__v'].includes(field.key)) continue;
+
+        const name = field.properties?.name || field.key;
+        const required = field.properties?.required ? ' (required)' : '';
+        const type = field.properties?._typeChanged === 'Relation'
+            ? `Relation → ${field.properties.relatedTo}`
+            : field.type;
+
+        let line = `${pad}- ${field.key}: ${type}${required}`;
+        if (name !== field.key) line += ` // ${name}`;
+
+        lines.push(line);
+
+        // Recurse into nested objects/arrays
+        if (field.definition && field.key !== '_self') {
+            const nested = field.definition.filter(f => f.key !== '_self');
+            if (nested.length > 0) {
+                lines.push(schemaToDescription(nested, indent + 1));
+            }
+            // For arrays with _self object defs
+            const selfObj = field.definition.find(f => f.key === '_self' && f.definition);
+            if (selfObj?.definition) {
+                lines.push(schemaToDescription(selfObj.definition, indent + 1));
+            }
+        }
+    }
+    return lines.join('\n');
+}
+
+module.exports = {
+    definitionToCreateSchema,
+    definitionToUpdateSchema,
+    schemaToDescription,
+    dnioTypeToZod,
+    buildObjectSchema
+};