@anyshift/mcp-proxy 0.6.9 → 0.6.10

package/dist/index.js

@@ -14,6 +14,7 @@
  * - Wrapper Mode: When MCP_PROXY_CHILD_COMMAND is set, wraps another MCP server
  * - Standalone Mode: When MCP_PROXY_CHILD_COMMAND is not set, provides only JQ tool
  */
+import * as Sentry from '@sentry/node';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
@@ -29,6 +30,21 @@ import { createFileWriter } from './fileWriter/index.js';
 import { generateToolId } from './utils/filename.js';
 import { PROXY_PARAMS } from './types/index.js';
 // ============================================================================
+// SENTRY INITIALIZATION
+// ============================================================================
+const MCP_NAME = process.env.MCP_PROXY_MCP_NAME || 'unknown';
+const SENTRY_DSN = process.env.SENTRY_DSN;
+const SENTRY_ENV = process.env.SENTRY_ENV;
+const SENTRY_TRACE_HEADER = process.env.SENTRY_TRACE_HEADER;
+const SENTRY_BAGGAGE_HEADER = process.env.SENTRY_BAGGAGE_HEADER;
+if (SENTRY_DSN) {
+    Sentry.init({
+        dsn: SENTRY_DSN,
+        environment: SENTRY_ENV,
+        tracesSampleRate: 1.0,
+    });
+}
+// ============================================================================
 // HELPER FUNCTIONS
 // ============================================================================
 /**
@@ -293,10 +309,12 @@ if (ENABLE_DOCS && DOCS_INDEXED_PATHS.length === 0) {
  */
 const childEnv = {};
 for (const [key, value] of Object.entries(process.env)) {
-    // Skip proxy configuration variables
     if (key.startsWith('MCP_PROXY_')) {
         continue;
     }
+    if (key === 'SENTRY_DSN' || key === 'SENTRY_ENV' || key === 'MCP_PROXY_MCP_NAME') {
+        continue;
+    }
     // Only include defined values
     if (value !== undefined) {
         childEnv[key] = value;
@@ -586,76 +604,225 @@ async function main() {
                 console.debug(`[mcp-proxy] Retry of: ${toolArgs.originalToolId}`);
             }
         }
-        try {
-            let result;
-            // Handle JQ tool locally (if enabled)
-            if (toolName === 'execute_jq_query' && jqTool) {
-                if (ENABLE_LOGGING) {
-                    console.debug('[mcp-proxy] Executing JQ tool locally');
-                }
-                result = await jqTool.handler({
-                    params: { arguments: toolArgs }
-                });
-                // JQ tool returns directly, wrap in unified format
-                const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
-                const unifiedResponse = createContentResponse(tool_id, result.content?.[0]?.text, toolArgs);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify(unifiedResponse, null, 2)
-                        }],
-                    isError: result.isError
-                };
-            }
-            // Handle Timeseries anomaly detection tool locally (if enabled)
-            if (toolName === 'detect_timeseries_anomalies' && timeseriesTool) {
-                if (ENABLE_LOGGING) {
-                    console.debug('[mcp-proxy] Executing Timeseries anomaly detection tool locally');
-                }
-                result = await timeseriesTool.handler({
-                    params: { arguments: toolArgs }
-                });
-                // Timeseries tool returns directly, wrap in unified format
-                const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
-                let outputContent = null;
-                if (result.content?.[0]?.text) {
-                    try {
-                        outputContent = JSON.parse(result.content[0].text);
-                    }
-                    catch {
-                        // If JSON parsing fails, use the raw text
-                        outputContent = result.content[0].text;
+        const executeToolCall = async () => {
+            try {
+                let result;
+                // Handle JQ tool locally (if enabled)
+                if (toolName === 'execute_jq_query' && jqTool) {
+                    if (ENABLE_LOGGING) {
+                        console.debug('[mcp-proxy] Executing JQ tool locally');
                     }
+                    result = await Sentry.startSpan({ name: toolName, op: 'mcp.tool_call.local' }, async () => {
+                        return await jqTool.handler({
+                            params: { arguments: toolArgs }
+                        });
+                    });
+                    // JQ tool returns directly, wrap in unified format
+                    const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
+                    const unifiedResponse = createContentResponse(tool_id, result.content?.[0]?.text, toolArgs);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify(unifiedResponse, null, 2)
+                            }],
+                        isError: result.isError
+                    };
                 }
-                const unifiedResponse = {
-                    tool_id,
-                    wroteToFile: false,
-                    outputContent
-                };
-                return {
-                    content: [{
-                            type: 'text',
-                            text: JSON.stringify(unifiedResponse, null, 2)
-                        }],
-                    isError: result.isError
-                };
-            }
-            // Handle Docs tools locally (if enabled)
-            // Route through file writer for large doc handling (same as child MCP tools)
-            const docsToolNames = ['docs_glob', 'docs_grep', 'docs_read'];
-            if (docsToolNames.includes(toolName) && docsTools.length > 0) {
-                const docTool = docsTools.find(t => t.toolDefinition.name === toolName);
-                if (docTool) {
+                // Handle Timeseries anomaly detection tool locally (if enabled)
+                if (toolName === 'detect_timeseries_anomalies' && timeseriesTool) {
                     if (ENABLE_LOGGING) {
-                        console.debug(`[mcp-proxy] Executing ${toolName} locally`);
+                        console.debug('[mcp-proxy] Executing Timeseries anomaly detection tool locally');
                     }
-                    try {
-                        result = await docTool.handler({
+                    result = await Sentry.startSpan({ name: toolName, op: 'mcp.tool_call.local' }, async () => {
+                        return await timeseriesTool.handler({
                             params: { arguments: toolArgs }
                         });
-                        const contentStr = result.content?.[0]?.text || '';
+                    });
+                    // Timeseries tool returns directly, wrap in unified format
+                    const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
+                    let outputContent = null;
+                    if (result.content?.[0]?.text) {
+                        try {
+                            outputContent = JSON.parse(result.content[0].text);
+                        }
+                        catch {
+                            // If JSON parsing fails, use the raw text
+                            outputContent = result.content[0].text;
+                        }
+                    }
+                    const unifiedResponse = {
+                        tool_id,
+                        wroteToFile: false,
+                        outputContent
+                    };
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify(unifiedResponse, null, 2)
+                            }],
+                        isError: result.isError
+                    };
+                }
+                // Handle Docs tools locally (if enabled)
+                // Route through file writer for large doc handling (same as child MCP tools)
+                const docsToolNames = ['docs_glob', 'docs_grep', 'docs_read'];
+                if (docsToolNames.includes(toolName) && docsTools.length > 0) {
+                    const docTool = docsTools.find(t => t.toolDefinition.name === toolName);
+                    if (docTool) {
+                        if (ENABLE_LOGGING) {
+                            console.debug(`[mcp-proxy] Executing ${toolName} locally`);
+                        }
+                        try {
+                            result = await Sentry.startSpan({ name: toolName, op: 'mcp.tool_call.local' }, async () => {
+                                return await docTool.handler({
+                                    params: { arguments: toolArgs }
+                                });
+                            });
+                            const contentStr = result.content?.[0]?.text || '';
+                            const originalLength = contentStr.length;
+                            // Route through file writer (same pipeline as child MCP tools)
+                            const unifiedResponse = await fileWriter.handleResponse(toolName, toolArgs, {
+                                content: [{ type: 'text', text: contentStr }]
+                            });
+                            if (ENABLE_LOGGING) {
+                                if (unifiedResponse.wroteToFile) {
+                                    console.debug(`[mcp-proxy] File written for ${toolName} (${originalLength} chars) → ${unifiedResponse.filePath}`);
+                                }
+                                else {
+                                    console.debug(`[mcp-proxy] Response for ${toolName} (${originalLength} chars) returned directly`);
+                                }
+                            }
+                            // If not written to file, apply truncation to outputContent
+                            if (!unifiedResponse.wroteToFile && unifiedResponse.outputContent) {
+                                const outputStr = typeof unifiedResponse.outputContent === 'string'
+                                    ? unifiedResponse.outputContent
+                                    : JSON.stringify(unifiedResponse.outputContent);
+                                const truncated = truncateResponseIfNeeded(truncationConfig, outputStr);
+                                if (truncated.length < outputStr.length) {
+                                    if (ENABLE_LOGGING) {
+                                        console.debug(`[mcp-proxy] Truncated response: ${outputStr.length} → ${truncated.length} chars`);
+                                    }
+                                    // Keep as string for docs (markdown content)
+                                    unifiedResponse.outputContent = truncated;
+                                }
+                            }
+                            // Add retry metadata and return unified response
+                            addRetryMetadata(unifiedResponse, toolArgs);
+                            return {
+                                content: [{
+                                        type: 'text',
+                                        text: JSON.stringify(unifiedResponse, null, 2)
+                                    }],
+                                isError: false
+                            };
+                        }
+                        catch (error) {
+                            const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
+                            return {
+                                content: [{
+                                        type: 'text',
+                                        text: JSON.stringify(createErrorResponse(tool_id, error.message || String(error), toolArgs), null, 2)
+                                    }],
+                                isError: true
+                            };
+                        }
+                    }
+                }
+                // Forward all other tools to child MCP (if child exists)
+                if (!childClient) {
+                    const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify(createErrorResponse(tool_id, `Tool ${toolName} not available in standalone mode (no child MCP)`, toolArgs), null, 2)
+                            }],
+                        isError: true
+                    };
+                }
+                if (ENABLE_LOGGING) {
+                    console.debug(`[mcp-proxy] Forwarding to child MCP: ${toolName}`);
+                }
+                // Sanitize arguments: remove proxy parameters that weren't in original tool schema
+                const sanitizedArgs = sanitizeToolArgs(toolName, toolArgs);
+                result = await Sentry.startSpan({ name: toolName, op: 'mcp.tool_call.remote' }, () => childClient.callTool({
+                    name: toolName,
+                    arguments: sanitizedArgs
+                }, undefined, {
+                    timeout: REQUEST_TIMEOUT_MS
+                }));
+                // Check if child MCP returned an error
+                const childReturnedError = !!result.isError;
+                // Preserve _meta from child response (e.g. parsed_commands) for passthrough
+                const childMeta = result._meta && typeof result._meta === 'object' && Object.keys(result._meta).length > 0
+                    ? result._meta
+                    : undefined;
+                // Process result through file writer to get unified response
+                if (result.content && Array.isArray(result.content) && result.content.length > 0) {
+                    // Extract text content and embedded resources from all content items
+                    const textContents = [];
+                    const resources = [];
+                    for (const item of result.content) {
+                        if (item.type === 'text' && typeof item.text === 'string') {
+                            textContents.push(item.text);
+                        }
+                        else if (item.type === 'resource' && item.resource) {
+                            // Handle EmbeddedResource - extract content from resource field
+                            const resource = item.resource;
+                            const resourceObj = {};
+                            if (resource.uri)
+                                resourceObj.uri = resource.uri;
+                            if (resource.mimeType)
+                                resourceObj.mimeType = resource.mimeType;
+                            // Content can be in 'text' (string) or 'blob' (base64 binary)
+                            if (resource.text) {
+                                resourceObj.content = resource.text;
+                            }
+                            else if (resource.blob) {
+                                // For binary content, keep as base64 or decode based on mimeType
+                                resourceObj.content = typeof resource.blob === 'string'
+                                    ? resource.blob
+                                    : Buffer.from(resource.blob).toString('base64');
+                            }
+                            resources.push(resourceObj);
+                        }
+                    }
+                    // Build combined content object
+                    let combinedContent;
+                    if (resources.length > 0) {
+                        // Has resources - combine text and resources into single object
+                        combinedContent = {
+                            text: textContents.length === 1 ? textContents[0] : textContents,
+                            resources: resources.length === 1 ? resources[0] : resources
+                        };
+                        if (ENABLE_LOGGING) {
+                            console.debug(`[mcp-proxy] Combined ${textContents.length} text items and ${resources.length} resources`);
+                        }
+                    }
+                    else if (textContents.length > 0) {
+                        // Text only - use first text content (original behavior)
+                        combinedContent = textContents[0];
+                    }
+                    if (combinedContent !== undefined) {
+                        const contentStr = typeof combinedContent === 'string'
+                            ? combinedContent
+                            : JSON.stringify(combinedContent);
                         const originalLength = contentStr.length;
-                        // Route through file writer (same pipeline as child MCP tools)
+                        // If child returned error, pass through directly without file writing
+                        if (childReturnedError) {
+                            const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
+                            if (ENABLE_LOGGING) {
+                                console.debug(`[mcp-proxy] Child MCP returned error for ${toolName}: ${contentStr.substring(0, 100)}...`);
+                            }
+                            return {
+                                content: [{
+                                        type: 'text',
+                                        text: JSON.stringify(createErrorResponse(tool_id, contentStr, toolArgs), null, 2)
+                                    }],
+                                isError: true,
+                                ...(childMeta ? { _meta: childMeta } : {})
+                            };
+                        }
+                        // Get unified response from file writer
                         const unifiedResponse = await fileWriter.handleResponse(toolName, toolArgs, {
                             content: [{ type: 'text', text: contentStr }]
                         });
@@ -677,191 +844,56 @@ async function main() {
                                 if (ENABLE_LOGGING) {
                                     console.debug(`[mcp-proxy] Truncated response: ${outputStr.length} → ${truncated.length} chars`);
                                 }
-                                // Keep as string for docs (markdown content)
-                                unifiedResponse.outputContent = truncated;
+                                // Re-parse if it was JSON, otherwise keep as string
+                                try {
+                                    unifiedResponse.outputContent = JSON.parse(truncated);
+                                }
+                                catch {
+                                    unifiedResponse.outputContent = truncated;
+                                }
                             }
                         }
-                        // Add retry metadata and return unified response
+                        // Add retry metadata and return unified response as JSON
                         addRetryMetadata(unifiedResponse, toolArgs);
                         return {
                             content: [{
                                     type: 'text',
                                     text: JSON.stringify(unifiedResponse, null, 2)
                                 }],
-                            isError: false
-                        };
-                    }
-                    catch (error) {
-                        const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify(createErrorResponse(tool_id, error.message || String(error), toolArgs), null, 2)
-                                }],
-                            isError: true
+                            isError: !!unifiedResponse.error,
+                            ...(childMeta ? { _meta: childMeta } : {})
                         };
                     }
                 }
+                // Fallback: return result with generated tool_id
+                const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify(createContentResponse(tool_id, result, toolArgs), null, 2)
+                        }],
+                    isError: childReturnedError,
+                    ...(childMeta ? { _meta: childMeta } : {})
+                };
             }
-            // Forward all other tools to child MCP (if child exists)
-            if (!childClient) {
+            catch (error) {
+                console.error(`[mcp-proxy] Error executing tool ${toolName}:`, error);
                 const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
                 return {
                     content: [{
                             type: 'text',
-                            text: JSON.stringify(createErrorResponse(tool_id, `Tool ${toolName} not available in standalone mode (no child MCP)`, toolArgs), null, 2)
+                            text: JSON.stringify(createErrorResponse(tool_id, `Error executing ${toolName}: ${error.message || String(error)}`, toolArgs), null, 2)
                         }],
                     isError: true
                 };
             }
-            if (ENABLE_LOGGING) {
-                console.debug(`[mcp-proxy] Forwarding to child MCP: ${toolName}`);
-            }
-            // Sanitize arguments: remove proxy parameters that weren't in original tool schema
-            const sanitizedArgs = sanitizeToolArgs(toolName, toolArgs);
-            result = await childClient.callTool({
-                name: toolName,
-                arguments: sanitizedArgs
-            }, undefined, {
-                timeout: REQUEST_TIMEOUT_MS
-            });
-            // Check if child MCP returned an error
-            const childReturnedError = !!result.isError;
-            // Preserve _meta from child response (e.g. parsed_commands) for passthrough
-            const childMeta = result._meta && typeof result._meta === 'object' && Object.keys(result._meta).length > 0
-                ? result._meta
-                : undefined;
-            // Process result through file writer to get unified response
-            if (result.content && Array.isArray(result.content) && result.content.length > 0) {
-                // Extract text content and embedded resources from all content items
-                const textContents = [];
-                const resources = [];
-                for (const item of result.content) {
-                    if (item.type === 'text' && typeof item.text === 'string') {
-                        textContents.push(item.text);
-                    }
-                    else if (item.type === 'resource' && item.resource) {
-                        // Handle EmbeddedResource - extract content from resource field
-                        const resource = item.resource;
-                        const resourceObj = {};
-                        if (resource.uri)
-                            resourceObj.uri = resource.uri;
-                        if (resource.mimeType)
-                            resourceObj.mimeType = resource.mimeType;
-                        // Content can be in 'text' (string) or 'blob' (base64 binary)
-                        if (resource.text) {
-                            resourceObj.content = resource.text;
-                        }
-                        else if (resource.blob) {
-                            // For binary content, keep as base64 or decode based on mimeType
-                            resourceObj.content = typeof resource.blob === 'string'
-                                ? resource.blob
-                                : Buffer.from(resource.blob).toString('base64');
-                        }
-                        resources.push(resourceObj);
-                    }
-                }
-                // Build combined content object
-                let combinedContent;
-                if (resources.length > 0) {
-                    // Has resources - combine text and resources into single object
-                    combinedContent = {
-                        text: textContents.length === 1 ? textContents[0] : textContents,
-                        resources: resources.length === 1 ? resources[0] : resources
-                    };
-                    if (ENABLE_LOGGING) {
-                        console.debug(`[mcp-proxy] Combined ${textContents.length} text items and ${resources.length} resources`);
-                    }
-                }
-                else if (textContents.length > 0) {
-                    // Text only - use first text content (original behavior)
-                    combinedContent = textContents[0];
-                }
-                if (combinedContent !== undefined) {
-                    const contentStr = typeof combinedContent === 'string'
-                        ? combinedContent
-                        : JSON.stringify(combinedContent);
-                    const originalLength = contentStr.length;
-                    // If child returned error, pass through directly without file writing
-                    if (childReturnedError) {
-                        const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
-                        if (ENABLE_LOGGING) {
-                            console.debug(`[mcp-proxy] Child MCP returned error for ${toolName}: ${contentStr.substring(0, 100)}...`);
-                        }
-                        return {
-                            content: [{
-                                    type: 'text',
-                                    text: JSON.stringify(createErrorResponse(tool_id, contentStr, toolArgs), null, 2)
-                                }],
-                            isError: true,
-                            ...(childMeta ? { _meta: childMeta } : {})
-                        };
-                    }
-                    // Get unified response from file writer
-                    const unifiedResponse = await fileWriter.handleResponse(toolName, toolArgs, {
-                        content: [{ type: 'text', text: contentStr }]
-                    });
-                    if (ENABLE_LOGGING) {
-                        if (unifiedResponse.wroteToFile) {
-                            console.debug(`[mcp-proxy] File written for ${toolName} (${originalLength} chars) → ${unifiedResponse.filePath}`);
-                        }
-                        else {
-                            console.debug(`[mcp-proxy] Response for ${toolName} (${originalLength} chars) returned directly`);
-                        }
-                    }
-                    // If not written to file, apply truncation to outputContent
-                    if (!unifiedResponse.wroteToFile && unifiedResponse.outputContent) {
-                        const outputStr = typeof unifiedResponse.outputContent === 'string'
-                            ? unifiedResponse.outputContent
-                            : JSON.stringify(unifiedResponse.outputContent);
-                        const truncated = truncateResponseIfNeeded(truncationConfig, outputStr);
-                        if (truncated.length < outputStr.length) {
-                            if (ENABLE_LOGGING) {
-                                console.debug(`[mcp-proxy] Truncated response: ${outputStr.length} → ${truncated.length} chars`);
-                            }
-                            // Re-parse if it was JSON, otherwise keep as string
-                            try {
-                                unifiedResponse.outputContent = JSON.parse(truncated);
-                            }
-                            catch {
-                                unifiedResponse.outputContent = truncated;
-                            }
-                        }
-                    }
-                    // Add retry metadata and return unified response as JSON
-                    addRetryMetadata(unifiedResponse, toolArgs);
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: JSON.stringify(unifiedResponse, null, 2)
-                            }],
-                        isError: !!unifiedResponse.error,
-                        ...(childMeta ? { _meta: childMeta } : {})
-                    };
-                }
-            }
-            // Fallback: return result with generated tool_id
-            const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(createContentResponse(tool_id, result, toolArgs), null, 2)
-                    }],
-                isError: childReturnedError,
-                ...(childMeta ? { _meta: childMeta } : {})
-            };
-        }
-        catch (error) {
-            console.error(`[mcp-proxy] Error executing tool ${toolName}:`, error);
-            const tool_id = generateToolId(toolName, toolArgs, fileWriterConfig.toolAbbreviations);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(createErrorResponse(tool_id, `Error executing ${toolName}: ${error.message || String(error)}`, toolArgs), null, 2)
-                    }],
-                isError: true
-            };
+        };
+        if (SENTRY_DSN && (SENTRY_TRACE_HEADER || SENTRY_BAGGAGE_HEADER)) {
+            const result = await Sentry.continueTrace({ sentryTrace: SENTRY_TRACE_HEADER || '', baggage: SENTRY_BAGGAGE_HEADER }, () => Sentry.startSpan({ name: `${MCP_NAME}/${toolName}`, op: 'mcp.tool_call' }, executeToolCall));
+            await Sentry.flush(2000);
+            return result;
         }
+        return executeToolCall();
     });
     // ------------------------------------------------------------------------
     // 8. CONNECT PROXY TO STDIO
@@ -870,8 +902,13 @@ async function main() {
     await server.connect(transport);
     console.debug('[mcp-proxy] Proxy server ready on stdio');
     console.debug('[mcp-proxy] Waiting for MCP protocol messages...');
-    // Prevent EPIPE from crashing the process
     process.on('SIGPIPE', () => { });
+    const shutdown = async () => {
+        await Sentry.close(2000);
+        process.exit(0);
+    };
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
 }
 // ============================================================================
 // START THE PROXY

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anyshift/mcp-proxy",
-  "version": "0.6.9",
+  "version": "0.6.10",
   "description": "Generic MCP proxy that adds truncation, file writing, and JQ capabilities to any MCP server",
   "type": "module",
   "main": "dist/index.js",
@@ -16,6 +16,7 @@
     "@modelcontextprotocol/sdk": "^1.24.0",
     "glob": "^13.0.0",
     "papaparse": "^5.5.3",
+    "@sentry/node": "^9.0.0",
     "zod": "^3.24.2"
   },
   "devDependencies": {