@arcadialdev/arcality 4.0.2 → 4.1.1

package/src/services/mcpStdioClient.mjs

@@ -0,0 +1,204 @@
+import { spawn } from 'child_process';
+import path from 'path';
+
+const MCP_PROTOCOL_VERSION = '2024-11-05';
+
+function isPlainObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function getNestedValue(source, dottedPath) {
+    return String(dottedPath || '')
+        .split('.')
+        .filter(Boolean)
+        .reduce((current, key) => (current && Object.prototype.hasOwnProperty.call(current, key) ? current[key] : undefined), source);
+}
+
+function replaceEnvTokens(value, envSource = process.env) {
+    return String(value).replace(/\$\{([A-Z0-9_]+)\}/gi, (_, envName) => {
+        const resolved = envSource[envName];
+        return resolved === undefined ? '' : String(resolved);
+    });
+}
+
+export function resolveTemplateValue(value, context = {}, envSource = process.env) {
+    if (typeof value === 'string') {
+        const envResolved = replaceEnvTokens(value, envSource);
+        const exactMatch = envResolved.match(/^\{\{\s*([a-zA-Z0-9_.]+)\s*\}\}$/);
+        if (exactMatch) {
+            return getNestedValue(context, exactMatch[1]);
+        }
+
+        return envResolved.replace(/\{\{\s*([a-zA-Z0-9_.]+)\s*\}\}/g, (_, tokenPath) => {
+            const resolved = getNestedValue(context, tokenPath);
+            if (resolved === undefined || resolved === null) return '';
+            if (typeof resolved === 'string' || typeof resolved === 'number' || typeof resolved === 'boolean') {
+                return String(resolved);
+            }
+            return JSON.stringify(resolved);
+        });
+    }
+
+    if (Array.isArray(value)) {
+        return value.map(entry => resolveTemplateValue(entry, context, envSource));
+    }
+
+    if (isPlainObject(value)) {
+        return Object.fromEntries(
+            Object.entries(value).map(([key, entryValue]) => [key, resolveTemplateValue(entryValue, context, envSource)])
+        );
+    }
+
+    return value;
+}
+
+export function extractRowsFromMcpToolResult(result, preferredRowsPath = '') {
+    const candidate = preferredRowsPath ? getNestedValue(result, preferredRowsPath) : undefined;
+    if (Array.isArray(candidate)) return candidate;
+    if (Array.isArray(result?.rows)) return result.rows;
+
+    const content = Array.isArray(result?.content) ? result.content : [];
+    for (const item of content) {
+        if (!item || item.type !== 'text' || typeof item.text !== 'string') continue;
+        const text = item.text.trim();
+        if (!text) continue;
+
+        try {
+            const parsed = JSON.parse(text);
+            if (Array.isArray(parsed)) return parsed;
+            if (Array.isArray(parsed?.rows)) return parsed.rows;
+            if (preferredRowsPath) {
+                const nested = getNestedValue(parsed, preferredRowsPath);
+                if (Array.isArray(nested)) return nested;
+            }
+        } catch { }
+    }
+
+    return [];
+}
+
+function createFrame(message) {
+    const body = Buffer.from(JSON.stringify(message), 'utf8');
+    const header = Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, 'utf8');
+    return Buffer.concat([header, body]);
+}
+
+function createParser(onMessage) {
+    let buffer = Buffer.alloc(0);
+
+    return chunk => {
+        buffer = Buffer.concat([buffer, chunk]);
+
+        while (true) {
+            const separatorIndex = buffer.indexOf('\r\n\r\n');
+            if (separatorIndex === -1) return;
+
+            const headerText = buffer.slice(0, separatorIndex).toString('utf8');
+            const headers = headerText.split('\r\n');
+            const lengthHeader = headers.find(line => line.toLowerCase().startsWith('content-length:'));
+            if (!lengthHeader) {
+                throw new Error('Invalid MCP response: missing Content-Length header.');
+            }
+
+            const length = Number(lengthHeader.split(':')[1]?.trim() || 0);
+            const bodyStart = separatorIndex + 4;
+            const bodyEnd = bodyStart + length;
+            if (buffer.length < bodyEnd) return;
+
+            const body = buffer.slice(bodyStart, bodyEnd).toString('utf8');
+            buffer = buffer.slice(bodyEnd);
+            onMessage(JSON.parse(body));
+        }
+    };
+}
+
+export async function callMcpToolWithConfig(config, toolContext = {}) {
+    if (!config || !config.command) {
+        throw new Error('MCP configuration is missing the command field.');
+    }
+
+    const timeoutMs = Number(config.timeoutMs || toolContext.timeoutMs || 15000);
+    const command = resolveTemplateValue(config.command, toolContext);
+    const args = Array.isArray(config.args) ? resolveTemplateValue(config.args, toolContext) : [];
+    const envFromConfig = isPlainObject(config.env) ? resolveTemplateValue(config.env, toolContext) : {};
+    const cwd = config.cwd ? resolveTemplateValue(config.cwd, toolContext) : process.cwd();
+    const toolName = String(resolveTemplateValue(config.toolName || 'query', toolContext) || '').trim();
+    const toolArguments = isPlainObject(config.toolArguments)
+        ? resolveTemplateValue(config.toolArguments, toolContext)
+        : {};
+
+    const child = spawn(command, args, {
+        cwd: path.isAbsolute(cwd) ? cwd : path.join(process.cwd(), cwd),
+        env: { ...process.env, ...envFromConfig },
+        stdio: ['pipe', 'pipe', 'pipe'],
+        windowsHide: true
+    });
+
+    let requestId = 1;
+    const pending = new Map();
+    let startupError = '';
+
+    const parser = createParser(message => {
+        if (message.id && pending.has(message.id)) {
+            const entry = pending.get(message.id);
+            pending.delete(message.id);
+            if (message.error) {
+                entry.reject(new Error(message.error.message || 'Unknown MCP error.'));
+            } else {
+                entry.resolve(message.result);
+            }
+        }
+    });
+
+    child.stdout.on('data', chunk => parser(chunk));
+    child.stderr.on('data', chunk => {
+        startupError += chunk.toString('utf8');
+    });
+
+    child.on('error', error => {
+        for (const [, entry] of pending) entry.reject(error);
+        pending.clear();
+    });
+
+    const sendRequest = (method, params) => new Promise((resolve, reject) => {
+        const id = requestId++;
+        pending.set(id, { resolve, reject });
+        child.stdin.write(createFrame({ jsonrpc: '2.0', id, method, params }));
+    });
+
+    const sendNotification = (method, params) => {
+        child.stdin.write(createFrame({ jsonrpc: '2.0', method, params }));
+    };
+
+    const timeout = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`MCP tool call timed out after ${timeoutMs}ms.`)), timeoutMs);
+    });
+
+    try {
+        const result = await Promise.race([
+            (async () => {
+                await sendRequest('initialize', {
+                    protocolVersion: MCP_PROTOCOL_VERSION,
+                    capabilities: {},
+                    clientInfo: { name: 'arcality', version: '4.1.0' }
+                });
+                sendNotification('notifications/initialized', {});
+                return await sendRequest('tools/call', {
+                    name: toolName,
+                    arguments: toolArguments
+                });
+            })(),
+            timeout
+        ]);
+
+        return result;
+    } catch (error) {
+        const details = startupError.trim();
+        if (details) {
+            throw new Error(`${error.message} MCP stderr: ${details}`);
+        }
+        throw error;
+    } finally {
+        child.kill();
+    }
+}