viewgate-mcp 1.0.23 → 1.0.25

package/dist/index.js

@@ -48,20 +48,20 @@ function createMcpServer(apiKey, personalKey) {
             tools: [
                 {
                     name: "get_annotations",
-                    description: "Retrieves all feedback annotations. WORKFLOW: 1. Read these annotations, 2. Open the source files and apply SURGICAL fixes based on '_ia_fix_instruction'. 3. IMMEDIATELY call 'mark_annotation_ready' with the results for EACH ticket you fixed. Use 'outerHtml' and 'source' (file:line) to locate the exact code block without manual searching. IMPORTANT: All AI analysis and comments MUST be in the 'preferredLanguage' specified in the output. Failure to follow the language setting is UNACCEPTABLE.",
+                    description: "Retrieves all feedback annotations. Use 'status' to filter (e.g. 'pending,bug_fixing'). WORKFLOW: 1. Read these annotations, 2. Open the source files and apply SURGICAL fixes. 3. Call 'mark_annotation_ready' for EACH ticket. IMPORTANT: Uses 'id' for marking, but 'key' for readability.",
                     inputSchema: {
                         type: "object",
                         properties: {
                             limit: { type: "number", description: "Maximum number of annotations to retrieve (default: 3)", default: 3 },
-                            status: { type: "string", description: "Comma-separated list of statuses to fetch (e.g. 'pending,bug_fixing,in_progress'). Use 'all' to fetch from any state.", default: "pending,bug_fixing" },
-                            search: { type: "string", description: "Search term to filter annotations by text in message or file paths." },
-                            key: { type: "string", description: "Human-readable key (e.g. VG-B62B4E) to find a specific annotation ID." }
+                            status: { type: "string", description: "Comma-separated list (e.g. 'pending,bug_fixing'). Use 'all' for any state.", default: "pending,bug_fixing" },
+                            search: { type: "string", description: "Search term to filter by message or file." },
+                            key: { type: "string", description: "Human key (e.g. VG-XXXX) to find a specific annotation." }
                         },
                     },
                 },
                 {
                     name: "mark_annotation_ready",
-                    description: "CRITICAL: Call this tool AFTER applying code fixes for annotations. It marks tickets as 'Ready for Review'. REQUIREMENT: Use the internal database ID (e.g. 675ba...), NOT the human key (VG-XXXX). If you only have the key, use 'get_annotations' with 'key' filter first. IMPORTANT: The 'appliedChanges' summary MUST be written in the 'preferredLanguage' specified by 'get_annotations'.",
+                    description: "CRITICAL: Call this tool AFTER applying code fixes. REQUIREMENT: Use the internal database ID (e.g. 675ba...), NOT the human key (VG-XXXX).",
                     inputSchema: {
                         type: "object",
                         properties: {
@@ -71,7 +71,7 @@ function createMcpServer(apiKey, personalKey) {
                                     type: "object",
                                     properties: {
                                         id: { type: "string", description: "The ID of the annotation to mark as ready" },
-                                        appliedChanges: { type: "string", description: "Descriptive summary of what was changed in the code for this specific ticket. MUST be in the preferredLanguage." }
+                                        appliedChanges: { type: "string", description: "Descriptive summary of changes in the preferredLanguage." }
                                     },
                                     required: ["id", "appliedChanges"]
                                 }
@@ -82,7 +82,7 @@ function createMcpServer(apiKey, personalKey) {
                 },
                 {
                     name: "planning",
-                    description: "Planning tool for backlog tickets. CALL WITHOUT ARGUMENTS to fetch backlog tickets that need analysis. CALL WITH 'results' to submit AI analysis in batch. Rules: complejidad (1-3), incertidumbre (1-3), impacto (1-3), riesgo (1-3), tipo (AI-friendly|AI-assisted|Human-critical). IMPORTANT: All AI analysis, 'aiAnalysis' descriptions, and comments MUST be in the 'preferredLanguage' specified in the output.",
+                    description: "Planning tool for backlog tickets. Fetch tickets or submit analysis.",
                     inputSchema: {
                         type: "object",
                         properties: {
@@ -91,27 +91,24 @@ function createMcpServer(apiKey, personalKey) {
                                 items: {
                                     type: "object",
                                     properties: {
-                                        id: { type: "string", description: "The ticket/annotation ID" },
+                                        id: { type: "string" },
                                         complejidad: { type: "number", minimum: 1, maximum: 3 },
                                         incertidumbre: { type: "number", minimum: 1, maximum: 3 },
                                         impacto: { type: "number", minimum: 1, maximum: 3 },
                                         riesgo: { type: "number", minimum: 1, maximum: 3 },
                                         tipo: { type: "string", enum: ["AI-friendly", "AI-assisted", "Human-critical"] },
-                                        aiAnalysis: { type: "string", description: "Reasoning or summary of the analysis. MUST be in the preferredLanguage." }
+                                        aiAnalysis: { type: "string" }
                                     },
                                     required: ["id", "complejidad", "incertidumbre", "impacto", "riesgo", "tipo", "aiAnalysis"]
                                 }
                             },
-                            force: {
-                                type: "boolean",
-                                description: "If true, overwrites existing planning data."
-                            }
+                            force: { type: "boolean" }
                         }
                     }
                 },
                 {
                     name: "sync_endpoints",
-                    description: "Manually synchronizes backend endpoints. Call ONLY if the user explicitly asks to 'sync endpoints' or 'update routes'. DO NOT call this automatically during other workflows.",
+                    description: "Manually synchronizes backend endpoints.",
                     inputSchema: {
                         type: "object",
                         properties: {
@@ -120,50 +117,38 @@ function createMcpServer(apiKey, personalKey) {
                                 items: {
                                     type: "object",
                                     properties: {
-                                        path: { type: "string", description: "The relative path of the endpoint" },
-                                        method: { type: "string", description: "HTTP method (GET, POST, etc.)" },
-                                        description: { type: "string", description: "Human-readable description of what the endpoint does. MUST be in the preferredLanguage." },
-                                        hash: { type: "string", description: "Optional SHA256 hash of the endpoint definition for efficient diffing." },
-                                        contract: { type: "string", description: "Optional JSON string or description of the request/response contract (payload)." }
+                                        path: { type: "string" },
+                                        method: { type: "string" },
+                                        description: { type: "string" },
+                                        hash: { type: "string" },
+                                        contract: { type: "string" }
                                     },
                                     required: ["path", "method", "description"]
                                 }
                             },
-                            clean: {
-                                type: "boolean",
-                                description: "If true, clears all existing endpoints before adding the new ones. Useful for the first batch of a fresh scan."
-                            },
-                            globalHash: {
-                                type: "string",
-                                description: "Optional SHA256 hash of the entire endpoint set. If provided and matches the backend, the entire sync is skipped for performance."
-                            }
+                            clean: { type: "boolean" },
+                            globalHash: { type: "string" }
                         },
                         required: ["endpoints"]
                     }
                 },
                 {
                     name: "get_synced_endpoints",
-                    description: "Retrieves the list of endpoints currently synchronized in the backend for this project. Use this to perform diffing and avoid redundant synchronization calls.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {},
-                    },
+                    description: "Retrieves the list of endpoints currently synchronized in the backend.",
+                    inputSchema: { type: "object", properties: {} },
                 },
                 {
                     name: "get_optimizations",
-                    description: "Retrieves reported JSON payload optimizations (unused fields). WORKFLOW: 1. Get optimizations, 2. Locate the backend code for the endpoint, 3. Remove unused fields from the response, 4. Call 'mark_optimization_applied' with the ID.",
-                    inputSchema: {
-                        type: "object",
-                        properties: {},
-                    },
+                    description: "Retrieves reported JSON payload optimizations.",
+                    inputSchema: { type: "object", properties: {} },
                 },
                 {
                     name: "mark_optimization_applied",
-                    description: "Marks a payload optimization as applied in the backend after you have modified the code to remove unused fields.",
+                    description: "Marks a payload optimization as applied.",
                     inputSchema: {
                         type: "object",
                         properties: {
-                            id: { type: "string", description: "The ID of the optimization report to mark as applied" }
+                            id: { type: "string" }
                         },
                         required: ["id"]
                     },
@@ -172,42 +157,39 @@ function createMcpServer(apiKey, personalKey) {
         };
     });
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        switch (request.params.name) {
-            case "get_annotations": {
-                try {
+        const toolName = request.params.name;
+        console.error(`[MCP] Handling tool call: ${toolName}`);
+        try {
+            switch (toolName) {
+                case "get_annotations": {
                     const args = request.params.arguments;
                     const limit = args.limit || 3;
                     const statuses = args.status || 'pending,bug_fixing';
                     const search = args.search || '';
                     const key = args.key || '';
-                    const url = new URL(`${BACKEND_URL}/api/mcp/annotations`);
+                    let fetchUrl = `${BACKEND_URL}/api/mcp/annotations?lock=true`;
                     if (statuses && statuses !== 'all')
-                        url.searchParams.append('status', statuses);
+                        fetchUrl += `&status=${statuses}`;
                     if (limit)
-                        url.searchParams.append('limit', limit.toString());
+                        fetchUrl += `&limit=${limit}`;
                     if (search)
-                        url.searchParams.append('search', search);
+                        fetchUrl += `&search=${encodeURIComponent(search)}`;
                     if (key)
-                        url.searchParams.append('key', key);
-                    url.searchParams.append('lock', 'true');
-                    const response = await fetch(url.toString(), {
+                        fetchUrl += `&key=${encodeURIComponent(key)}`;
+                    const response = await fetch(fetchUrl, {
                         headers: {
                             'x-api-key': apiKey,
                             ...(personalKey ? { 'x-personal-key': personalKey } : {})
                         }
                     });
-                    if (!response.ok) {
+                    if (!response.ok)
                         throw new Error(`Backend responded with ${response.status}`);
-                    }
                     const rawData = (await response.json());
                     let rawAnnotations = Array.isArray(rawData) ? rawData : (rawData?.data || rawData?.annotations || []);
                     if (!Array.isArray(rawAnnotations)) {
-                        return {
-                            content: [{ type: "text", text: "Error: Invalid format from backend" }],
-                            isError: true
-                        };
+                        return { content: [{ type: "text", text: "Error: Invalid format from backend" }], isError: true };
                     }
-                    // Local filtering fallback for search and key (in case backend doesn't support them yet)
+                    // Local filtering fallback (for older backend versions)
                     if (search) {
                         const lowSearch = search.toLowerCase();
                         rawAnnotations = rawAnnotations.filter((ann) => (ann.message && ann.message.toLowerCase().includes(lowSearch)) ||
@@ -217,315 +199,135 @@ function createMcpServer(apiKey, personalKey) {
                     if (key) {
                         rawAnnotations = rawAnnotations.filter((ann) => ann.key === key || ann._id === key);
                     }
-                    const priorityMap = {
-                        'urgente': 4,
-                        'urgent': 4,
-                        'alta': 3,
-                        'high': 3,
-                        'media': 2,
-                        'medium': 2,
-                        'baja': 1,
-                        'low': 1
-                    };
+                    const priorityMap = { 'urgente': 4, 'urgent': 4, 'alta': 3, 'high': 3, 'media': 2, 'medium': 2, 'baja': 1, 'low': 1 };
                     const sortedAnnotations = rawAnnotations.sort((a, b) => {
-                        const statusOrder = {
-                            'pending': 2,
-                            'bug_fixing': 1
-                        };
+                        const statusOrder = { 'pending': 2, 'bug_fixing': 1 };
                         const statusA = (a.status || 'pending').toLowerCase();
                         const statusB = (b.status || 'pending').toLowerCase();
                         if (statusOrder[statusA] !== statusOrder[statusB]) {
                             return (statusOrder[statusB] || 0) - (statusOrder[statusA] || 0);
                         }
-                        const prioA = priorityMap[(a.priority || 'medium').toLowerCase()] || 0;
-                        const prioB = priorityMap[(b.priority || 'medium').toLowerCase()] || 0;
-                        return prioB - prioA;
+                        return (priorityMap[(b.priority || 'medium').toLowerCase()] || 0) - (priorityMap[(a.priority || 'medium').toLowerCase()] || 0);
                     });
                     const annotationsWithTips = sortedAnnotations.map((ann) => {
                         const file = ann.reference?.source?.split(':')[0];
                         const line = ann.reference?.source?.split(':')[1];
-                        const source = ann.reference?.source;
                         const pendingCorrection = Array.isArray(ann.corrections)
                             ? ann.corrections.find((c) => c.status === 'pending')
                             : (typeof ann.corrections === 'string' ? { text: ann.corrections } : null);
-                        // Essential fields for the AI to perform a surgical fix
                         return {
                             id: ann._id,
                             key: ann.key,
                             priority: ann.priority,
                             status: ann.status,
                             message: ann.message,
-                            corrections: ann.corrections, // Include full history
-                            source: source,
+                            corrections: ann.corrections,
+                            source: ann.reference?.source,
                             filePath: ann.filePath || file,
                             line: ann.line || (line ? parseInt(line) : undefined),
                             vgId: ann.reference?.vgId,
-                            confidence: ann.reference?.confidence,
-                            fingerprint: ann.reference?.fingerprint,
                             outerHtml: ann.reference?.outerHtml,
-                            parentContext: ann.reference?.parentContext,
-                            componentPath: ann.reference?.componentPath,
-                            selector: ann.reference?.selector,
-                            tag: ann.reference?.tag,
-                            figmaReference: ann.figmaReference,
-                            backendEndpoints: ann.backendEndpoints || [ann.backendEndpoint].filter(Boolean),
-                            _ia_fix_instruction: `### 🎨 DESIGN CONTEXT (Figma)
-${ann.figmaReference ? `A design reference is available: ${ann.figmaReference}. Use the Figma link to understand the UX requirements.` : 'No explicit figma design linked.'}
-
-${pendingCorrection ? `### ⚠️ PENDING CORRECTION (FEEDBACK)
-The user has requested the following corrections:
-"${pendingCorrection.text}"
-${pendingCorrection.author ? `Requested by: ${pendingCorrection.author.name}` : ''}
-PLEASE ENSURE THESE SPECIFIC ISSUES ARE ADDRESSED IN YOUR FIX.` : ''}
-
-### 🔬 SURGICAL FIX PROTOCOL (Language: ${rawData.preferredLanguage || 'en'})
-1. **PRIMARY**: Search for \`data-vg-id="${ann.reference?.vgId}"\`.
-2. **SECONDARY**: Check \`${file}\` L${line} (Fiber Source).
-3. **TERTIARY**: Match Tag(\`${ann.reference?.tag}\`) + Role(\`${ann.reference?.fingerprint?.role}\`) + Text("${ann.reference?.text?.slice(0, 30)}").
-4. **VALIDATE**: Confirm parent context matches \`${ann.reference?.parentContext?.slice(0, 50).replace(/`/g, "'")}...\`.
-
-IMPORTANT: All your analysis and implementation comments MUST BE IN ${rawData.preferredLanguage === 'es' ? 'SPANISH' : 'ENGLISH'}.
-
-Confidence: [vgId: ${ann.reference?.confidence?.vgId || 0}, Fiber: ${ann.reference?.confidence?.fiber || 0}, Fingerprint: ${ann.reference?.confidence?.fingerprint || 0}]
-Instruction: ${ann.message}${pendingCorrection ? `\nCorrection Needed: ${pendingCorrection.text}` : ''}`
+                            _ia_fix_instruction: `### 🎯 DESIGN CONTEXT (Figma)
+${ann.figmaReference ? `A design reference is available: ${ann.figmaReference}` : 'No explicit design linked.'}
+
+${pendingCorrection ? `### ⚠️ PENDING CORRECTION\nUser feedback: "${pendingCorrection.text}"` : ''}
+
+### 🔬 FIX PROTOCOL
+1. **Target**: \`data-vg-id="${ann.reference?.vgId}"\` in \`${file}\`.
+2. **Context**: \`${ann.reference?.parentContext?.slice(0, 50)}...\`
+
+IMPORTANT: Respond in ${rawData.preferredLanguage === 'es' ? 'SPANISH' : 'ENGLISH'}.
+Instruction: ${ann.message}`
                         };
                     });
                     return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    preferredLanguage: rawData.preferredLanguage || 'en',
-                                    annotations: annotationsWithTips
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Error fetching annotations: ${error.message}`,
-                            },
-                        ],
-                        isError: true,
+                        content: [{ type: "text", text: JSON.stringify({ preferredLanguage: rawData.preferredLanguage || 'en', annotations: annotationsWithTips }, null, 2) }],
                     };
                 }
-            }
-            case "mark_annotation_ready": {
-                try {
+                case "mark_annotation_ready": {
                     const args = request.params.arguments;
-                    let lastError = null;
-                    for (let attempt = 1; attempt <= 3; attempt++) {
-                        try {
-                            const response = await fetch(`${BACKEND_URL}/api/mcp/annotations/batch-ready`, {
-                                method: 'PATCH',
-                                headers: {
-                                    'Content-Type': 'application/json',
-                                    'x-api-key': apiKey,
-                                    ...(personalKey ? { 'x-personal-key': personalKey } : {})
-                                },
-                                body: JSON.stringify({ results: args.results })
-                            });
-                            if (!response.ok) {
-                                throw new Error(`Backend responded with ${response.status}`);
-                            }
-                            const result = await response.json();
-                            return {
-                                content: [{ type: "text", text: `Successfully processed batch update: ${JSON.stringify(result, null, 2)}` }],
-                            };
-                        }
-                        catch (error) {
-                            lastError = error;
-                            console.error(`[MCP] mark_annotation_ready attempt ${attempt} failed:`, error.message);
-                            if (attempt < 3)
-                                await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
-                        }
-                    }
-                    throw lastError || new Error('Unknown error during batch update');
-                }
-                catch (error) {
-                    return {
-                        content: [{ type: "text", text: `Error marking annotations ready: ${error.message}` }],
-                        isError: true,
-                    };
+                    console.error(`[MCP] Marking ${args.results.length} annotations as ready.`);
+                    const response = await fetch(`${BACKEND_URL}/api/mcp/annotations/batch-ready`, {
+                        method: 'PATCH',
+                        headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey, ...(personalKey ? { 'x-personal-key': personalKey } : {}) },
+                        body: JSON.stringify({ results: args.results })
+                    });
+                    if (!response.ok)
+                        throw new Error(`Backend responded with ${response.status}`);
+                    const result = await response.json();
+                    return { content: [{ type: "text", text: `Processed: ${JSON.stringify(result, null, 2)}` }] };
                 }
-            }
-            case "planning": {
-                try {
+                case "planning": {
                     const args = request.params.arguments;
-                    if (!args.results) {
-                        // Fetch Backlog Mode
-                        const response = await fetch(`${BACKEND_URL}/api/mcp/backlog`, {
-                            headers: {
-                                'x-api-key': apiKey,
-                                ...(personalKey ? { 'x-personal-key': personalKey } : {})
-                            }
-                        });
-                        if (!response.ok) {
-                            throw new Error(`Backend responded with ${response.status}`);
-                        }
-                        const data = (await response.json());
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        preferredLanguage: data.preferredLanguage || 'en',
-                                        backlog: data.data || []
-                                    }, null, 2)
-                                }]
-                        };
-                    }
-                    else {
-                        // Submit Results Mode
-                        const response = await fetch(`${BACKEND_URL}/api/mcp/annotations/batch-planning`, {
-                            method: 'PATCH',
-                            headers: {
-                                'Content-Type': 'application/json',
-                                'x-api-key': apiKey,
-                                ...(personalKey ? { 'x-personal-key': personalKey } : {})
-                            },
-                            body: JSON.stringify({ results: args.results, force: args.force })
-                        });
-                        if (!response.ok) {
-                            throw new Error(`Backend responded with ${response.status}`);
-                        }
-                        const result = await response.json();
-                        return {
-                            content: [{ type: "text", text: `Planning results processed: ${JSON.stringify(result, null, 2)}` }]
-                        };
-                    }
-                }
-                catch (error) {
-                    return {
-                        content: [{ type: "text", text: `Error in planning tool: ${error.message}` }],
-                        isError: true
-                    };
+                    const url = args.results ? `${BACKEND_URL}/api/mcp/annotations/batch-planning` : `${BACKEND_URL}/api/mcp/backlog`;
+                    const method = args.results ? 'PATCH' : 'GET';
+                    const response = await fetch(url, {
+                        method,
+                        headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey, ...(personalKey ? { 'x-personal-key': personalKey } : {}) },
+                        body: args.results ? JSON.stringify({ results: args.results, force: args.force }) : undefined
+                    });
+                    if (!response.ok)
+                        throw new Error(`Backend responded with ${response.status}`);
+                    const data = await response.json();
+                    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
                 }
-            }
-            case "sync_endpoints": {
-                try {
+                case "sync_endpoints": {
                     const args = request.params.arguments;
-                    if (!args.endpoints || !Array.isArray(args.endpoints)) {
-                        throw new Error("Invalid endpoints format. Expected an array.");
-                    }
                     const response = await fetch(`${BACKEND_URL}/api/mcp/sync-endpoints`, {
                         method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            'x-api-key': apiKey,
-                            ...(personalKey ? { 'x-personal-key': personalKey } : {})
-                        },
-                        body: JSON.stringify({
-                            endpoints: args.endpoints,
-                            clean: args.clean,
-                            globalHash: args.globalHash
-                        })
+                        headers: { 'Content-Type': 'application/json', 'x-api-key': apiKey, ...(personalKey ? { 'x-personal-key': personalKey } : {}) },
+                        body: JSON.stringify(args)
                     });
-                    if (!response.ok) {
+                    if (!response.ok)
                         throw new Error(`Backend responded with ${response.status}`);
-                    }
-                    const result = (await response.json());
-                    return {
-                        content: [{ type: "text", text: `Endpoints synchronized successfully: ${result.count} routes processed. ${result.saved ? 'Changes saved.' : 'No changes detected.'}` }]
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [{ type: "text", text: `Error synchronizing endpoints: ${error.message}` }],
-                        isError: true
-                    };
+                    const result = await response.json();
+                    return { content: [{ type: "text", text: `Sync results: ${JSON.stringify(result)}` }] };
                 }
-            }
-            case "get_synced_endpoints": {
-                try {
+                case "get_synced_endpoints": {
                     const response = await fetch(`${BACKEND_URL}/api/projects/endpoints`, {
-                        headers: {
-                            'x-api-key': apiKey,
-                            ...(personalKey ? { 'x-personal-key': personalKey } : {})
-                        }
+                        headers: { 'x-api-key': apiKey, ...(personalKey ? { 'x-personal-key': personalKey } : {}) }
                     });
-                    if (!response.ok) {
+                    if (!response.ok)
                         throw new Error(`Backend responded with ${response.status}`);
-                    }
-                    const data = (await response.json());
-                    return {
-                        content: [{
-                                type: "text",
-                                text: JSON.stringify(data.endpoints || [], null, 2)
-                            }]
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [{ type: "text", text: `Error fetching synced endpoints: ${error.message}` }],
-                        isError: true
-                    };
+                    const data = await response.json();
+                    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
                 }
-            }
-            case "get_optimizations": {
-                try {
+                case "get_optimizations": {
                     const response = await fetch(`${BACKEND_URL}/api/mcp/optimizations`, {
-                        headers: {
-                            'x-api-key': apiKey,
-                            ...(personalKey ? { 'x-personal-key': personalKey } : {})
-                        }
+                        headers: { 'x-api-key': apiKey, ...(personalKey ? { 'x-personal-key': personalKey } : {}) }
                     });
                     if (!response.ok)
                         throw new Error(`Backend responded with ${response.status}`);
                     const data = await response.json();
-                    return {
-                        content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [{ type: "text", text: `Error fetching optimizations: ${error.message}` }],
-                        isError: true
-                    };
+                    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
                 }
-            }
-            case "mark_optimization_applied": {
-                try {
+                case "mark_optimization_applied": {
                     const args = request.params.arguments;
                     const response = await fetch(`${BACKEND_URL}/api/mcp/optimizations/${args.id}/applied`, {
                         method: 'PATCH',
-                        headers: {
-                            'x-api-key': apiKey,
-                            ...(personalKey ? { 'x-personal-key': personalKey } : {})
-                        }
+                        headers: { 'x-api-key': apiKey, ...(personalKey ? { 'x-personal-key': personalKey } : {}) }
                     });
                     if (!response.ok)
                         throw new Error(`Backend responded with ${response.status}`);
-                    const result = await response.json();
-                    return {
-                        content: [{ type: "text", text: `Optimization marked as applied: ${JSON.stringify(result)}` }]
-                    };
-                }
-                catch (error) {
-                    return {
-                        content: [{ type: "text", text: `Error marking optimization: ${error.message}` }],
-                        isError: true
-                    };
+                    return { content: [{ type: "text", text: "Optimization marked as applied." }] };
                 }
+                default:
+                    throw new Error("Unknown tool");
             }
-            default:
-                throw new Error("Unknown tool");
+        }
+        catch (error) {
+            console.error(`[MCP Error] ${toolName}:`, error.message);
+            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
         }
     });
     return server;
 }
-// --- TRANSPORT SELECTION ---
 const useSSE = process.argv.includes("--sse") || process.env.MCP_TRANSPORT === "sse";
 if (!useSSE) {
-    // STDIO Mode (NPM Package Default)
-    // In Stdio mode, we use the API key from environment variable
     const apiKey = process.env.VIEWGATE_API_KEY || process.env.API_KEY || "";
     const personalKey = process.env.VIEWGATE_PERSONAL_KEY || "";
     if (!apiKey) {
-        console.error("Error: VIEWGATE_API_KEY environment variable is required in STDIO mode.");
+        console.error("Error: VIEWGATE_API_KEY environment variable is required.");
         process.exit(1);
     }
     const server = createMcpServer(apiKey, personalKey);
@@ -536,20 +338,10 @@ if (!useSSE) {
     });
 }
 else {
-    // SSE Mode (Express/Remote)
     const app = express();
-    const ALLOWED_ORIGINS = process.env.ALLOWED_ORIGINS ? process.env.ALLOWED_ORIGINS.split(',') : '*';
-    app.use(cors({
-        origin: ALLOWED_ORIGINS,
-        methods: ['GET', 'POST', 'OPTIONS'],
-        allowedHeaders: ['Content-Type', 'x-api-key', 'Authorization']
-    }));
-    // Apply JSON middleware only for non-MCP routes
-    app.use((req, res, next) => {
-        if (req.path === "/message")
-            return next();
-        express.json()(req, res, next);
-    });
+    app.use(cors());
+    app.use((req, res, next) => { if (req.path === "/message")
+        return next(); express.json()(req, res, next); });
     app.get("/sse", async (req, res) => {
         const apiKey = req.query.apiKey || req.headers['x-api-key'];
         const personalKey = req.query.personalKey || req.headers['x-personal-key'];
@@ -573,6 +365,5 @@ else {
         }
         await session.transport.handlePostMessage(req, res);
     });
-    app.listen(port, () => {
-    });
+    app.listen(port, () => { console.error(`[MCP SSE] Listening on port ${port}`); });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viewgate-mcp",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "main": "dist/index.js",
   "bin": {
     "viewgate-mcp": "./dist/index.js"