viewgate-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+import express from "express";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import fetch from "node-fetch";
+import cors from "cors";
+import dotenv from "dotenv";
+dotenv.config();
+const port = process.env.PORT || 3000;
+const BACKEND_URL = process.env.BACKEND_URL || "https://view-gate.vercel.app";
+// Store active sessions for SSE: sessionId -> { server, transport }
+const sessions = new Map();
+/**
+ * Create a new MCP server instance for a specific context.
+ */
+function createMcpServer(apiKey) {
+    const server = new Server({
+        name: "viewgate-mcp",
+        version: "1.0.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return {
+            tools: [
+                {
+                    name: "get_annotations",
+                    description: "Retrieves all feedback annotations. For each annotation, follow the '_ia_fix_instruction' to perform a FAST, SURGICAL fix. Use 'outerHtml' and 'source' (file:line) to locate the exact code block without manual searching.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {},
+                    },
+                },
+                {
+                    name: "mark_annotation_ready",
+                    description: "Mark an annotation as ready for review after applying changes, and generate a local Markdown log.",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            id: {
+                                type: "string",
+                                description: "The ID of the annotation to mark as ready"
+                            },
+                            originalMessage: {
+                                type: "string",
+                                description: "The original feedback message for the changelog"
+                            },
+                            appliedChanges: {
+                                type: "string",
+                                description: "Brief summary of what was changed in the code"
+                            }
+                        },
+                        required: ["id", "originalMessage", "appliedChanges"]
+                    },
+                }
+            ],
+        };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        switch (request.params.name) {
+            case "get_annotations": {
+                try {
+                    const statuses = 'pending,bug_fixing';
+                    const response = await fetch(`${BACKEND_URL}/api/mcp/annotations?status=${statuses}`, {
+                        headers: {
+                            'x-api-key': apiKey
+                        }
+                    });
+                    if (!response.ok) {
+                        throw new Error(`Backend responded with ${response.status}`);
+                    }
+                    const data = (await response.json());
+                    const rawAnnotations = Array.isArray(data) ? data : (data?.data || []);
+                    if (!Array.isArray(rawAnnotations)) {
+                        return {
+                            content: [{ type: "text", text: "Error: Invalid format" }],
+                            isError: true
+                        };
+                    }
+                    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 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;
+                    });
+                    const annotationsWithTips = sortedAnnotations.map((ann) => {
+                        const source = ann.reference?.source;
+                        const hasSource = source && source !== 'unknown:0';
+                        const [file, line] = hasSource ? source.split(':') : [null, 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,
+                            source: source,
+                            filePath: ann.filePath || file,
+                            line: ann.line || (line ? parseInt(line) : undefined),
+                            outerHtml: ann.reference?.outerHtml,
+                            parentContext: ann.reference?.parentContext,
+                            componentPath: ann.reference?.componentPath,
+                            selector: ann.reference?.selector,
+                            tag: ann.reference?.tag,
+                            _ia_fix_instruction: hasSource
+                                ? `FAST SURGICAL FIX: Open \`${file}\` at line ${line}. Focus on the block inside \`${ann.reference?.parentContext?.slice(0, 50)}...\`. Exact element: \`${ann.reference?.outerHtml?.slice(0, 100)}...\`. Instruction: ${ann.message}`
+                                : `MANUAL FIND: Search for the element using selector \`${ann.reference?.selector}\`. Reference HTML: \`${ann.reference?.outerHtml?.slice(0, 100)}...\`. Instruction: ${ann.message}`
+                        };
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(annotationsWithTips, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error fetching annotations: ${error.message}`,
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            }
+            case "mark_annotation_ready": {
+                try {
+                    const { id, appliedChanges } = request.params.arguments;
+                    const response = await fetch(`${BACKEND_URL}/api/annotations/${id}`, {
+                        method: 'PATCH',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            'x-api-key': apiKey
+                        },
+                        body: JSON.stringify({ status: 'ready_for_review' })
+                    });
+                    if (!response.ok) {
+                        throw new Error(`Backend responded with ${response.status} when updating annotation`);
+                    }
+                    return {
+                        content: [{ type: "text", text: `Successfully marked annotation ${id} as ready_for_review.` }],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [{ type: "text", text: `Error marking annotation ready: ${error.message}` }],
+                        isError: true,
+                    };
+                }
+            }
+            default:
+                throw new Error("Unknown tool");
+        }
+    });
+    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 || "";
+    if (!apiKey) {
+        console.error("Error: VIEWGATE_API_KEY environment variable is required in STDIO mode.");
+        process.exit(1);
+    }
+    const server = createMcpServer(apiKey);
+    const transport = new StdioServerTransport();
+    server.connect(transport).catch((error) => {
+        console.error("Failed to start Stdio transport:", error);
+        process.exit(1);
+    });
+}
+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.get("/sse", async (req, res) => {
+        const apiKey = req.query.apiKey || req.headers['x-api-key'];
+        if (!apiKey) {
+            res.status(401).send("API Key is required");
+            return;
+        }
+        const transport = new SSEServerTransport("/message", res);
+        const server = createMcpServer(apiKey);
+        await server.connect(transport);
+        const sessionId = transport.sessionId;
+        sessions.set(sessionId, { server, transport });
+        res.on("close", () => sessions.delete(sessionId));
+    });
+    app.post("/message", async (req, res) => {
+        const sessionId = req.query.sessionId;
+        const session = sessions.get(sessionId);
+        if (!session) {
+            res.status(404).send("Session not found");
+            return;
+        }
+        await session.transport.handlePostMessage(req, res);
+    });
+    app.listen(port, () => {
+        console.log(`ViewGate MCP (SSE) listening on port ${port}`);
+    });
+}

package/dist/test_fix.js

@@ -0,0 +1,59 @@
+import fetch from "node-fetch";
+async function test() {
+    console.log("1. Connecting to http://localhost:3333/sse...");
+    const response = await fetch("http://localhost:3333/sse?apiKey=2af5628c9442f10b93cfe6970897d4de26578d958ba43a4e3bcb684fe0f92668");
+    if (!response.ok) {
+        console.error("Failed to connect to SSE:", response.status, await response.text());
+        return;
+    }
+    console.log("SSE connected. Reading stream for sessionId...");
+    const body = response.body;
+    let sessionId = null;
+    body.on("data", async (chunk) => {
+        const text = chunk.toString();
+        console.log("SSE Data:", text);
+        // Example event: 
+        // event: endpoint
+        // data: /message?sessionId=...
+        const match = text.match(/sessionId=([a-f0-9-]+)/);
+        if (match && !sessionId) {
+            sessionId = match[1];
+            console.log("FOUND SESSION ID:", sessionId);
+            // 2. Test POST to /message
+            console.log(`2. Testing POST to /message?sessionId=${sessionId}...`);
+            const postResponse = await fetch(`http://localhost:3333/message?sessionId=${sessionId}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: 1,
+                    method: "initialize",
+                    params: {
+                        clientInfo: { name: "test-client", version: "1.0.0" },
+                        protocolVersion: "2024-11-05",
+                        capabilities: {}
+                    }
+                })
+            });
+            console.log("POST Response Status:", postResponse.status);
+            const responseText = await postResponse.text();
+            console.log("POST Response Body:", responseText);
+            if (postResponse.status === 200 || postResponse.status === 202) {
+                console.log("SUCCESS: Stream was readable and message was accepted.");
+            }
+            else {
+                console.error("FAILURE: Server returned error status.");
+            }
+            process.exit(0);
+        }
+    });
+    setTimeout(() => {
+        if (!sessionId) {
+            console.error("TIMEOUT: Did not receive sessionId from SSE.");
+            process.exit(1);
+        }
+    }, 10000);
+}
+test();

package/dist/test_sse.js

@@ -0,0 +1,23 @@
+import fetch from "node-fetch";
+async function test() {
+    console.log("Connecting to http://localhost:3333/sse...");
+    const response = await fetch("http://localhost:3333/sse?apiKey=test-key");
+    if (!response.ok) {
+        console.error("Failed to connect:", response.status, await response.text());
+        return;
+    }
+    console.log("Headers:", response.headers.raw());
+    const body = response.body;
+    body.on("data", (chunk) => {
+        console.log("Chunk received:", chunk.toString());
+        if (chunk.toString().includes("event: endpoint")) {
+            console.log("FOUND ENDPOINT EVENT!");
+        }
+    });
+    body.on("end", () => console.log("Connection closed"));
+    setTimeout(() => {
+        console.log("Closing test...");
+        process.exit(0);
+    }, 5000);
+}
+test();

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "viewgate-mcp",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "bin": {
+    "viewgate-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "start": "node dist/index.js",
+    "dev": "tsx watch src/index.ts",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "cors": "^2.8.6",
+    "dotenv": "^17.3.1",
+    "express": "^5.2.1",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.5.0",
+    "@types/node-fetch": "^2.6.13",
+    "nodemon": "^3.1.14",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}