@universal-mcp-toolkit/server-vercel 0.1.0

package/.well-known/mcp-server.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json.schemastore.org/json",
+  "name": "vercel",
+  "title": "Vercel MCP Server",
+  "description": "Project, deployment, and account tools for Vercel.",
+  "version": "0.1.0",
+  "packageName": "@universal-mcp-toolkit/server-vercel",
+  "homepage": "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit",
+  "transports": [
+    "stdio",
+    "sse"
+  ],
+  "authentication": {
+    "mode": "environment-variables",
+    "required": [
+      "VERCEL_TOKEN",
+      "VERCEL_TEAM_ID"
+    ]
+  },
+  "capabilities": {
+    "tools": true,
+    "resources": true,
+    "prompts": true
+  },
+  "tools": [
+    "list_projects",
+    "list_deployments",
+    "get_deployment"
+  ],
+  "resources": [
+    "account"
+  ],
+  "prompts": [
+    "deployment-audit"
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 universal-mcp-toolkit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import * as _universal_mcp_toolkit_core from '@universal-mcp-toolkit/core';
+import { ToolkitServer, ToolkitServerMetadata } from '@universal-mcp-toolkit/core';
+import { z } from 'zod';
+
+declare const metadata: ToolkitServerMetadata;
+declare const serverCard: _universal_mcp_toolkit_core.ToolkitServerCard;
+declare const projectSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    framework: z.ZodNullable<z.ZodString>;
+    latestProductionUrl: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const deploymentSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    projectName: z.ZodString;
+    url: z.ZodString;
+    state: z.ZodString;
+    target: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodNullable<z.ZodString>;
+    readyState: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const deploymentDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectName: z.ZodString;
+    url: z.ZodString;
+    state: z.ZodString;
+    target: z.ZodNullable<z.ZodString>;
+    createdAt: z.ZodNullable<z.ZodString>;
+    readyState: z.ZodNullable<z.ZodString>;
+    alias: z.ZodArray<z.ZodString>;
+    inspectorUrl: z.ZodNullable<z.ZodString>;
+    creator: z.ZodObject<{
+        id: z.ZodNullable<z.ZodString>;
+        username: z.ZodNullable<z.ZodString>;
+        email: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+declare const accountSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    username: z.ZodNullable<z.ZodString>;
+    email: z.ZodNullable<z.ZodString>;
+    name: z.ZodNullable<z.ZodString>;
+    defaultTeamId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type VercelProjectSummary = z.infer<typeof projectSummarySchema>;
+type VercelDeploymentSummary = z.infer<typeof deploymentSummarySchema>;
+type VercelDeploymentDetail = z.infer<typeof deploymentDetailSchema>;
+type VercelAccountSummary = z.infer<typeof accountSummarySchema>;
+interface VercelClient {
+    listProjects(input: {
+        limit: number;
+        search?: string;
+    }): Promise<ReadonlyArray<VercelProjectSummary>>;
+    listDeployments(input: {
+        limit: number;
+        projectId?: string;
+        target?: string;
+    }): Promise<ReadonlyArray<VercelDeploymentSummary>>;
+    getDeployment(deploymentId: string): Promise<VercelDeploymentDetail>;
+    getAccountSummary(): Promise<VercelAccountSummary>;
+}
+interface CreateVercelServerOptions {
+    client?: VercelClient;
+    env?: NodeJS.ProcessEnv;
+    fetch?: typeof fetch;
+}
+declare class VercelServer extends ToolkitServer {
+    private readonly client;
+    constructor(client: VercelClient);
+}
+declare function createServer(options?: CreateVercelServerOptions): Promise<VercelServer>;
+declare function main(argv?: readonly string[]): Promise<void>;
+
+export { type CreateVercelServerOptions, type VercelAccountSummary, type VercelClient, type VercelDeploymentDetail, type VercelDeploymentSummary, type VercelProjectSummary, VercelServer, createServer, main, metadata, serverCard };

package/dist/index.js

@@ -0,0 +1,401 @@
+// src/index.ts
+import {
+  createServerCard,
+  defineTool,
+  ExternalServiceError,
+  loadEnv,
+  parseRuntimeOptions,
+  runToolkitServer,
+  ToolkitServer
+} from "@universal-mcp-toolkit/core";
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+import { z } from "zod";
+var toolNames = ["list_projects", "list_deployments", "get_deployment"];
+var resourceNames = ["account"];
+var promptNames = ["deployment-audit"];
+var metadata = {
+  id: "vercel",
+  title: "Vercel MCP Server",
+  description: "Project, deployment, and account tools for Vercel.",
+  version: "0.1.0",
+  packageName: "@universal-mcp-toolkit/server-vercel",
+  homepage: "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit",
+  repositoryUrl: "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit",
+  documentationUrl: "https://github.com/universal-mcp-toolkit/universal-mcp-toolkit/tree/main/servers/vercel",
+  envVarNames: ["VERCEL_TOKEN", "VERCEL_TEAM_ID"],
+  transports: ["stdio", "sse"],
+  toolNames,
+  resourceNames,
+  promptNames
+};
+var serverCard = createServerCard(metadata);
+var envShape = {
+  VERCEL_TOKEN: z.string().min(1),
+  VERCEL_TEAM_ID: z.string().min(1).optional(),
+  VERCEL_API_BASE_URL: z.string().url().optional()
+};
+var projectSummarySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  framework: z.string().nullable(),
+  latestProductionUrl: z.string().nullable(),
+  createdAt: z.string().nullable(),
+  updatedAt: z.string().nullable()
+});
+var deploymentSummarySchema = z.object({
+  id: z.string(),
+  projectName: z.string(),
+  url: z.string(),
+  state: z.string(),
+  target: z.string().nullable(),
+  createdAt: z.string().nullable(),
+  readyState: z.string().nullable()
+});
+var deploymentDetailSchema = deploymentSummarySchema.extend({
+  alias: z.array(z.string()),
+  inspectorUrl: z.string().nullable(),
+  creator: z.object({
+    id: z.string().nullable(),
+    username: z.string().nullable(),
+    email: z.string().nullable()
+  }),
+  meta: z.record(z.string(), z.string()).default({})
+});
+var accountSummarySchema = z.object({
+  id: z.string(),
+  username: z.string().nullable(),
+  email: z.string().nullable(),
+  name: z.string().nullable(),
+  defaultTeamId: z.string().nullable()
+});
+var listProjectsResponseSchema = z.object({
+  projects: z.array(
+    z.object({
+      id: z.string(),
+      name: z.string(),
+      framework: z.string().nullable().optional(),
+      latestProductionUrl: z.string().nullable().optional(),
+      createdAt: z.number().optional(),
+      updatedAt: z.number().optional()
+    })
+  )
+});
+var listDeploymentsResponseSchema = z.object({
+  deployments: z.array(
+    z.object({
+      uid: z.string(),
+      name: z.string(),
+      url: z.string(),
+      state: z.string(),
+      target: z.string().nullable().optional(),
+      created: z.number().optional(),
+      readyState: z.string().nullable().optional()
+    })
+  )
+});
+var deploymentResponseSchema = z.object({
+  uid: z.string(),
+  name: z.string(),
+  url: z.string(),
+  state: z.string(),
+  target: z.string().nullable().optional(),
+  created: z.number().optional(),
+  readyState: z.string().nullable().optional(),
+  alias: z.array(z.string()).optional(),
+  inspectorUrl: z.string().nullable().optional(),
+  creator: z.object({
+    uid: z.string().optional(),
+    username: z.string().nullable().optional(),
+    email: z.string().nullable().optional()
+  }).optional(),
+  meta: z.record(z.string(), z.string()).optional()
+});
+var accountResponseSchema = z.object({
+  id: z.string(),
+  username: z.string().nullable().optional(),
+  email: z.string().nullable().optional(),
+  name: z.string().nullable().optional(),
+  defaultTeamId: z.string().nullable().optional()
+});
+function resolveEnv(source = process.env) {
+  return loadEnv(envShape, source);
+}
+function buildQuery(params) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) {
+      searchParams.set(key, String(value));
+    }
+  }
+  const query = searchParams.toString();
+  return query.length > 0 ? `?${query}` : "";
+}
+function toIsoTimestamp(value) {
+  return typeof value === "number" ? new Date(value).toISOString() : null;
+}
+function toNullableString(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+var FetchVercelClient = class {
+  token;
+  teamId;
+  baseUrl;
+  fetchImpl;
+  constructor(options) {
+    this.token = options.token;
+    this.teamId = options.teamId;
+    this.baseUrl = (options.baseUrl ?? "https://api.vercel.com").replace(/\/+$/, "");
+    this.fetchImpl = options.fetch;
+  }
+  async listProjects(input) {
+    const payload = await this.requestJson(
+      `/v9/projects${buildQuery({ limit: input.limit, search: input.search })}`,
+      listProjectsResponseSchema
+    );
+    return payload.projects.map((project) => ({
+      id: project.id,
+      name: project.name,
+      framework: toNullableString(project.framework),
+      latestProductionUrl: toNullableString(project.latestProductionUrl),
+      createdAt: toIsoTimestamp(project.createdAt),
+      updatedAt: toIsoTimestamp(project.updatedAt)
+    }));
+  }
+  async listDeployments(input) {
+    const payload = await this.requestJson(
+      `/v6/deployments${buildQuery({ limit: input.limit, projectId: input.projectId, target: input.target })}`,
+      listDeploymentsResponseSchema
+    );
+    return payload.deployments.map((deployment) => ({
+      id: deployment.uid,
+      projectName: deployment.name,
+      url: deployment.url,
+      state: deployment.state,
+      target: toNullableString(deployment.target),
+      createdAt: toIsoTimestamp(deployment.created),
+      readyState: toNullableString(deployment.readyState)
+    }));
+  }
+  async getDeployment(deploymentId) {
+    const payload = await this.requestJson(`/v13/deployments/${encodeURIComponent(deploymentId)}`, deploymentResponseSchema);
+    return {
+      id: payload.uid,
+      projectName: payload.name,
+      url: payload.url,
+      state: payload.state,
+      target: toNullableString(payload.target),
+      createdAt: toIsoTimestamp(payload.created),
+      readyState: toNullableString(payload.readyState),
+      alias: payload.alias ?? [],
+      inspectorUrl: toNullableString(payload.inspectorUrl),
+      creator: {
+        id: payload.creator?.uid ?? null,
+        username: toNullableString(payload.creator?.username),
+        email: toNullableString(payload.creator?.email)
+      },
+      meta: payload.meta ?? {}
+    };
+  }
+  async getAccountSummary() {
+    const payload = await this.requestJson("/v2/user", accountResponseSchema);
+    return {
+      id: payload.id,
+      username: toNullableString(payload.username),
+      email: toNullableString(payload.email),
+      name: toNullableString(payload.name),
+      defaultTeamId: toNullableString(payload.defaultTeamId)
+    };
+  }
+  async requestJson(path, schema) {
+    const url = new URL(path, this.baseUrl);
+    if (this.teamId) {
+      url.searchParams.set("teamId", this.teamId);
+    }
+    const response = await this.fetchImpl(url, {
+      method: "GET",
+      headers: {
+        authorization: `Bearer ${this.token}`,
+        accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new ExternalServiceError(`Vercel request failed with status ${response.status}.`, {
+        statusCode: response.status,
+        details: body
+      });
+    }
+    const payload = await response.json();
+    const parsed = schema.safeParse(payload);
+    if (!parsed.success) {
+      throw new ExternalServiceError("Vercel returned an unexpected response shape.", {
+        details: parsed.error.flatten()
+      });
+    }
+    return parsed.data;
+  }
+};
+var VercelServer = class extends ToolkitServer {
+  client;
+  constructor(client) {
+    super(metadata);
+    this.client = client;
+    this.registerTool(
+      defineTool({
+        name: "list_projects",
+        title: "List Vercel projects",
+        description: "List Vercel projects that the current token can access.",
+        inputSchema: {
+          limit: z.number().int().min(1).max(50).default(20),
+          search: z.string().trim().min(1).optional()
+        },
+        outputSchema: {
+          projects: z.array(projectSummarySchema),
+          returned: z.number().int()
+        },
+        handler: async ({ limit, search }, context) => {
+          await context.log("info", "Listing Vercel projects");
+          const request = { limit };
+          if (search !== void 0) {
+            request.search = search;
+          }
+          const projects = await this.client.listProjects(request);
+          return {
+            projects: [...projects],
+            returned: projects.length
+          };
+        },
+        renderText: ({ projects, returned }) => {
+          if (returned === 0) {
+            return "No Vercel projects found.";
+          }
+          return projects.map((project) => `${project.name} (${project.id})`).join("\n");
+        }
+      })
+    );
+    this.registerTool(
+      defineTool({
+        name: "list_deployments",
+        title: "List deployments",
+        description: "List recent Vercel deployments, optionally scoped to a project.",
+        inputSchema: {
+          limit: z.number().int().min(1).max(50).default(10),
+          projectId: z.string().trim().min(1).optional(),
+          target: z.enum(["production", "preview"]).optional()
+        },
+        outputSchema: {
+          deployments: z.array(deploymentSummarySchema),
+          returned: z.number().int()
+        },
+        handler: async ({ limit, projectId, target }, context) => {
+          await context.log("info", "Listing Vercel deployments");
+          const request = { limit };
+          if (projectId !== void 0) {
+            request.projectId = projectId;
+          }
+          if (target !== void 0) {
+            request.target = target;
+          }
+          const deployments = await this.client.listDeployments(request);
+          return {
+            deployments: [...deployments],
+            returned: deployments.length
+          };
+        },
+        renderText: ({ deployments, returned }) => {
+          if (returned === 0) {
+            return "No deployments found.";
+          }
+          return deployments.map((deployment) => `${deployment.projectName}: ${deployment.state} (${deployment.id})`).join("\n");
+        }
+      })
+    );
+    this.registerTool(
+      defineTool({
+        name: "get_deployment",
+        title: "Get deployment",
+        description: "Fetch details for a specific Vercel deployment.",
+        inputSchema: {
+          deploymentId: z.string().trim().min(1)
+        },
+        outputSchema: {
+          deployment: deploymentDetailSchema
+        },
+        handler: async ({ deploymentId }, context) => {
+          await context.log("info", `Fetching deployment ${deploymentId}`);
+          return {
+            deployment: await this.client.getDeployment(deploymentId)
+          };
+        },
+        renderText: ({ deployment }) => `${deployment.projectName} deployment ${deployment.id} is ${deployment.state}`
+      })
+    );
+    this.registerStaticResource(
+      "account",
+      "vercel://account",
+      {
+        title: "Vercel account",
+        description: "Authenticated Vercel account summary.",
+        mimeType: "application/json"
+      },
+      async (uri) => this.createJsonResource(uri.toString(), await this.client.getAccountSummary())
+    );
+    this.registerPrompt(
+      "deployment-audit",
+      {
+        title: "Deployment audit",
+        description: "Draft an audit plan for a Vercel deployment or project.",
+        argsSchema: {
+          target: z.string().trim().min(1),
+          deploymentId: z.string().trim().min(1).optional(),
+          focus: z.string().trim().min(1).optional()
+        }
+      },
+      async ({ target, deploymentId, focus }) => this.createTextPrompt(
+        [
+          `Audit the Vercel target "${target}"${deploymentId ? ` using deployment ${deploymentId}` : ""}.`,
+          "Check deployment state, aliases, runtime configuration, rollback readiness, and production impact.",
+          focus ? `Pay extra attention to: ${focus}.` : "Highlight the highest-risk operational gaps first."
+        ].join(" ")
+      )
+    );
+  }
+};
+async function createServer(options = {}) {
+  if (options.client) {
+    return new VercelServer(options.client);
+  }
+  const env = resolveEnv(options.env);
+  const client = new FetchVercelClient({
+    token: env.VERCEL_TOKEN,
+    fetch: options.fetch ?? globalThis.fetch,
+    ...env.VERCEL_TEAM_ID ? { teamId: env.VERCEL_TEAM_ID } : {},
+    ...env.VERCEL_API_BASE_URL ? { baseUrl: env.VERCEL_API_BASE_URL } : {}
+  });
+  return new VercelServer(client);
+}
+function isMainModule(metaUrl) {
+  const entry = process.argv[1];
+  return typeof entry === "string" && fileURLToPath(metaUrl) === resolve(entry);
+}
+async function main(argv = process.argv.slice(2)) {
+  const runtimeOptions = parseRuntimeOptions(argv);
+  await runToolkitServer(
+    {
+      createServer: () => createServer(),
+      serverCard
+    },
+    runtimeOptions
+  );
+}
+if (isMainModule(import.meta.url)) {
+  await main();
+}
+export {
+  VercelServer,
+  createServer,
+  main,
+  metadata,
+  serverCard
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@universal-mcp-toolkit/server-vercel",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Project, deployment, and environment tools for Vercel.",
+  "license": "MIT",
+  "bin": {
+    "server-vercel": "./dist/index.js",
+    "umt-vercel": "./dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Markgatcha/universal-mcp-toolkit.git"
+  },
+  "homepage": "https://github.com/Markgatcha/universal-mcp-toolkit#readme",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    ".well-known"
+  ],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "developer-tools",
+    "typescript",
+    "vercel",
+    "deployments",
+    "hosting",
+    "frontend"
+  ],
+  "dependencies": {
+    "@universal-mcp-toolkit/core": "0.1.0",
+    "zod": "^4.3.6"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsx watch src/index.ts",
+    "lint": "tsc --noEmit",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "clean": "rimraf dist"
+  }
+}