@anyshift/mcp-proxy 0.2.0

package/dist/fileWriter/writer.js

@@ -0,0 +1,277 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { generateCompactFilename } from '../utils/filename.js';
+import { analyzeJsonSchema, extractNullableFields } from './schema.js';
+// Default minimum character count to trigger file writing
+const DEFAULT_MIN_CHARS = 1000;
+/**
+ * Helper function to detect if a response contains an error
+ */
+const isErrorResponse = (response) => {
+    if (!response || typeof response !== 'object')
+        return false;
+    const obj = response;
+    // Check MCP-level error flags first
+    if (obj.error || obj.isError) {
+        return true;
+    }
+    // For MCP responses, extract and parse the raw text to check for API-level errors
+    const rawText = extractRawText(obj);
+    if (rawText) {
+        try {
+            // Handle cases where text might contain "Listed incidents: {...}" or "Queried metrics data: {...}"
+            let jsonText = rawText;
+            // Extract JSON from common response patterns
+            const jsonMatch = rawText.match(/:\s*(\{.*\}|\[.*\])$/s);
+            if (jsonMatch) {
+                jsonText = jsonMatch[1];
+            }
+            // Try to parse as JSON to check for status: "error"
+            const parsed = JSON.parse(jsonText);
+            return parsed.status === 'error';
+        }
+        catch {
+            // If JSON parsing fails, fall back to string matching
+            return (rawText.includes('"status":"error"') ||
+                rawText.includes('"status": "error"'));
+        }
+    }
+    // Fallback: check if the response object directly has status === 'error'
+    return obj.status === 'error';
+};
+/**
+ * Helper function to extract error message from API error responses
+ */
+const extractErrorMessage = (response) => {
+    if (!response || typeof response !== 'object') {
+        return 'Unknown error occurred';
+    }
+    const obj = response;
+    // Check for direct error properties first
+    if (obj.error && typeof obj.error === 'string') {
+        return obj.error;
+    }
+    // For MCP responses, extract error from parsed content
+    const rawText = extractRawText(obj);
+    if (rawText) {
+        try {
+            // Handle cases where text might contain "Listed incidents: {...}" or "Queried metrics data: {...}"
+            let jsonText = rawText;
+            // Extract JSON from common response patterns
+            const jsonMatch = rawText.match(/:\s*(\{.*\}|\[.*\])$/s);
+            if (jsonMatch) {
+                jsonText = jsonMatch[1];
+            }
+            const parsed = JSON.parse(jsonText);
+            // Try different error message fields
+            if (parsed.error && typeof parsed.error === 'string') {
+                return parsed.error;
+            }
+            if (parsed.message && typeof parsed.message === 'string') {
+                return parsed.message;
+            }
+            if (parsed.status === 'error') {
+                return 'API request failed with error status';
+            }
+        }
+        catch {
+            // If JSON parsing fails, look for error patterns in the raw text
+            const errorMatch = rawText.match(/"error":\s*"([^"]+)"/);
+            if (errorMatch && errorMatch[1]) {
+                return errorMatch[1];
+            }
+            const messageMatch = rawText.match(/"message":\s*"([^"]+)"/);
+            if (messageMatch && messageMatch[1]) {
+                return messageMatch[1];
+            }
+        }
+    }
+    return 'API error occurred';
+};
+/**
+ * Extract raw text from MCP response format
+ */
+const extractRawText = (response) => {
+    if (response._rawText) {
+        return response._rawText;
+    }
+    if (response.content && Array.isArray(response.content)) {
+        const textContent = response.content
+            .filter((item) => item.type === 'text')
+            .map((item) => item.text)
+            .join('\n');
+        return textContent || null;
+    }
+    return null;
+};
+/**
+ * Centralized response handler with file writing capability
+ * @param config - File writer configuration
+ * @param toolName - Name of the tool that generated the response
+ * @param args - Arguments passed to the tool
+ * @param responseData - The response data to potentially write to file
+ * @returns Either the original response or a file reference response
+ */
+export async function handleToolResponse(config, toolName, args, responseData) {
+    // JQ query tool should always return directly to AI (never write to file)
+    if (toolName === 'execute_jq_query') {
+        return responseData;
+    }
+    // If there's an error, return proper MCP error response (never write errors to file)
+    if (isErrorResponse(responseData)) {
+        const errorMessage = extractErrorMessage(responseData);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    // If file writing is disabled, just return the response
+    if (!config.enabled || !config.outputPath) {
+        return responseData;
+    }
+    // Check character count threshold - if response is too short, return directly
+    const rawText = extractRawText(responseData);
+    let contentLength = 0;
+    if (rawText) {
+        contentLength = rawText.length;
+    }
+    else if (responseData &&
+        typeof responseData === 'object' &&
+        'content' in responseData &&
+        Array.isArray(responseData.content)) {
+        const textContent = responseData.content
+            .filter((item) => item.type === 'text')
+            .map((item) => item.text)
+            .join('\n');
+        contentLength = textContent.length;
+    }
+    else {
+        contentLength = JSON.stringify(responseData).length;
+    }
+    // If content is shorter than threshold, return response directly instead of writing to file
+    const minChars = config.minCharsForWrite ?? DEFAULT_MIN_CHARS;
+    if (contentLength < minChars) {
+        return responseData;
+    }
+    // Success case: write to file
+    try {
+        // Create compact, LLM-friendly filename
+        const filename = generateCompactFilename(toolName, args, config.toolAbbreviations);
+        const filepath = path.join(config.outputPath, filename);
+        // Ensure output directory exists
+        await fs.mkdir(config.outputPath, { recursive: true });
+        // Extract the actual data from MCP response format
+        let contentToWrite;
+        let parsedForSchema;
+        if (rawText) {
+            try {
+                // Try to parse the raw text as JSON for prettier formatting
+                let jsonText = rawText;
+                // Extract JSON from common response patterns
+                const jsonMatch = rawText.match(/:\s*(\{.*\}|\[.*\])$/s);
+                if (jsonMatch) {
+                    jsonText = jsonMatch[1];
+                }
+                const parsed = JSON.parse(jsonText);
+                parsedForSchema = parsed;
+                // Remove pagination-related fields before writing
+                const { pagination, has_more, next_page, previous_page, page, page_size, total_pages, ...cleanData } = parsed;
+                contentToWrite = JSON.stringify(cleanData, null, 2);
+            }
+            catch {
+                // If parsing fails, write the raw text directly
+                contentToWrite = rawText;
+            }
+        }
+        else {
+            // Fallback: extract from display content or stringify the entire response
+            if (responseData &&
+                typeof responseData === 'object' &&
+                'content' in responseData &&
+                Array.isArray(responseData.content)) {
+                const textContent = responseData.content
+                    .filter((item) => item.type === 'text')
+                    .map((item) => item.text)
+                    .join('\n');
+                contentToWrite = textContent;
+            }
+            else {
+                contentToWrite = JSON.stringify(responseData, null, 2);
+            }
+        }
+        await fs.writeFile(filepath, contentToWrite);
+        // Try to generate schema if we have valid JSON
+        let schemaInfo = '';
+        let quickReference = '';
+        if (parsedForSchema) {
+            // Use the clean data (without pagination) for schema analysis
+            const { pagination, has_more, next_page, previous_page, page, page_size, total_pages, ...cleanData } = parsedForSchema;
+            const schema = analyzeJsonSchema(cleanData);
+            const nullFields = extractNullableFields(schema);
+            const schemaObj = schema;
+            // Build quick reference section
+            quickReference += `\n\n🔍 UNDERSTAND THIS SCHEMA BEFORE WRITING JQ QUERIES:\n`;
+            // Structure hints
+            if (schemaObj._keysAreNumeric) {
+                quickReference += `   • Structure: Object with numeric keys ("0", "1", ...) - use .["0"]\n`;
+            }
+            else if (schemaObj.type === 'array') {
+                quickReference += `   • Structure: Array with ${schemaObj.length} items\n`;
+            }
+            else if (schemaObj.type === 'object' && schemaObj.properties) {
+                const props = schemaObj.properties;
+                const keys = Object.keys(props).slice(0, 5).join(', ');
+                quickReference += `   • Structure: Object with keys: ${keys}\n`;
+            }
+            // Always null fields
+            if (nullFields.alwaysNull.length > 0) {
+                const fieldList = nullFields.alwaysNull.slice(0, 5).join(', ');
+                const more = nullFields.alwaysNull.length > 5
+                    ? ` (+${nullFields.alwaysNull.length - 5} more)`
+                    : '';
+                quickReference += `   • Always null: ${fieldList}${more}\n`;
+            }
+            // Nullable fields
+            if (nullFields.nullable.length > 0) {
+                const fieldList = nullFields.nullable.slice(0, 5).join(', ');
+                const more = nullFields.nullable.length > 5
+                    ? ` (+${nullFields.nullable.length - 5} more)`
+                    : '';
+                quickReference += `   • Sometimes null: ${fieldList}${more}\n`;
+            }
+            // Suggest exploratory queries
+            if (schemaObj._keysAreNumeric) {
+                quickReference += `   • Explore: keys, .["0"] | keys, .["0"]\n`;
+            }
+            else if (schemaObj.type === 'array' && schemaObj.length > 0) {
+                quickReference += `   • Explore: length, .[0] | keys, .[0]\n`;
+            }
+            else {
+                quickReference += `   • Explore: keys, type\n`;
+            }
+            // Full schema
+            schemaInfo = `\n\nFull JSON Schema:\n${JSON.stringify(schema, null, 2)}`;
+        }
+        // Count lines in the content
+        const lineCount = contentToWrite.split('\n').length;
+        // Return success message with file path, size, lines, quick reference, and schema
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `📄 File: ${filepath}\nSize: ${contentToWrite.length} characters | Lines: ${lineCount}${quickReference}${schemaInfo}`,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        // If file writing fails, return the original response
+        console.error(`[handleToolResponse] Error writing file:`, error);
+        return responseData;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Generic MCP Proxy
+ *
+ * A universal wrapper for ANY Model Context Protocol (MCP) server that adds:
+ * 1. Response truncation (to stay within token limits)
+ * 2. Automatic file writing (for large responses)
+ * 3. JQ tool (for querying saved JSON files)
+ *
+ * This proxy is completely MCP-agnostic and works with any MCP server through
+ * a clean environment variable contract.
+ *
+ * MODES:
+ * - 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
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,346 @@
+#!/usr/bin/env node
+/**
+ * Generic MCP Proxy
+ *
+ * A universal wrapper for ANY Model Context Protocol (MCP) server that adds:
+ * 1. Response truncation (to stay within token limits)
+ * 2. Automatic file writing (for large responses)
+ * 3. JQ tool (for querying saved JSON files)
+ *
+ * This proxy is completely MCP-agnostic and works with any MCP server through
+ * a clean environment variable contract.
+ *
+ * MODES:
+ * - 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 { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { createJqTool } from './jq/index.js';
+import { truncateResponseIfNeeded } from './truncation/index.js';
+import { createFileWriter } from './fileWriter/index.js';
+/**
+ * ENVIRONMENT VARIABLE CONTRACT
+ * =============================
+ *
+ * The proxy uses a namespace convention to separate its configuration from
+ * the child MCP server's configuration:
+ *
+ * MCP_PROXY_* variables = Proxy's own configuration
+ * Everything else        = Passed through to child MCP server
+ *
+ * This design allows the proxy to wrap ANY MCP server without knowing
+ * anything about its specific requirements.
+ */
+// ============================================================================
+// PROXY CONFIGURATION (MCP_PROXY_* prefix)
+// ============================================================================
+/**
+ * MCP_PROXY_CHILD_COMMAND (OPTIONAL)
+ * The command to spawn as the child MCP server
+ * If not provided, proxy runs in standalone mode (JQ tool only)
+ * Examples: "mcp-grafana", "npx @anyshift/anyshift-mcp-server", "node /path/to/server.js"
+ */
+const CHILD_COMMAND = process.env.MCP_PROXY_CHILD_COMMAND;
+/**
+ * MCP_PROXY_CHILD_ARGS (OPTIONAL)
+ * Comma-separated list of arguments to pass to the child command
+ * Example: "arg1,arg2,arg3" becomes ["arg1", "arg2", "arg3"]
+ */
+const CHILD_ARGS = process.env.MCP_PROXY_CHILD_ARGS
+    ? process.env.MCP_PROXY_CHILD_ARGS.split(',').map(s => s.trim()).filter(Boolean)
+    : [];
+/**
+ * MCP_PROXY_MAX_TOKENS (OPTIONAL, default: 10000)
+ * Maximum tokens before truncating responses
+ * Calculated as: maxTokens * charsPerToken = max characters
+ * Default: 10000 tokens * 4 chars/token = 40,000 characters
+ */
+const MAX_TOKENS = parseInt(process.env.MCP_PROXY_MAX_TOKENS || '10000');
+/**
+ * MCP_PROXY_CHARS_PER_TOKEN (OPTIONAL, default: 4)
+ * Average characters per token for truncation calculation
+ * Standard approximation: 1 token ≈ 4 characters
+ */
+const CHARS_PER_TOKEN = parseInt(process.env.MCP_PROXY_CHARS_PER_TOKEN || '4');
+/**
+ * MCP_PROXY_WRITE_TO_FILE (OPTIONAL, default: false)
+ * Enable automatic file writing for large responses
+ * When enabled, responses above MIN_CHARS_FOR_WRITE are saved to disk
+ */
+const WRITE_TO_FILE = process.env.MCP_PROXY_WRITE_TO_FILE === 'true';
+/**
+ * MCP_PROXY_OUTPUT_PATH (REQUIRED if WRITE_TO_FILE=true)
+ * Directory where response files should be saved
+ * Must be an absolute path
+ */
+const OUTPUT_PATH = process.env.MCP_PROXY_OUTPUT_PATH || '';
+/**
+ * MCP_PROXY_MIN_CHARS_FOR_WRITE (OPTIONAL, default: 1000)
+ * Minimum response size (in characters) before saving to file
+ * Responses smaller than this are not written to disk
+ */
+const MIN_CHARS_FOR_WRITE = parseInt(process.env.MCP_PROXY_MIN_CHARS_FOR_WRITE || '1000');
+/**
+ * MCP_PROXY_ENABLE_JQ (OPTIONAL, default: true)
+ * Enable the JQ tool for querying JSON files
+ * The JQ tool is added to the list of available tools from the child MCP
+ */
+const ENABLE_JQ = process.env.MCP_PROXY_ENABLE_JQ !== 'false'; // default true
+/**
+ * MCP_PROXY_JQ_TIMEOUT_MS (OPTIONAL, default: 30000)
+ * Timeout in milliseconds for JQ query execution
+ */
+const JQ_TIMEOUT_MS = parseInt(process.env.MCP_PROXY_JQ_TIMEOUT_MS || '30000');
+/**
+ * MCP_PROXY_ENABLE_LOGGING (OPTIONAL, default: false)
+ * Enable debug logging for the proxy
+ * Logs truncation events and file writing operations
+ */
+const ENABLE_LOGGING = process.env.MCP_PROXY_ENABLE_LOGGING === 'true';
+// ============================================================================
+// VALIDATION
+// ============================================================================
+// Validate configuration
+// CHILD_COMMAND is now optional - if not provided, proxy runs in standalone mode (JQ only)
+if (!CHILD_COMMAND) {
+    console.error('[mcp-proxy] No child command specified - running in standalone mode (JQ only)');
+    if (!ENABLE_JQ) {
+        console.error('ERROR: Standalone mode requires JQ to be enabled (MCP_PROXY_ENABLE_JQ must not be false)');
+        process.exit(1);
+    }
+}
+if (WRITE_TO_FILE && !OUTPUT_PATH) {
+    console.error('ERROR: MCP_PROXY_OUTPUT_PATH is required when MCP_PROXY_WRITE_TO_FILE=true');
+    console.error('Example: export MCP_PROXY_OUTPUT_PATH="/tmp/mcp-results"');
+    process.exit(1);
+}
+// ============================================================================
+// PASS-THROUGH ENVIRONMENT VARIABLES
+// ============================================================================
+/**
+ * Extract all environment variables that should be passed to the child MCP.
+ *
+ * We pass through everything EXCEPT:
+ * - Variables prefixed with MCP_PROXY_ (those are for the proxy itself)
+ * - System variables that shouldn't be inherited (PATH, HOME, etc. are handled by spawn)
+ *
+ * This allows the child MCP to receive exactly the environment variables it needs,
+ * such as:
+ * - GRAFANA_URL, GRAFANA_SERVICE_ACCOUNT_TOKEN
+ * - DATADOG_API_KEY, DATADOG_APP_KEY
+ * - API_TOKEN, API_BASE_URL
+ * - etc.
+ */
+const childEnv = {};
+for (const [key, value] of Object.entries(process.env)) {
+    // Skip proxy configuration variables
+    if (key.startsWith('MCP_PROXY_')) {
+        continue;
+    }
+    // Only include defined values
+    if (value !== undefined) {
+        childEnv[key] = value;
+    }
+}
+// ============================================================================
+// CONFIGURATION SUMMARY
+// ============================================================================
+if (ENABLE_LOGGING) {
+    console.error('[mcp-proxy] Configuration:');
+    console.error(`  Mode: ${CHILD_COMMAND ? 'wrapper' : 'standalone (JQ only)'}`);
+    if (CHILD_COMMAND) {
+        console.error(`  Child command: ${CHILD_COMMAND}`);
+        console.error(`  Child args: [${CHILD_ARGS.join(', ')}]`);
+    }
+    console.error(`  Max tokens: ${MAX_TOKENS}`);
+    console.error(`  Chars per token: ${CHARS_PER_TOKEN}`);
+    console.error(`  Write to file: ${WRITE_TO_FILE}`);
+    if (WRITE_TO_FILE) {
+        console.error(`  Output path: ${OUTPUT_PATH}`);
+        console.error(`  Min chars for write: ${MIN_CHARS_FOR_WRITE}`);
+    }
+    console.error(`  JQ tool enabled: ${ENABLE_JQ}`);
+    if (CHILD_COMMAND) {
+        console.error(`  Pass-through env vars: ${Object.keys(childEnv).length}`);
+    }
+}
+// ============================================================================
+// MAIN PROXY LOGIC
+// ============================================================================
+async function main() {
+    console.error('[mcp-proxy] Starting generic MCP proxy...');
+    // ------------------------------------------------------------------------
+    // 1. SPAWN CHILD MCP SERVER (if configured)
+    // ------------------------------------------------------------------------
+    let childClient = null;
+    let childToolsResponse = { tools: [] };
+    if (CHILD_COMMAND) {
+        console.error(`[mcp-proxy] Spawning child MCP: ${CHILD_COMMAND}`);
+        const childTransport = new StdioClientTransport({
+            command: CHILD_COMMAND,
+            args: CHILD_ARGS,
+            env: childEnv // All values are defined strings (filtered in extraction loop)
+        });
+        childClient = new Client({
+            name: 'mcp-proxy-client',
+            version: '1.0.0'
+        }, {
+            capabilities: {}
+        });
+        await childClient.connect(childTransport);
+        console.error('[mcp-proxy] Connected to child MCP');
+        // ------------------------------------------------------------------------
+        // 2. DISCOVER TOOLS FROM CHILD MCP
+        // ------------------------------------------------------------------------
+        childToolsResponse = await childClient.listTools();
+        console.error(`[mcp-proxy] Discovered ${childToolsResponse.tools.length} tools from child MCP`);
+    }
+    else {
+        console.error('[mcp-proxy] Standalone mode - no child MCP');
+    }
+    // ------------------------------------------------------------------------
+    // 3. CREATE PROXY SERVER
+    // ------------------------------------------------------------------------
+    const server = new Server({
+        name: 'mcp-proxy',
+        version: '1.0.0'
+    }, {
+        capabilities: {
+            tools: {}
+        }
+    });
+    // ------------------------------------------------------------------------
+    // 4. INITIALIZE PROXY CAPABILITIES
+    // ------------------------------------------------------------------------
+    // Truncation configuration
+    const truncationConfig = {
+        maxTokens: MAX_TOKENS,
+        charsPerToken: CHARS_PER_TOKEN,
+        enableLogging: ENABLE_LOGGING,
+        messagePrefix: 'RESPONSE TRUNCATED' // Can be customized per service
+    };
+    // File writer configuration
+    const fileWriterConfig = {
+        enabled: WRITE_TO_FILE,
+        outputPath: OUTPUT_PATH,
+        minCharsForWrite: MIN_CHARS_FOR_WRITE,
+        toolAbbreviations: {} // No service-specific abbreviations (generic proxy)
+    };
+    const fileWriter = createFileWriter(fileWriterConfig);
+    // JQ tool configuration
+    let jqTool = null;
+    if (ENABLE_JQ) {
+        jqTool = createJqTool({
+            allowedPaths: [process.cwd(), OUTPUT_PATH].filter(Boolean),
+            timeoutMs: JQ_TIMEOUT_MS
+        });
+    }
+    // ------------------------------------------------------------------------
+    // 5. REGISTER ALL TOOLS (CHILD + PROXY)
+    // ------------------------------------------------------------------------
+    const allTools = [
+        ...childToolsResponse.tools,
+        ...(jqTool ? [jqTool.toolDefinition] : [])
+    ];
+    console.error(`[mcp-proxy] Exposing ${allTools.length} tools total (${childToolsResponse.tools.length} from child${jqTool ? ' + 1 JQ' : ''})`);
+    // ------------------------------------------------------------------------
+    // 6. HANDLE TOOL LIST REQUESTS
+    // ------------------------------------------------------------------------
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: allTools };
+    });
+    // ------------------------------------------------------------------------
+    // 7. HANDLE TOOL CALL REQUESTS (WITH TRUNCATION & FILE WRITING)
+    // ------------------------------------------------------------------------
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const toolName = request.params.name;
+        const toolArgs = request.params.arguments || {};
+        if (ENABLE_LOGGING) {
+            console.error(`[mcp-proxy] Tool call: ${toolName}`);
+        }
+        try {
+            // Handle JQ tool locally (if enabled)
+            if (toolName === 'execute_jq_query' && jqTool) {
+                if (ENABLE_LOGGING) {
+                    console.error('[mcp-proxy] Executing JQ tool locally');
+                }
+                return await jqTool.handler({
+                    params: { arguments: toolArgs }
+                });
+            }
+            // Forward all other tools to child MCP (if child exists)
+            if (!childClient) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Error: Tool ${toolName} not available in standalone mode (no child MCP)`
+                        }],
+                    isError: true
+                };
+            }
+            if (ENABLE_LOGGING) {
+                console.error(`[mcp-proxy] Forwarding to child MCP: ${toolName}`);
+            }
+            const result = await childClient.callTool({
+                name: toolName,
+                arguments: toolArgs
+            });
+            // Apply truncation and file writing to text responses
+            if (result.content && Array.isArray(result.content) && result.content.length > 0) {
+                for (let i = 0; i < result.content.length; i++) {
+                    const item = result.content[i];
+                    if (item.type === 'text' && typeof item.text === 'string') {
+                        const originalLength = item.text.length;
+                        // Step 1: Apply truncation
+                        item.text = truncateResponseIfNeeded(truncationConfig, item.text);
+                        if (item.text.length < originalLength && ENABLE_LOGGING) {
+                            console.error(`[mcp-proxy] Truncated response: ${originalLength} → ${item.text.length} chars`);
+                        }
+                        // Step 2: Apply file writing (if enabled)
+                        if (fileWriterConfig.enabled) {
+                            const fileResult = await fileWriter.handleResponse(toolName, toolArgs, {
+                                content: [{ type: 'text', text: item.text }]
+                            });
+                            if (fileResult && fileResult.content && Array.isArray(fileResult.content) &&
+                                fileResult.content.length > 0 && fileResult.content[0].type === 'text') {
+                                item.text = fileResult.content[0].text;
+                                if (ENABLE_LOGGING) {
+                                    console.error(`[mcp-proxy] File writing applied for ${toolName}`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            console.error(`[mcp-proxy] Error executing tool ${toolName}:`, error);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Error executing ${toolName}: ${error.message || String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    // ------------------------------------------------------------------------
+    // 8. CONNECT PROXY TO STDIO
+    // ------------------------------------------------------------------------
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('[mcp-proxy] Proxy server ready on stdio');
+    console.error('[mcp-proxy] Waiting for MCP protocol messages...');
+}
+// ============================================================================
+// START THE PROXY
+// ============================================================================
+main().catch((error) => {
+    console.error('[mcp-proxy] Fatal error:', error);
+    process.exit(1);
+});

package/dist/jq/handler.d.ts

@@ -0,0 +1,14 @@
+import { JqConfig } from './types.js';
+/**
+ * Execute a JQ query on a JSON file
+ * @param config - JQ configuration
+ * @param jqQuery - The JQ query to execute
+ * @param filePath - Absolute path to the JSON file
+ * @returns Promise with the query result
+ */
+export declare function executeJqQuery(config: JqConfig, jqQuery: string, filePath: string): Promise<{
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}>;