Add HTTP transport to MCP server

mcp/index.js

@@ -1,37 +1,175 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import express from "express";
+import { z } from "zod";
 
-// Creo la instancia del servidor MCP
-const server = new McpServer({
-  name: "hello-world",
-  version: "0.1.0",
-  capabilities: {
-    resources: {},
-    tools: {}
+const API_BASE_URL = process.env.PLANILLA_API_URL || "http://localhost:4000";
+
+async function fetchJSON(path, options = {}) {
+  const res = await fetch(`${API_BASE_URL}${path}`, {
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    ...options
+  });
+  if (!res.ok) {
+    const txt = await res.text();
+    throw new Error(`API request failed (${res.status}): ${txt}`);
   }
-});
-
-// Registro un tool “hello-world” que devuelve un saludo
-server.tool(
-  "hello-world",
-  "Devuelve un saludo de prueba",
-  {},       // sin parámetros
-  async () => ({
-    content: [
-      { type: "text", text: "¡Hola, mundo!" }
-    ]
-  }) 
-);
-
-async function main() {
-  // Me conecto por stdio (puede ser stdin/stdout de un cliente MCP)
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.log("MCP Hello World Server corriendo por stdio");
-  console.error("MCP Hello World Server corriendo por stdio");
+  return res.json();
 }
 
-main().catch(err => {
+function createServer() {
+  const server = new McpServer({
+    name: "planilla-mcp",
+    version: "0.1.0",
+  });
+
+  // ----- Resources -----
+  // List all planillas
+  server.resource(
+    "planilla-list",
+    "planilla://list",
+    async (uri) => {
+      const planillas = await fetchJSON('/api/planillas');
+      return {
+        contents: [{ uri: uri.href, text: JSON.stringify(planillas) }]
+      };
+    }
+  );
+
+  // Get planilla by ID
+  server.resource(
+    "planilla",
+    new ResourceTemplate("planilla://{id}", { list: undefined }),
+    async (uri, { id }) => {
+      const planilla = await fetchJSON(`/api/planillas/${id}`);
+      return {
+        contents: [{ uri: uri.href, text: JSON.stringify(planilla) }]
+      };
+    }
+  );
+
+  // ----- Tools -----
+  // Create a new planilla
+  server.tool(
+    "create-planilla",
+    "Crea una planilla",
+    {
+      empleado_id: z.number(),
+      fecha_desde: z.string(),
+      fecha_hasta: z.string(),
+      titulo: z.string(),
+      total: z.number().optional(),
+      estado: z.string().optional(),
+      fecha_anulado: z.string().optional(),
+      creador_id: z.number().optional(),
+      anulador_id: z.number().optional(),
+    },
+    async (params) => {
+      const body = JSON.stringify(params);
+      const planilla = await fetchJSON('/api/planillas', { method: 'POST', body });
+      return { content: [{ type: 'text', text: JSON.stringify(planilla) }] };
+    }
+  );
+
+  // Update planilla by ID
+  server.tool(
+    "update-planilla",
+    "Actualiza una planilla existente",
+    {
+      id: z.number(),
+      empleado_id: z.number().optional(),
+      fecha_desde: z.string().optional(),
+      fecha_hasta: z.string().optional(),
+      titulo: z.string().optional(),
+      total: z.number().optional(),
+      estado: z.string().optional(),
+      fecha_anulado: z.string().optional(),
+      anulador_id: z.number().optional(),
+    },
+    async ({ id, ...updates }) => {
+      const body = JSON.stringify(updates);
+      const planilla = await fetchJSON(`/api/planillas/${id}`, {
+        method: 'PUT',
+        body,
+      });
+      return { content: [{ type: 'text', text: JSON.stringify(planilla) }] };
+    }
+  );
+
+  // Delete planilla by ID
+  server.tool(
+    "delete-planilla",
+    "Elimina una planilla",
+    { id: z.number() },
+    async ({ id }) => {
+      await fetchJSON(`/api/planillas/${id}`, { method: 'DELETE' });
+      return { content: [{ type: 'text', text: `Planilla ${id} eliminada` }] };
+    }
+  );
+
+  return server;
+}
+
+async function main() {
+  const useStdio = process.argv.includes("--stdio");
+  if (useStdio) {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.log("MCP Planilla server listo (stdio)");
+  } else {
+    const app = express();
+    app.use(express.json());
+    const port = process.env.PORT || 5000;
+
+    app.post("/mcp", async (req, res) => {
+      try {
+        const server = createServer();
+        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+        res.on("close", () => {
+          transport.close();
+          server.close();
+        });
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+      } catch (error) {
+        console.error("Error handling MCP request:", error);
+        if (!res.headersSent) {
+          res.status(500).json({
+            jsonrpc: "2.0",
+            error: { code: -32603, message: "Internal server error" },
+            id: null,
+          });
+        }
+      }
+    });
+
+    app.get("/mcp", async (_req, res) => {
+      res.writeHead(405).end(JSON.stringify({
+        jsonrpc: "2.0",
+        error: { code: -32000, message: "Method not allowed." },
+        id: null,
+      }));
+    });
+
+    app.delete("/mcp", async (_req, res) => {
+      res.writeHead(405).end(JSON.stringify({
+        jsonrpc: "2.0",
+        error: { code: -32000, message: "Method not allowed." },
+        id: null,
+      }));
+    });
+
+    app.listen(port, () => {
+      console.log(`MCP Planilla HTTP server listening on port ${port}`);
+    });
+  }
+}
+
+main().catch((err) => {
   console.error("Error fatal en MCP server:", err);
   process.exit(1);
 });