@datanimbus/dnio-mcp 1.0.0

package/src/clients/data-formats.js

@@ -0,0 +1,40 @@
+'use strict';
+
+class DataFormatsClient {
+    constructor(http) {
+        this.http = http;
+    }
+
+    _base(appName) {
+        return `api/a/bm/${appName}/dataFormat`;
+    }
+
+    list(appName, {filter, select, count = -1, page = 1} = {}) {
+        const params = new URLSearchParams();
+        params.set('filter', JSON.stringify({app: appName, ...(filter || {})}));
+        params.set('count', String(count));
+        params.set('page', String(page));
+        if (select) params.set('select', select);
+        return this.http.get(`${this._base(appName)}?${params.toString()}`);
+    }
+
+    get(appName, id) {
+        return this.http.get(`${this._base(appName)}/${id}`);
+    }
+
+    // Step 1: POST shell with empty definition. Platform assigns _id.
+    create(appName, payload) {
+        return this.http.post(this._base(appName), payload);
+    }
+
+    // Step 2 (and all attribute mutations): full PUT with populated definition.
+    update(appName, id, payload) {
+        return this.http.put(`${this._base(appName)}/${id}`, payload);
+    }
+
+    delete(appName, id) {
+        return this.http.delete(`${this._base(appName)}/${id}`);
+    }
+}
+
+module.exports = DataFormatsClient;

package/src/clients/data-pipes.js

@@ -0,0 +1,33 @@
+'use strict';
+
+class DataPipesClient {
+    constructor(http) {
+        this.http = http;
+    }
+
+    list(appName, {filter, select, count = -1} = {}) {
+        const params = new URLSearchParams();
+        params.set('filter', JSON.stringify({app: appName, ...(filter || {})}));
+        params.set('count', String(count));
+        if (select) params.set('select', select);
+        return this.http.get(`api/a/bm/${appName}/flow?${params.toString()}`);
+    }
+
+    get(appName, flowId) {
+        return this.http.get(`api/a/bm/${appName}/flow/${flowId}`);
+    }
+
+    create(appName, payload) {
+        return this.http.post(`api/a/bm/${appName}/flow`, payload);
+    }
+
+    update(appName, flowId, payload) {
+        return this.http.put(`api/a/bm/${appName}/flow/${flowId}`, payload);
+    }
+
+    publish(appName, flowId) {
+        return this.http.put(`api/a/bm/${appName}/flow/utils/${flowId}/publish`, {app: appName});
+    }
+}
+
+module.exports = DataPipesClient;

package/src/clients/deployment-groups.js

@@ -0,0 +1,59 @@
+'use strict';
+
+class DeploymentGroupsClient {
+    constructor(http) {
+        this.http = http;
+    }
+
+    _base(appName) {
+        return `api/a/bm/${appName}/deployment/group`;
+    }
+
+    listAvailableFlows(appName) {
+        const filter = encodeURIComponent(JSON.stringify({app: appName}));
+        return this.http.get(`${this._base(appName)}/utils/available/flows?filter=${filter}`);
+    }
+
+    list(appName, {filter, count = -1, select} = {}) {
+        const params = new URLSearchParams();
+        params.set('filter', JSON.stringify({app: appName, ...(filter || {})}));
+        params.set('count', String(count));
+        if (select) params.set('select', select);
+        return this.http.get(`${this._base(appName)}?${params.toString()}`);
+    }
+
+    get(appName, groupId) {
+        return this.http.get(`${this._base(appName)}/${groupId}`);
+    }
+
+    create(appName, payload) {
+        return this.http.post(this._base(appName), payload);
+    }
+
+    update(appName, groupId, payload) {
+        return this.http.put(`${this._base(appName)}/${groupId}`, payload);
+    }
+
+    start(appName, groupId) {
+        return this.http.put(`${this._base(appName)}/utils/${groupId}/start`, {});
+    }
+
+    stop(appName, groupId) {
+        return this.http.put(`${this._base(appName)}/utils/${groupId}/stop`, {});
+    }
+
+    sync(appName, groupId) {
+        return this.http.put(`${this._base(appName)}/utils/${groupId}/sync`, {});
+    }
+
+    delete(appName, groupId) {
+        return this.http.delete(`${this._base(appName)}/${groupId}`);
+    }
+
+    getYamls(appName, groupId) {
+        const filter = encodeURIComponent(JSON.stringify({app: appName}));
+        return this.http.get(`${this._base(appName)}/utils/${groupId}/yamls?filter=${filter}`);
+    }
+}
+
+module.exports = DeploymentGroupsClient;

package/src/clients/formulas.js

@@ -0,0 +1,10 @@
+'use strict';
+
+class FormulasClient {
+    constructor(http) {
+        this.http = http;
+    }
+    // TODO: implement DNIO formulas APIs
+}
+
+module.exports = FormulasClient;

package/src/clients/functions.js

@@ -0,0 +1,10 @@
+'use strict';
+
+class FunctionsClient {
+    constructor(http) {
+        this.http = http;
+    }
+    // TODO: implement DNIO functions APIs
+}
+
+module.exports = FunctionsClient;

package/src/clients/plugins.js

@@ -0,0 +1,39 @@
+'use strict';
+
+class PluginsClient {
+    constructor(http) {
+        this.http = http;
+    }
+
+    listMarketplace(appName, {page = 1, count = -1, select, sort = 'label', filter} = {}) {
+        const params = new URLSearchParams();
+        params.set('page', String(page));
+        params.set('count', String(count));
+        params.set('select', select || 'label,type,version,icon');
+        params.set('sort', sort);
+        params.set('filter', JSON.stringify(filter || {}));
+        return this.http.get(`api/a/bm/${appName}/marketplace/node?${params.toString()}`);
+    }
+
+    listInstalled(appName, {count = -1, select, filter} = {}) {
+        const params = new URLSearchParams();
+        params.set('count', String(count));
+        params.set('select', select || 'label,type,version,icon');
+        params.set('filter', JSON.stringify({app: appName, ...(filter || {})}));
+        return this.http.get(`api/a/bm/${appName}/my-node?${params.toString()}`);
+    }
+
+    install(appName, marketIds) {
+        return this.http.post(`api/a/bm/${appName}/my-node/utils/install`, {marketIds});
+    }
+
+    update(appName, ids) {
+        return this.http.post(`api/a/bm/${appName}/my-node/utils/update`, {app: appName, ids});
+    }
+
+    uninstall(appName, ids) {
+        return this.http.post(`api/a/bm/${appName}/my-node/utils/uninstall`, {app: appName, ids});
+    }
+}
+
+module.exports = PluginsClient;

package/src/clients/records.js

@@ -0,0 +1,51 @@
+'use strict';
+
+class RecordsClient {
+    constructor(http) {
+        this.http = http;
+    }
+
+    _endpoint(appName, servicePath, recordId) {
+        const base = `api/c/${appName}/${servicePath}`;
+        return recordId ? `${base}/${recordId}` : base;
+    }
+
+    list(appName, servicePath, {filter, sort, select, page = 1, count = 20, expand = false} = {}) {
+        const endpoint = this._endpoint(appName, servicePath);
+        const params = new URLSearchParams();
+        if (filter) params.set('filter', JSON.stringify(filter));
+        if (sort) params.set('sort', sort);
+        if (select) params.set('select', select);
+        params.set('page', String(page));
+        params.set('count', String(count));
+        if (expand) params.set('expand', 'true');
+        const qs = params.toString();
+        return this.http.get(`${endpoint}${qs ? '?' + qs : ''}`);
+    }
+
+    get(appName, servicePath, recordId, {expand = false} = {}) {
+        let endpoint = this._endpoint(appName, servicePath, recordId);
+        if (expand) endpoint += '?expand=true';
+        return this.http.get(endpoint);
+    }
+
+    create(appName, servicePath, data) {
+        return this.http.post(this._endpoint(appName, servicePath), data);
+    }
+
+    update(appName, servicePath, recordId, data) {
+        return this.http.put(this._endpoint(appName, servicePath, recordId), data);
+    }
+
+    delete(appName, servicePath, recordId) {
+        return this.http.delete(this._endpoint(appName, servicePath, recordId));
+    }
+
+    count(appName, servicePath, filter) {
+        let endpoint = this._endpoint(appName, servicePath) + '/utils/count';
+        if (filter) endpoint += `?filter=${encodeURIComponent(JSON.stringify(filter))}`;
+        return this.http.get(endpoint, {timeout: {request: 1000}});
+    }
+}
+
+module.exports = RecordsClient;

package/src/clients/services.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const logger = require('../utils/logger');
+
+class ServicesClient {
+    constructor(http) {
+        this.http = http;
+    }
+
+    _endpoint(appName, serviceId) {
+        const base = `api/a/sm/${appName}/service`;
+        return serviceId ? `${base}/${serviceId}` : base;
+    }
+
+    list(appName, {filter, select, count = -1} = {}) {
+        const params = new URLSearchParams();
+        params.set('filter', JSON.stringify({app: appName, ...(filter || {})}));
+        params.set('count', String(count));
+        if (select) params.set('select', select);
+        return this.http.get(`${this._endpoint(appName)}?${params.toString()}`);
+    }
+
+    getSchema(appName, serviceId) {
+        return this.http.get(`api/a/sm/${appName}/service/${serviceId}`);
+    }
+
+    create(appName, data) {
+        return this.http.post(this._endpoint(appName), data);
+    }
+
+    update(appName, serviceId, data) {
+        return this.http.put(this._endpoint(appName, serviceId), data);
+    }
+
+    get(appName, serviceId, {draft = false, select} = {}) {
+        const params = new URLSearchParams();
+        params.set('filter', JSON.stringify({app: appName}));
+        if (draft) params.set('draft', 'true');
+        if (select) params.set('select', select);
+        return this.http.get(`${this._endpoint(appName, serviceId)}?${params.toString()}`);
+    }
+
+    deploy(appName, serviceId) {
+        return this.http.put(`api/a/sm/${appName}/service/utils/${serviceId}/deploy`, {app: appName});
+    }
+
+    startStop(appName, serviceId, {start = true} = {}) {
+        const action = start ? 'start' : 'stop';
+        return this.http.put(`api/a/sm/${appName}/service/utils/${serviceId}/${action}`, {app: appName});
+    }
+
+    async verifyPod(appName, servicePath) {
+        try {
+            await this.http.records.count(appName, servicePath);
+            return true;
+        } catch (error) {
+            logger.warn(`Pod verification failed for ${appName}/${servicePath}: ${error.message}`);
+            return false;
+        }
+    }
+}
+
+module.exports = ServicesClient;

package/src/clients/user-groups.js

@@ -0,0 +1,10 @@
+'use strict';
+
+class UserGroupsClient {
+    constructor(http) {
+        this.http = http;
+    }
+    // TODO: implement DNIO user groups APIs
+}
+
+module.exports = UserGroupsClient;

package/src/clients/users.js

@@ -0,0 +1,10 @@
+'use strict';
+
+class UsersClient {
+    constructor(http) {
+        this.http = http;
+    }
+    // TODO: implement DNIO users APIs
+}
+
+module.exports = UsersClient;

package/src/examples/ai-sdk-client.js

@@ -0,0 +1,165 @@
+'use strict';
+
+/**
+ * AI SDK Integration Example
+ *
+ * Shows how to connect the DNIO MCP server to AI models via Vercel AI SDK.
+ * Supports: Google Vertex AI, OpenAI, Local Ollama
+ *
+ * Usage:
+ *   PROVIDER=vertex node src/examples/ai-sdk-client.js "List all contracts"
+ *   PROVIDER=openai node src/examples/ai-sdk-client.js "Create a party named Acme Corp"
+ *   PROVIDER=ollama node src/examples/ai-sdk-client.js "How many contracts exist?"
+ */
+
+// ─── Provider Setup ──────────────────────────────────────────────────────────
+
+function getModel() {
+    const provider = process.env.PROVIDER || 'vertex';
+
+    switch (provider) {
+        case 'vertex': {
+            const {createVertex} = require('@ai-sdk/google-vertex');
+            const vertex = createVertex({
+                project: process.env.GOOGLE_VERTEX_PROJECT || process.env.GOOGLE_CLOUD_PROJECT,
+                location: process.env.GOOGLE_VERTEX_LOCATION || 'us-central1',
+                ...(process.env.GOOGLE_CLIENT_EMAIL && {
+                    googleAuthOptions: {
+                        credentials: {
+                            client_email: process.env.GOOGLE_CLIENT_EMAIL,
+                            private_key: (process.env.GOOGLE_PRIVATE_KEY || '').replace(/\\n/g, '\n')
+                        }
+                    }
+                })
+            });
+            return vertex(process.env.AI_MODEL || 'gemini-2.5-flash');
+        }
+
+        case 'openai': {
+            const {createOpenAI} = require('@ai-sdk/openai');
+            const openai = createOpenAI({
+                apiKey: process.env.OPENAI_API_KEY,
+                ...(process.env.OPENAI_BASE_URL && {baseURL: process.env.OPENAI_BASE_URL})
+            });
+            return openai(process.env.AI_MODEL || 'gpt-4o');
+        }
+
+        case 'ollama': {
+            // Ollama is OpenAI-compatible, so we use the OpenAI provider with custom base URL
+            const {createOpenAI} = require('@ai-sdk/openai');
+            const ollama = createOpenAI({
+                baseURL: process.env.OLLAMA_BASE_URL || 'http://localhost:11434/v1',
+                apiKey: 'ollama' // Ollama doesn't need a real key
+            });
+            return ollama(process.env.AI_MODEL || 'llama3.1');
+        }
+
+        default:
+            throw new Error(`Unknown provider: ${provider}. Use 'vertex', 'openai', or 'ollama'`);
+    }
+}
+
+// ─── MCP Client Connection ───────────────────────────────────────────────────
+
+async function connectMCPClient() {
+    const {createMCPClient} = require('@ai-sdk/mcp');
+
+    const mcpTransport = process.env.MCP_TRANSPORT || 'stdio';
+
+    if (mcpTransport === 'http') {
+        // Connect to remote MCP server via HTTP
+        const mcpUrl = process.env.MCP_SERVER_URL || 'http://localhost:3100/mcp';
+        console.error(`Connecting to MCP server at ${mcpUrl}`);
+
+        return createMCPClient({
+            transport: {
+                type: 'http',
+                url: mcpUrl
+            }
+        });
+    } else {
+        // Spawn MCP server as subprocess (stdio)
+        const {Experimental_StdioMCPTransport} = require('@ai-sdk/mcp/mcp-stdio');
+
+        console.error('Starting MCP server via stdio...');
+        return createMCPClient({
+            transport: new Experimental_StdioMCPTransport({
+                command: 'node',
+                args: [require('path').resolve(__dirname, '../index.js')],
+                env: {
+                    ...process.env,
+                    TRANSPORT: 'stdio'
+                }
+            })
+        });
+    }
+}
+
+// ─── Main Agent Loop ─────────────────────────────────────────────────────────
+
+async function main() {
+    const prompt = process.argv[2];
+    if (!prompt) {
+        console.error('Usage: node ai-sdk-client.js "your question here"');
+        console.error('');
+        console.error('Environment variables:');
+        console.error('  PROVIDER=vertex|openai|ollama');
+        console.error('  MCP_TRANSPORT=stdio|http');
+        console.error('  MCP_SERVER_URL=http://localhost:3100/mcp (for http transport)');
+        console.error('  DNIO_BASE_URL, DNIO_TOKEN, DNIO_APP_NAME');
+        process.exit(1);
+    }
+
+    const {generateText} = require('ai');
+
+    let mcpClient;
+    try {
+        // 1. Get AI model
+        const model = getModel();
+        console.error(`Using model: ${process.env.AI_MODEL || 'default'} via ${process.env.PROVIDER || 'vertex'}`);
+
+        // 2. Connect to MCP server
+        mcpClient = await connectMCPClient();
+
+        // 3. Get tools from MCP server
+        const tools = await mcpClient.tools();
+        console.error(`Loaded ${Object.keys(tools).length} tools from MCP server`);
+
+        // 4. Run agent with tools
+        const result = await generateText({
+            model,
+            tools,
+            maxSteps: 10,
+            system: `You are a helpful assistant that manages data on the DataNimbus BaaS platform.
+You have access to tools for CRUD operations on various data services.
+
+Start by listing available data services if you need to understand what's available.
+Use the appropriate tools to fulfill user requests.
+Always confirm destructive operations before executing them.
+
+When creating records, make sure to follow the schema structure for each service.`,
+            messages: [{role: 'user', content: prompt}]
+        });
+
+        console.log('\n' + result.text);
+
+        // Show tool usage summary
+        if (result.steps?.length > 1) {
+            console.error(`\n--- Completed in ${result.steps.length} steps ---`);
+            for (const step of result.steps) {
+                if (step.toolCalls) {
+                    for (const call of step.toolCalls) {
+                        console.error(`  Tool: ${call.toolName}(${JSON.stringify(call.args).substring(0, 80)}...)`);
+                    }
+                }
+            }
+        }
+
+    } catch (error) {
+        console.error('Error:', error.message);
+        if (error.cause) console.error('Cause:', error.cause);
+        process.exit(1);
+    } finally {
+        if (mcpClient) await mcpClient.close();
+    }
+}

package/src/examples/claude_desktop_config.json

@@ -0,0 +1,34 @@
+{
+  "mcpServers": {
+    "dnio": {
+      "command": "node",
+      "args": [
+        "<ABSOLUTE_PATH_TO>/dnio-mcp-server/src/index.js"
+      ],
+      "env": {
+        "DNIO_BASE_URL": "<YOUR_DNIO_BASE_URL>",
+        "DNIO_USERNAME": "<DNIO_ADMIN_USERNAME>",
+        "DNIO_PASSWORD": "<DNIO_ADMIN_PASSWORD>",
+        "MCP_USER_EMAIL": "<MCP_USER_ACCOUNT_EMAIL>",
+        "MCP_USER_PASSWORD": "<MCP_USER_ACCOUNT_PASSWORD>",
+        "DNIO_TOKEN_TTL": "1800",
+        "DNIO_NAMESPACE": "DNIO",
+        "TRANSPORT": "stdio",
+        "LOG_LEVEL": "info"
+      }
+    },
+    "dnio-bridge": {
+      "command": "node",
+      "args": [
+        "<ABSOLUTE_PATH_TO>/dnio-mcp-server/src/stdio-bridge.js"
+      ],
+      "env": {
+        "MCP_REMOTE_URL": "http://localhost:3100/mcp"
+      }
+    },
+    "dnio-remote": {
+      "type": "streamable-http",
+      "url": "<YOUR_DEPLOYED_MCP_SERVER_URL>/mcp"
+    }
+  }
+}