deploy-mcp 0.1.0

package/dist/chunk-QRZL43CY.js

@@ -0,0 +1,297 @@
+// src/core/tools.ts
+import { z } from "zod";
+var checkDeploymentStatusSchema = z.object({
+  platform: z.enum(["vercel"]).describe("The deployment platform (more platforms coming soon)"),
+  project: z.string().describe("The project name or ID"),
+  token: z.string().optional().describe("API token for authentication (optional if set in environment)")
+});
+
+// src/core/mcp-handler.ts
+var MCPHandler = class {
+  constructor(adapters) {
+    this.adapters = adapters;
+  }
+  async handleToolCall(tool, args) {
+    switch (tool) {
+      case "check_deployment_status":
+        return this.checkDeploymentStatus(args);
+      default:
+        throw new Error(`Unknown tool: ${tool}`);
+    }
+  }
+  async handleRequest(request) {
+    if (request.method === "tools/call") {
+      const { name, arguments: args } = request.params;
+      const result = await this.handleToolCall(name, args);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+    if (request.method === "tools/list") {
+      return {
+        tools: [
+          {
+            name: "check_deployment_status",
+            description: "Check the latest deployment status for a project on a platform",
+            inputSchema: {
+              type: "object",
+              properties: {
+                platform: {
+                  type: "string",
+                  enum: ["vercel"],
+                  description: "The deployment platform"
+                },
+                project: {
+                  type: "string",
+                  description: "The project name or ID"
+                },
+                token: {
+                  type: "string",
+                  description: "API token for authentication (optional if set in environment)"
+                }
+              },
+              required: ["platform", "project"]
+            }
+          }
+        ]
+      };
+    }
+    throw new Error(`Unknown method: ${request.method}`);
+  }
+  async checkDeploymentStatus(args) {
+    const validated = checkDeploymentStatusSchema.parse(args);
+    const adapter = this.adapters.get(validated.platform);
+    if (!adapter) {
+      throw new Error(`Unsupported platform: ${validated.platform}`);
+    }
+    try {
+      const status = await adapter.getLatestDeployment(
+        validated.project,
+        validated.token
+      );
+      return this.formatResponse(status, validated.platform);
+    } catch (error) {
+      console.error(`Error checking deployment status: ${error}`);
+      return {
+        status: "error",
+        platform: validated.platform,
+        projectName: validated.project,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  formatResponse(status, platform) {
+    return {
+      ...status,
+      platform,
+      timestamp: status.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+};
+
+// src/adapters/base/adapter.ts
+var BaseAdapter = class {
+  formatTimestamp(date) {
+    return new Date(date).toISOString();
+  }
+  calculateDuration(start, end) {
+    const startTime = new Date(start).getTime();
+    const endTime = end ? new Date(end).getTime() : Date.now();
+    return Math.floor((endTime - startTime) / 1e3);
+  }
+};
+
+// src/adapters/base/types.ts
+var AdapterException = class extends Error {
+  constructor(type, message, originalError) {
+    super(message);
+    this.type = type;
+    this.originalError = originalError;
+    this.name = "AdapterException";
+  }
+};
+
+// src/adapters/vercel/api.ts
+var VercelAPI = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Get deployments for a project
+   */
+  async getDeployments(projectId, token, limit = 1) {
+    const url = `${this.config.baseUrl}/v6/deployments?projectId=${projectId}&limit=${limit}`;
+    try {
+      const response = await this.makeRequest(url, token);
+      return await response.json();
+    } catch (error) {
+      throw this.handleApiError(
+        error,
+        `Failed to fetch deployments for project ${projectId}`
+      );
+    }
+  }
+  /**
+   * Get user information to validate token
+   */
+  async getUser(token) {
+    const url = `${this.config.baseUrl}/v2/user`;
+    try {
+      const response = await this.makeRequest(url, token);
+      return await response.json();
+    } catch (error) {
+      throw this.handleApiError(error, "Failed to validate Vercel token");
+    }
+  }
+  /**
+   * Make authenticated request to Vercel API
+   */
+  async makeRequest(url, token) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          "User-Agent": "deploy-mcp/1.0.0"
+        }
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return response;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Handle and categorize API errors
+   */
+  handleApiError(error, context) {
+    if (error instanceof Error) {
+      if (error.message.includes("401")) {
+        return new AdapterException(
+          "UNAUTHORIZED",
+          "Invalid Vercel token",
+          error
+        );
+      }
+      if (error.message.includes("404")) {
+        return new AdapterException("NOT_FOUND", "Project not found", error);
+      }
+      if (error.message.includes("429")) {
+        return new AdapterException(
+          "RATE_LIMITED",
+          "Rate limit exceeded",
+          error
+        );
+      }
+      if (error.name === "AbortError") {
+        return new AdapterException("NETWORK_ERROR", "Request timeout", error);
+      }
+      return new AdapterException("NETWORK_ERROR", context, error);
+    }
+    return new AdapterException("UNKNOWN_ERROR", context);
+  }
+};
+
+// src/adapters/vercel/index.ts
+var VercelAdapter = class extends BaseAdapter {
+  name = "vercel";
+  api;
+  constructor(config) {
+    super();
+    const defaultConfig = {
+      baseUrl: "https://api.vercel.com",
+      timeout: 1e4,
+      retryAttempts: 3
+    };
+    this.api = new VercelAPI({ ...defaultConfig, ...config });
+  }
+  async getLatestDeployment(project, token) {
+    const apiToken = token || process.env.VERCEL_TOKEN;
+    if (!apiToken) {
+      throw new Error(
+        "Vercel token required. Set VERCEL_TOKEN environment variable or pass token parameter."
+      );
+    }
+    try {
+      const data = await this.api.getDeployments(project, apiToken, 1);
+      if (!data.deployments || data.deployments.length === 0) {
+        return {
+          status: "unknown",
+          projectName: project,
+          platform: "vercel"
+        };
+      }
+      return this.transformDeployment(data.deployments[0]);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw error;
+      }
+      throw new Error("Failed to fetch deployment status from Vercel");
+    }
+  }
+  async authenticate(token) {
+    try {
+      await this.api.getUser(token);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Transform Vercel deployment to standard format
+   */
+  transformDeployment(deployment) {
+    const status = this.mapState(deployment.state);
+    return {
+      id: deployment.uid,
+      status,
+      url: deployment.url ? `https://${deployment.url}` : void 0,
+      projectName: deployment.name,
+      platform: "vercel",
+      timestamp: this.formatTimestamp(deployment.createdAt),
+      duration: deployment.ready ? this.calculateDuration(deployment.createdAt, deployment.ready) : void 0,
+      environment: deployment.target || "production",
+      commit: deployment.meta ? {
+        sha: deployment.meta.githubCommitSha,
+        message: deployment.meta.githubCommitMessage,
+        author: deployment.meta.githubCommitAuthorName
+      } : void 0
+    };
+  }
+  /**
+   * Map Vercel states to standard deployment status
+   */
+  mapState(state) {
+    switch (state) {
+      case "READY":
+        return "success";
+      case "ERROR":
+      case "CANCELED":
+        return "failed";
+      case "BUILDING":
+      case "INITIALIZING":
+      case "QUEUED":
+        return "building";
+      default:
+        return "unknown";
+    }
+  }
+};
+
+export {
+  MCPHandler,
+  VercelAdapter
+};

package/dist/index.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import {
+  MCPHandler,
+  VercelAdapter
+} from "./chunk-QRZL43CY.js";
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var handler = new MCPHandler(
+  /* @__PURE__ */ new Map([
+    ["vercel", new VercelAdapter()]
+    // ['netlify', new NetlifyAdapter()] // To be implemented
+  ])
+);
+var server = new Server(
+  {
+    name: "deploy-mcp",
+    version: "0.1.0",
+    description: "Universal deployment tracker for AI assistants"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "check_deployment_status",
+        description: "Check the latest deployment status for a project on a platform",
+        inputSchema: {
+          type: "object",
+          properties: {
+            platform: {
+              type: "string",
+              enum: ["vercel"],
+              description: "The deployment platform"
+            },
+            project: {
+              type: "string",
+              description: "The project name or ID"
+            },
+            token: {
+              type: "string",
+              description: "API token for authentication (optional if set in environment)"
+            }
+          },
+          required: ["platform", "project"]
+        }
+      }
+    ]
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    const result = await handler.handleToolCall(
+      request.params.name,
+      request.params.arguments
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : "Unknown error occurred"}`
+        }
+      ],
+      isError: true
+    };
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("Deploy MCP server started");
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});