viewgate-mcp 1.0.32 → 1.0.33

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();
 /**
@@ -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.",
@@ -177,23 +195,27 @@ function createMcpServer(apiKey, personalKey) {
                     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 +239,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 +255,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 +316,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.33",
   "main": "dist/index.js",
   "bin": {
     "viewgate-mcp": "./dist/index.js"