@hanzo/platform-mcp 1.4.0

package/build/http-server.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import express from "express";
+import { randomUUID } from "node:crypto";
+import { createServer } from "./server.js";
+import { createLogger } from "./utils/logger.js";
+// Container always uses port 3000 internally
+const PORT = 3000;
+const logger = createLogger("MCP-HTTP-Server");
+export async function main() {
+    const app = express();
+    app.use(express.json());
+    // Store active transports by session ID for different transport types
+    const transports = {
+        streamable: {},
+        sse: {},
+    };
+    // Health check endpoint
+    app.get("/health", (_req, res) => {
+        res.json({ status: "ok", timestamp: new Date().toISOString() });
+    });
+    // Modern Streamable HTTP endpoint for POST requests (client-to-server)
+    app.post("/mcp", async (req, res) => {
+        try {
+            // Check for existing session ID
+            const sessionId = req.headers["mcp-session-id"];
+            let transport;
+            if (sessionId && transports.streamable[sessionId]) {
+                // Reuse existing transport
+                transport = transports.streamable[sessionId];
+            }
+            else if (!sessionId && isInitializeRequest(req.body)) {
+                // New initialization request
+                transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    onsessioninitialized: (sessionId) => {
+                        // Store the transport by session ID
+                        transports.streamable[sessionId] = transport;
+                        logger.info("New MCP session initialized", { sessionId });
+                    },
+                });
+                // Clean up transport when closed
+                transport.onclose = () => {
+                    if (transport.sessionId) {
+                        logger.info("MCP session closed", {
+                            sessionId: transport.sessionId,
+                        });
+                        delete transports.streamable[transport.sessionId];
+                    }
+                };
+                // Create and connect server first
+                const server = createServer();
+                // The transport will have sessionId after initialization
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                await server.connect(transport);
+                // Log after successful connection
+                logger.info("New MCP session server connected", {
+                    sessionId: transport.sessionId,
+                });
+            }
+            else {
+                // Invalid request
+                res.status(400).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: "Bad Request: No valid session ID provided for existing session or invalid initialization request",
+                    },
+                    id: null,
+                });
+                return;
+            }
+            // Handle the request
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            logger.error("Error handling HTTP request", {
+                error: error instanceof Error ? error.message : String(error),
+                sessionId: req.headers["mcp-session-id"],
+            });
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: "Internal server error",
+                    },
+                    id: null,
+                });
+            }
+        }
+    });
+    // Reusable handler for GET and DELETE requests (Streamable HTTP)
+    const handleSessionRequest = async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        if (!sessionId || !transports.streamable[sessionId]) {
+            res.status(400).json({
+                jsonrpc: "2.0",
+                error: {
+                    code: -32000,
+                    message: "Invalid or missing session ID",
+                },
+                id: null,
+            });
+            return;
+        }
+        try {
+            const transport = transports.streamable[sessionId];
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            logger.error("Error handling session request", {
+                error: error instanceof Error ? error.message : String(error),
+                sessionId,
+                method: req.method,
+            });
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: "Internal server error",
+                    },
+                    id: null,
+                });
+            }
+        }
+    };
+    // Handle GET requests for server-to-client notifications via SSE
+    app.get("/mcp", handleSessionRequest);
+    // Handle DELETE requests for session termination
+    app.delete("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        if (!sessionId || !transports.streamable[sessionId]) {
+            res.status(400).json({
+                jsonrpc: "2.0",
+                error: {
+                    code: -32000,
+                    message: "Invalid or missing session ID",
+                },
+                id: null,
+            });
+            return;
+        }
+        try {
+            const transport = transports.streamable[sessionId];
+            await transport.handleRequest(req, res);
+            // Clean up after session termination
+            if (transports.streamable[sessionId]) {
+                logger.info("MCP session terminated", { sessionId });
+                delete transports.streamable[sessionId];
+            }
+        }
+        catch (error) {
+            logger.error("Error handling DELETE request", {
+                error: error instanceof Error ? error.message : String(error),
+                sessionId,
+            });
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: "Internal server error",
+                    },
+                    id: null,
+                });
+            }
+        }
+    });
+    // Legacy SSE endpoint for older clients (protocol version 2024-11-05)
+    app.get("/sse", async (_req, res) => {
+        try {
+            // Create SSE transport for legacy clients
+            const transport = new SSEServerTransport("/messages", res);
+            transports.sse[transport.sessionId] = transport;
+            res.on("close", () => {
+                logger.info("Legacy SSE session closed", {
+                    sessionId: transport.sessionId,
+                });
+                delete transports.sse[transport.sessionId];
+            });
+            // Create and connect server for this transport
+            const server = createServer();
+            await server.connect(transport);
+            logger.info("New legacy SSE session initialized", {
+                sessionId: transport.sessionId,
+            });
+        }
+        catch (error) {
+            logger.error("Error handling SSE request", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: "Internal server error",
+                    },
+                    id: null,
+                });
+            }
+        }
+    });
+    // Legacy message endpoint for older clients
+    app.post("/messages", async (req, res) => {
+        try {
+            const sessionId = req.query.sessionId;
+            if (!sessionId) {
+                logger.warn("No sessionId provided in message request");
+                res.status(400).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: "sessionId query parameter is required",
+                    },
+                    id: null,
+                });
+                return;
+            }
+            const transport = transports.sse[sessionId];
+            if (!transport) {
+                logger.warn("No SSE transport found for sessionId", { sessionId });
+                res.status(400).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: "No transport found for sessionId",
+                    },
+                    id: null,
+                });
+                return;
+            }
+            await transport.handlePostMessage(req, res, req.body);
+        }
+        catch (error) {
+            logger.error("Error handling legacy message request", {
+                error: error instanceof Error ? error.message : String(error),
+                sessionId: req.query.sessionId,
+            });
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: "Internal server error",
+                    },
+                    id: null,
+                });
+            }
+        }
+    });
+    // Start the server
+    app.listen(PORT, () => {
+        logger.info("MCP Platform server started", {
+            port: PORT,
+            protocols: [
+                "Streamable HTTP (MCP 2025-03-26)",
+                "Legacy SSE (MCP 2024-11-05)",
+            ],
+            endpoints: {
+                modern: {
+                    mcp: `http://localhost:${PORT}/mcp`,
+                    health: `http://localhost:${PORT}/health`,
+                },
+                legacy: {
+                    sse: `http://localhost:${PORT}/sse`,
+                    messages: `http://localhost:${PORT}/messages`,
+                },
+            },
+        });
+    });
+}
+// Only run if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch((error) => {
+        logger.error("Fatal error occurred", {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        process.exit(1);
+    });
+}

package/build/index.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+import { createLogger } from "./utils/logger.js";
+const logger = createLogger("MCP-Entry");
+async function main() {
+    // Check if running in HTTP mode
+    const args = process.argv.slice(2);
+    const httpMode = args.includes("--http") ||
+        args.includes("--sse") ||
+        process.env.MCP_TRANSPORT === "http" ||
+        process.env.MCP_TRANSPORT === "sse";
+    if (httpMode) {
+        // Dynamic import to avoid loading Express dependencies when not needed
+        const httpModule = await import("./http-server.js");
+        if (typeof httpModule.main === "function") {
+            return httpModule.main();
+        }
+        else {
+            throw new Error("HTTP server module does not export main function");
+        }
+    }
+    // Default: stdio mode
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logger.info("MCP Platform CLI server running via stdio");
+}
+main().catch((error) => {
+    logger.error("Fatal error occurred", {
+        error: error.message,
+        stack: error.stack,
+    });
+    process.exit(1);
+});

package/build/mcp/tools/application/applicationCleanQueues.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const applicationCleanQueues = createTool({
+    name: "application-cleanQueues",
+    description: "Cleans the queues for an application in Platform.",
+    schema: z.object({
+        applicationId: z
+            .string()
+            .describe("The ID of the application to clean queues for."),
+    }),
+    annotations: {
+        title: "Clean Application Queues",
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/application.cleanQueues", input);
+        return ResponseFormatter.success(`Queues for application "${input.applicationId}" cleaned successfully`, response.data);
+    },
+});

package/build/mcp/tools/application/applicationCreate.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { createTool } from "../toolFactory.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+export const applicationCreate = createTool({
+    name: "application-create",
+    description: "Creates a new application in Platform.",
+    schema: z.object({
+        name: z.string().min(1).describe("The name of the application."),
+        appName: z
+            .string()
+            .optional()
+            .describe("The app name for the application."),
+        description: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("An optional description for the application."),
+        projectId: z
+            .string()
+            .min(1)
+            .describe("The ID of the project where the application will be created."),
+        serverId: z
+            .string()
+            .nullable()
+            .optional()
+            .describe("The ID of the server where the application will be deployed."),
+    }),
+    annotations: {
+        title: "Create Application",
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/application.create", input);
+        return ResponseFormatter.success(`Application "${input.name}" created successfully in project "${input.projectId}"`, response.data);
+    },
+});

package/build/mcp/tools/application/applicationDelete.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const applicationDelete = createTool({
+    name: "application-delete",
+    description: "Deletes an application in Platform.",
+    schema: z.object({
+        applicationId: z.string().describe("The ID of the application to delete."),
+    }),
+    annotations: {
+        title: "Delete Application",
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/application.delete", input);
+        return ResponseFormatter.success(`Application "${input.applicationId}" deleted successfully`, response.data);
+    },
+});

package/build/mcp/tools/application/applicationDeploy.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const applicationDeploy = createTool({
+    name: "application-deploy",
+    description: "Deploys an application in Platform.",
+    schema: z.object({
+        applicationId: z.string().describe("The ID of the application to deploy."),
+    }),
+    annotations: {
+        title: "Deploy Application",
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/application.deploy", input);
+        return ResponseFormatter.success(`Application "${input.applicationId}" deployment started successfully`, response.data);
+    },
+});

package/build/mcp/tools/application/applicationMarkRunning.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const applicationMarkRunning = createTool({
+    name: "application-markRunning",
+    description: "Marks an application as running in Platform.",
+    schema: z.object({
+        applicationId: z
+            .string()
+            .describe("The ID of the application to mark as running."),
+    }),
+    annotations: {
+        title: "Mark Application as Running",
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/application.markRunning", input);
+        return ResponseFormatter.success(`Application "${input.applicationId}" marked as running successfully`, response.data);
+    },
+});

package/build/mcp/tools/application/applicationMove.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const applicationMove = createTool({
+    name: "application-move",
+    description: "Moves an application to a different project in Platform.",
+    schema: z.object({
+        applicationId: z.string().describe("The ID of the application to move."),
+        targetProjectId: z.string().describe("The ID of the destination project."),
+    }),
+    annotations: {
+        title: "Move Application",
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/application.move", input);
+        return ResponseFormatter.success(`Application "${input.applicationId}" moved to project "${input.targetProjectId}" successfully`, response.data);
+    },
+});

package/build/mcp/tools/application/applicationOne.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { createTool } from "../toolFactory.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+export const applicationOne = createTool({
+    name: "application-one",
+    description: "Gets a specific application by its ID in Platform.",
+    schema: z.object({
+        applicationId: z
+            .string()
+            .describe("The ID of the application to retrieve."),
+    }),
+    annotations: {
+        title: "Get Application Details",
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const application = await apiClient.get(`/application.one?applicationId=${input.applicationId}`);
+        if (!application?.data) {
+            return ResponseFormatter.error("Failed to fetch application", `Application with ID "${input.applicationId}" not found`);
+        }
+        return ResponseFormatter.success(`Successfully fetched application "${input.applicationId}"`, application.data);
+    },
+});

package/build/mcp/tools/application/applicationReadAppMonitoring.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const applicationReadAppMonitoring = createTool({
+    name: "application-readAppMonitoring",
+    description: "Reads monitoring data for an application in Platform.",
+    schema: z.object({
+        appName: z
+            .string()
+            .describe("The app name of the application to get monitoring data for."),
+    }),
+    annotations: {
+        title: "Read Application Monitoring",
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.get(`/application.readAppMonitoring?appName=${input.appName}`);
+        if (!response?.data) {
+            return ResponseFormatter.error("Failed to fetch application monitoring data", `No monitoring data found for application "${input.appName}"`);
+        }
+        return ResponseFormatter.success(`Successfully fetched monitoring data for application "${input.appName}"`, response.data);
+    },
+});

package/build/mcp/tools/application/applicationReadTraefikConfig.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const applicationReadTraefikConfig = createTool({
+    name: "application-readTraefikConfig",
+    description: "Reads Traefik configuration for an application in Platform.",
+    schema: z.object({
+        applicationId: z
+            .string()
+            .describe("The ID of the application to get Traefik config for."),
+    }),
+    annotations: {
+        title: "Read Application Traefik Config",
+        readOnlyHint: true,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.get(`/application.readTraefikConfig?applicationId=${input.applicationId}`);
+        if (!response?.data) {
+            return ResponseFormatter.error("Failed to fetch application Traefik configuration", `No Traefik configuration found for application "${input.applicationId}"`);
+        }
+        return ResponseFormatter.success(`Successfully fetched Traefik configuration for application "${input.applicationId}"`, response.data);
+    },
+});

package/build/mcp/tools/application/applicationRedeploy.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const applicationRedeploy = createTool({
+    name: "application-redeploy",
+    description: "Redeploys an application in Platform.",
+    schema: z.object({
+        applicationId: z
+            .string()
+            .describe("The ID of the application to redeploy."),
+    }),
+    annotations: {
+        title: "Redeploy Application",
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/application.redeploy", input);
+        return ResponseFormatter.success(`Application "${input.applicationId}" redeployment started successfully`, response.data);
+    },
+});

package/build/mcp/tools/application/applicationRefreshToken.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const applicationRefreshToken = createTool({
+    name: "application-refreshToken",
+    description: "Refreshes the token for an application in Platform.",
+    schema: z.object({
+        applicationId: z
+            .string()
+            .describe("The ID of the application to refresh token for."),
+    }),
+    annotations: {
+        title: "Refresh Application Token",
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/application.refreshToken", input);
+        return ResponseFormatter.success(`Token for application "${input.applicationId}" refreshed successfully`, response.data);
+    },
+});

package/build/mcp/tools/application/applicationReload.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import apiClient from "../../../utils/apiClient.js";
+import { ResponseFormatter } from "../../../utils/responseFormatter.js";
+import { createTool } from "../toolFactory.js";
+export const applicationReload = createTool({
+    name: "application-reload",
+    description: "Reloads an application in Platform.",
+    schema: z.object({
+        applicationId: z.string().describe("The ID of the application to reload."),
+        appName: z.string().describe("The app name of the application to reload."),
+    }),
+    annotations: {
+        title: "Reload Application",
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true,
+    },
+    handler: async (input) => {
+        const response = await apiClient.post("/application.reload", input);
+        return ResponseFormatter.success(`Application "${input.applicationId}" reloaded successfully`, response.data);
+    },
+});