viewgate-mcp 1.0.32 → 1.0.34

package/dist/index.js

@@ -21,6 +21,7 @@ import fetch from "node-fetch";
 import cors from "cors";
 import dotenv from "dotenv";
 import path from "path";
+import os from "os";
 import { fileURLToPath } from "url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -29,6 +30,8 @@ const port = process.env.PORT || 3000;
 const BACKEND_URL = process.env.BACKEND_URL || "https://view-gate.vercel.app";
 console.error(`[MCP Config] BACKEND_URL: ${BACKEND_URL}`);
 console.error(`[MCP Config] API_KEY Prefix: ${process.env.API_KEY?.substring(0, 5)}...`);
+const agentId = `${os.hostname()}-${process.pid}`;
+console.error(`[MCP Identity] Agent ID: ${agentId}`);
 // Store active sessions for SSE: sessionId -> { server, transport }
 const sessions = new Map();
 /**
@@ -53,7 +56,7 @@ function createMcpServer(apiKey, personalKey) {
                         type: "object",
                         properties: {
                             limit: { type: "number", description: "Maximum number of annotations to retrieve (default: 3, automatically increased if specific keys are provided)", default: 3 },
-                            status: { type: "string", description: "Comma-separated list (e.g. 'pending,bug_fixing'). Use 'all' for any state.", default: "pending,bug_fixing" },
+                            status: { type: "string", description: "Comma-separated list (e.g. 'pending,bug_fixing'). Only 'pending' and 'bug_fixing' are allowed for MCP resolution flow.", 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) or comma-separated keys to find specific annotations." },
                             keys: { type: "array", items: { type: "string" }, description: "List of human keys (e.g. VG-XXXX) to find specific annotations." },
@@ -82,6 +85,21 @@ function createMcpServer(apiKey, personalKey) {
                         required: ["results"]
                     },
                 },
+                {
+                    name: "mark_annotations_as_live",
+                    description: "Transitions annotations from 'applied' (local fix) to 'ready_for_review' (live on server). Call this tool ONLY after you have successfully deployed/uploaded your code changes.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            ids: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "List of internal database IDs to mark as live."
+                            }
+                        },
+                        required: ["ids"]
+                    },
+                },
                 {
                     name: "planning",
                     description: "Planning tool for backlog tickets. Fetch tickets or submit analysis.",
@@ -171,29 +189,36 @@ function createMcpServer(apiKey, personalKey) {
                 case "get_annotations": {
                     const args = request.params.arguments;
                     const limit = args.limit || 3;
-                    const statuses = args.status || 'pending,bug_fixing';
+                    // Strictly enforce allowed statuses: pending and bug_fixing
+                    const allowedStatuses = ['pending', 'bug_fixing'];
+                    const requestedStatuses = (args.status || 'pending,bug_fixing').split(',').map(s => s.trim()).filter(s => allowedStatuses.includes(s));
+                    const statuses = requestedStatuses.length > 0 ? requestedStatuses.join(',') : 'pending,bug_fixing';
                     const search = args.search || '';
                     // Normalize keys and ids
                     let keysToFetch = [];
                     if (args.key)
                         keysToFetch = keysToFetch.concat(args.key.split(',').map(s => s.trim()));
-                    if (args.keys)
-                        keysToFetch = keysToFetch.concat(args.keys);
-                    const combinedKey = keysToFetch.filter(k => k).join(',');
-                    const idsToFetch = args.ids || '';
+                    const key = args.key;
+                    const keys = args.keys;
+                    const ids = args.ids;
                     const agentId = personalKey || 'mcp-agent-' + (apiKey?.slice(-6) || 'generic');
-                    let fetchUrl = `${BACKEND_URL}/api/mcp/annotations?lock=true&agentId=${encodeURIComponent(agentId)}`;
-                    if (statuses && statuses !== 'all')
-                        fetchUrl += `&status=${statuses}`;
+                    const fetchUrl = new URL(`${BACKEND_URL}/api/mcp/annotations`);
                     if (limit)
-                        fetchUrl += `&limit=${limit}`;
+                        fetchUrl.searchParams.append("limit", limit.toString());
+                    if (statuses)
+                        fetchUrl.searchParams.append("status", statuses);
                     if (search)
-                        fetchUrl += `&search=${encodeURIComponent(search)}`;
-                    if (combinedKey)
-                        fetchUrl += `&key=${encodeURIComponent(combinedKey)}`;
-                    if (idsToFetch)
-                        fetchUrl += `&ids=${encodeURIComponent(idsToFetch)}`;
-                    console.error(`[MCP] Fetching: ${fetchUrl}`);
+                        fetchUrl.searchParams.append("search", search);
+                    if (key)
+                        fetchUrl.searchParams.append("key", key);
+                    if (ids)
+                        fetchUrl.searchParams.append("ids", ids);
+                    if (keys && keys.length > 0)
+                        fetchUrl.searchParams.append("keys", keys.join(","));
+                    // Add lock and agentId parameters
+                    fetchUrl.searchParams.append("lock", "true");
+                    fetchUrl.searchParams.append("agentId", agentId);
+                    console.error(`[get_annotations] Fetching: ${fetchUrl.toString()}`);
                     const response = await fetch(fetchUrl, {
                         headers: {
                             'x-api-key': apiKey,
@@ -217,10 +242,11 @@ function createMcpServer(apiKey, personalKey) {
                             (ann.reference?.source && ann.reference.source.toLowerCase().includes(lowSearch)) ||
                             (ann.key && ann.key.toLowerCase().includes(lowSearch)));
                     }
+                    const combinedKey = key || (keys && keys.join(','));
                     if (combinedKey) {
                         // Normalize keyList for case-insensitive matching and handle VG- prefix
-                        const keyList = combinedKey.split(',').map(k => k.trim().toUpperCase());
-                        const baseKeys = keyList.map(k => k.startsWith('VG-') ? k.substring(3) : k);
+                        const keyList = combinedKey.split(',').map((k) => k.trim().toUpperCase());
+                        const baseKeys = keyList.map((k) => k.startsWith('VG-') ? k.substring(3) : k);
                         rawAnnotations = rawAnnotations.filter((ann) => {
                             if (!ann.key)
                                 return keyList.includes(ann._id);
@@ -232,8 +258,8 @@ function createMcpServer(apiKey, personalKey) {
                         });
                         console.error(`[MCP] Filtered with keys. Remaining: ${rawAnnotations.length}`);
                     }
-                    if (idsToFetch) {
-                        const idList = idsToFetch.split(',').map(i => i.trim());
+                    if (ids) {
+                        const idList = ids.split(',').map((i) => i.trim());
                         rawAnnotations = rawAnnotations.filter((ann) => idList.includes(ann._id));
                         console.error(`[MCP] Filtered with IDs. Remaining: ${rawAnnotations.length}`);
                     }
@@ -293,19 +319,45 @@ Instruction: ${ann.message}`
                 }
                 case "mark_annotation_ready": {
                     const args = request.params.arguments;
-                    console.error(`[MCP] Marking ${args.results.length} annotations as ready.`);
-                    console.error(`[MCP] Batch ready update: ${BACKEND_URL}/api/mcp/annotations/batch-ready`);
+                    const results = args.results;
+                    console.error(`[mark_annotation_ready] Submitting results for ${results?.length} items`);
                     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 })
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'x-api-key': apiKey,
+                            'x-personal-key': personalKey || ''
+                        },
+                        body: JSON.stringify({
+                            results: results.map((r) => ({ ...r, status: 'applied' }))
+                        })
                     });
-                    if (!response.ok) {
-                        const errorBody = await response.text();
-                        throw new Error(`Backend responded with ${response.status}: ${errorBody}`);
-                    }
-                    const result = await response.json();
-                    return { content: [{ type: "text", text: `Processed: ${JSON.stringify(result, null, 2)}` }] };
+                    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 "mark_annotations_as_live": {
+                    const args = request.params.arguments;
+                    const ids = args.ids;
+                    console.error(`[mark_annotations_as_live] Marking ${ids?.length} items as live`);
+                    const response = await fetch(`${BACKEND_URL}/api/mcp/annotations/mark-as-live`, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'x-api-key': apiKey,
+                            'x-personal-key': personalKey || ''
+                        },
+                        body: JSON.stringify({ ids })
+                    });
+                    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 "planning": {
                     const args = request.params.arguments;

package/package.json

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