@mgsoftwarebv/mg-dashboard-mcp 3.13.0 → 3.14.0

package/dist/index.js

@@ -9,7 +9,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { ListToolsRequestSchema, CallToolRequestSchema, isInitializeRequest, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListResourceTemplatesRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, ListToolsResultSchema, CallToolResultSchema, ListPromptsResultSchema, GetPromptResultSchema, ListResourcesResultSchema, ReadResourceResultSchema, ListResourceTemplatesResultSchema, EmptyResultSchema } from '@modelcontextprotocol/sdk/types.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { createServer } from 'http';
-import { randomUUID, createHash, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
+import { randomUUID, createHash, randomBytes, createDecipheriv, createCipheriv } from 'crypto';
 import { createClient } from '@supabase/supabase-js';
 import { readFile, mkdtemp, writeFile, rm } from 'fs/promises';
 import { tmpdir } from 'os';
@@ -1213,6 +1213,393 @@ LinkedIn: ${pageLinkedIn.join(", ")}`;
       return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
   }
 }
+
+// src/vercel-tools.ts
+var VERCEL_API = "https://api.vercel.com";
+var VERCEL_TOOLS = [
+  {
+    name: "vercel-projects",
+    description: "List Vercel projects in the configured account/team. Returns id, name, framework, GitHub repo link, production URL, and the latest deployment summary. Use the project name or id as input to vercel-deployments.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Max projects to return (default 50, max 200)" },
+        search: { type: "string", description: "Substring filter on project name (case-insensitive)" }
+      }
+    }
+  },
+  {
+    name: "vercel-deployments",
+    description: "List recent deployments for a Vercel project. Returns deployment ID, state, target, branch, commit and timestamps. Use the deployment ID with vercel-logs.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Vercel project ID or name (from vercel-projects)" },
+        state: {
+          type: "string",
+          description: "Optional state filter: BUILDING, ERROR, INITIALIZING, QUEUED, READY, CANCELED"
+        },
+        target: { type: "string", description: "Optional target filter: production or preview" },
+        limit: { type: "number", description: "Max deployments to return (default 20, max 100)" }
+      },
+      required: ["project"]
+    }
+  },
+  {
+    name: "vercel-logs",
+    description: 'Unified log inspector for Vercel. Use `kind` to pick the source:\n- "build" (default): build / deployment console events (stdout, stderr, command, exit). Requires deploymentId.\n- "runtime": runtime / function logs after a successful build. Requires project + deploymentId.\n- "webhooks": our own vercel_webhook_logs table (Telegram / push delivery history). No deployment needed.\nPick deployments via vercel-deployments first.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        kind: {
+          type: "string",
+          enum: ["build", "runtime", "webhooks"],
+          description: "Which log stream to fetch (default: build)."
+        },
+        project: {
+          type: "string",
+          description: 'Vercel project ID or name (required for kind="runtime").'
+        },
+        deploymentId: {
+          type: "string",
+          description: 'Vercel deployment ID (required for kind="build" or "runtime").'
+        },
+        projectName: {
+          type: "string",
+          description: 'Optional project_name filter (kind="webhooks" only).'
+        },
+        status: {
+          type: "string",
+          description: 'Optional status filter (kind="webhooks" only): sent, skipped, error.'
+        },
+        sinceMinutes: {
+          type: "number",
+          description: 'Time window in minutes (kind="runtime" only, default 60, max 7 days).'
+        },
+        limit: {
+          type: "number",
+          description: "Max entries to return. Defaults per kind: build=500 (max 5000), runtime=200 (max 1000), webhooks=25 (max 200)."
+        }
+      }
+    }
+  }
+];
+var VERCEL_TOOL_NAMES = new Set(VERCEL_TOOLS.map((t) => t.name));
+var VERCEL_TOOL_MODULE_MAP = {
+  "vercel-projects": "ci_cd",
+  "vercel-deployments": "ci_cd",
+  "vercel-logs": "ci_cd"
+};
+async function vercelFetch(token, path) {
+  const res = await fetch(`${VERCEL_API}${path}`, {
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" }
+  });
+  const body = await res.text();
+  let parsed = null;
+  try {
+    parsed = body ? JSON.parse(body) : null;
+  } catch {
+  }
+  if (!res.ok) {
+    const msg = parsed?.error?.message ?? parsed?.message ?? body ?? `HTTP ${res.status}`;
+    return { data: null, error: `Vercel API ${res.status}: ${msg}`, status: res.status };
+  }
+  return { data: parsed, error: null, status: res.status };
+}
+async function listVercelProjectsAll(token, limit) {
+  const collected = [];
+  let nextTimestamp;
+  while (collected.length < limit) {
+    const params = new URLSearchParams({ limit: String(Math.min(limit - collected.length, 100)) });
+    if (nextTimestamp) params.set("until", String(nextTimestamp));
+    const res = await vercelFetch(token, `/v9/projects?${params.toString()}`);
+    if (res.error) return { projects: [], error: res.error };
+    if (!res.data?.projects?.length) break;
+    collected.push(...res.data.projects);
+    if (!res.data.pagination?.next) break;
+    nextTimestamp = res.data.pagination.next;
+  }
+  return { projects: collected, error: null };
+}
+async function listVercelDeployments(token, options) {
+  const params = new URLSearchParams({
+    limit: String(options.limit),
+    projectId: options.projectId
+  });
+  if (options.state) params.set("state", options.state);
+  if (options.target) params.set("target", options.target);
+  const res = await vercelFetch(
+    token,
+    `/v6/deployments?${params.toString()}`
+  );
+  if (res.error) return { deployments: [], error: res.error };
+  return { deployments: res.data?.deployments ?? [], error: null };
+}
+async function getDeploymentBuildEvents(token, deploymentId, limit) {
+  const params = new URLSearchParams({
+    limit: String(limit),
+    direction: "forward",
+    follow: "0"
+  });
+  const url = `${VERCEL_API}/v3/deployments/${encodeURIComponent(deploymentId)}/events?${params.toString()}`;
+  const res = await fetch(url, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  const body = await res.text();
+  if (!res.ok) {
+    let msg = body;
+    try {
+      const parsed = JSON.parse(body);
+      msg = parsed?.error?.message ?? parsed?.message ?? body;
+    } catch {
+    }
+    return { events: [], error: `Vercel API ${res.status}: ${msg}` };
+  }
+  const events = [];
+  const trimmed = body.trim();
+  if (!trimmed) return { events, error: null };
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+      for (const r of parsed) events.push(r);
+      return { events, error: null };
+    }
+  } catch {
+  }
+  for (const line of trimmed.split("\n")) {
+    const s = line.trim();
+    if (!s) continue;
+    try {
+      events.push(JSON.parse(s));
+    } catch {
+    }
+  }
+  return { events, error: null };
+}
+async function getRuntimeLogs(token, projectIdOrName, deploymentId, limit, sinceMs) {
+  const params = new URLSearchParams({
+    limit: String(Math.min(Math.max(limit, 1), 1e3))
+  });
+  if (sinceMs) params.set("since", String(sinceMs));
+  const url = `${VERCEL_API}/v1/projects/${encodeURIComponent(projectIdOrName)}/deployments/${encodeURIComponent(deploymentId)}/runtime-logs?${params.toString()}`;
+  const res = await fetch(url, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  const body = await res.text();
+  if (!res.ok) {
+    let msg = body;
+    try {
+      const parsed = JSON.parse(body);
+      msg = parsed?.error?.message ?? parsed?.message ?? body;
+    } catch {
+    }
+    return { logs: [], error: `Vercel API ${res.status}: ${msg}` };
+  }
+  const logs = [];
+  const trimmed = body.trim();
+  if (!trimmed) return { logs, error: null };
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (Array.isArray(parsed)) {
+      for (const r of parsed) logs.push(r);
+      return { logs, error: null };
+    }
+  } catch {
+  }
+  for (const line of trimmed.split("\n")) {
+    const s = line.trim();
+    if (!s) continue;
+    try {
+      logs.push(JSON.parse(s));
+    } catch {
+    }
+  }
+  return { logs, error: null };
+}
+async function getVercelToken(deps) {
+  const { data, error } = await deps.supabase.from("app_setting").select("vercel_token_encrypted").maybeSingle();
+  if (error) throw new Error(`Could not read app_setting: ${error.message}`);
+  if (!data?.vercel_token_encrypted) {
+    throw new Error("Vercel API token is not configured. Add it in dashboard Settings.");
+  }
+  try {
+    return deps.decrypt(data.vercel_token_encrypted);
+  } catch {
+    throw new Error("Failed to decrypt the stored Vercel API token.");
+  }
+}
+async function resolveProjectId(token, projectInput) {
+  const res = await vercelFetch(
+    token,
+    `/v9/projects/${encodeURIComponent(projectInput)}`
+  );
+  if (res.error || !res.data?.id) {
+    throw new Error(
+      `Could not resolve Vercel project "${projectInput}": ${res.error ?? "not found"}`
+    );
+  }
+  return res.data.id;
+}
+function formatTimestamp(ms) {
+  if (!ms) return "";
+  return new Date(ms).toLocaleString("nl-NL", { timeZone: "Europe/Amsterdam" });
+}
+function formatProjectsTable(projects) {
+  if (projects.length === 0) return "No Vercel projects found";
+  const lines = projects.map((p) => {
+    const repo = p.link ? `${p.link.org ?? ""}/${p.link.repo ?? ""}` : "";
+    const prodUrl = p.targets?.production?.alias?.[0] ?? p.targets?.production?.url ?? "";
+    const latest = p.latestDeployments?.[0];
+    const latestStr = latest ? `${latest.state} @ ${formatTimestamp(latest.createdAt)}` : "";
+    return `${p.id.padEnd(28)}  ${(p.name || "").padEnd(40)}  ${(p.framework || "-").padEnd(10)}  ${repo.padEnd(40)}  ${prodUrl.padEnd(35)}  ${latestStr}`;
+  });
+  const header = `${"ID".padEnd(28)}  ${"NAME".padEnd(40)}  ${"FRAMEWORK".padEnd(10)}  ${"REPO".padEnd(40)}  ${"PROD URL".padEnd(35)}  LATEST`;
+  return `${header}
+${"-".repeat(header.length)}
+${lines.join("\n")}`;
+}
+function formatDeploymentsTable(deployments) {
+  if (deployments.length === 0) return "No deployments found";
+  const lines = deployments.map((d) => {
+    const branch = d.meta?.githubCommitRef ?? "";
+    const sha = d.meta?.githubCommitSha?.slice(0, 7) ?? "";
+    const msg = (d.meta?.githubCommitMessage ?? "").replace(/\n.*/s, "").slice(0, 60);
+    return `${d.uid.padEnd(28)}  ${d.state.padEnd(11)}  ${(d.target || "-").padEnd(10)}  ${branch.padEnd(20)}  ${sha.padEnd(8)}  ${formatTimestamp(d.created).padEnd(20)}  ${msg}`;
+  });
+  const header = `${"ID".padEnd(28)}  ${"STATE".padEnd(11)}  ${"TARGET".padEnd(10)}  ${"BRANCH".padEnd(20)}  ${"COMMIT".padEnd(8)}  ${"CREATED".padEnd(20)}  MESSAGE`;
+  return `${header}
+${"-".repeat(header.length)}
+${lines.join("\n")}`;
+}
+function formatBuildEvents(events) {
+  if (events.length === 0) return "No build events found for this deployment";
+  const filtered = events.filter(
+    (e) => ["command", "stdout", "stderr", "exit", "delimiter", "deployment-state"].includes(e.type)
+  );
+  return filtered.map((e) => {
+    const time = e.created ? new Date(e.created).toISOString().slice(11, 19) : "--:--:--";
+    const text = (e.payload?.text ?? e.text ?? "").replace(/\s+$/u, "");
+    const prefix = e.type === "stderr" ? "!" : " ";
+    return `${prefix}${time} [${e.type.padEnd(16)}] ${text}`;
+  }).join("\n");
+}
+function formatRuntimeLogs(logs) {
+  if (logs.length === 0) {
+    return "No runtime logs found for this deployment in the requested window";
+  }
+  return logs.map((l) => {
+    const ts = l.timestampInMs ?? l.timestamp ?? 0;
+    const time = ts ? new Date(ts).toISOString().slice(11, 23) : "--:--:--";
+    const level = (l.level ?? "info").toUpperCase().padEnd(5);
+    const status = l.proxy?.statusCode ?? l.responseStatusCode;
+    const reqInfo = l.proxy?.method ? `${l.proxy.method} ${l.proxy.path ?? ""} ${status ?? ""}`.trim() : "";
+    const message = (l.message ?? l.text ?? "").replace(/\s+$/u, "");
+    const reqId = l.requestId ? ` [${l.requestId.slice(0, 12)}]` : "";
+    const head = reqInfo ? `${reqInfo}${reqId}` : reqId.trim();
+    return `${time} [${level}] ${head ? head + " " : ""}${message}`;
+  }).join("\n");
+}
+function formatWebhookHistory(rows) {
+  if (rows.length === 0) return "No webhook log rows match those filters";
+  const lines = rows.map((r) => {
+    const ts = new Date(r.created_at).toLocaleString("nl-NL", { timeZone: "Europe/Amsterdam" });
+    const note = r.error_message ?? r.message ?? "";
+    return `${ts.padEnd(20)}  ${r.event_type.padEnd(22)}  ${r.status.padEnd(8)}  ${(r.project_name ?? "").padEnd(40)}  ${(r.target ?? "").padEnd(10)}  ${(r.deployment_id ?? "").padEnd(28)}  ${note}`;
+  });
+  const header = `${"WHEN".padEnd(20)}  ${"EVENT".padEnd(22)}  ${"STATUS".padEnd(8)}  ${"PROJECT".padEnd(40)}  ${"TARGET".padEnd(10)}  ${"DEPLOYMENT".padEnd(28)}  NOTE`;
+  return `${header}
+${"-".repeat(header.length)}
+${lines.join("\n")}`;
+}
+async function handleVercelTool(name, args2, deps) {
+  switch (name) {
+    case "vercel-projects": {
+      const token = await getVercelToken(deps);
+      const limit = Math.min(Math.max(Number(args2.limit) || 50, 1), 200);
+      const search = typeof args2.search === "string" ? args2.search.toLowerCase() : null;
+      const { projects, error } = await listVercelProjectsAll(token, limit);
+      if (error) return { content: [{ type: "text", text: `Error: ${error}` }] };
+      const filtered = search ? projects.filter((p) => (p.name || "").toLowerCase().includes(search)) : projects;
+      return { content: [{ type: "text", text: formatProjectsTable(filtered) }] };
+    }
+    case "vercel-deployments": {
+      const token = await getVercelToken(deps);
+      const projectInput = String(args2.project);
+      const limit = Math.min(Math.max(Number(args2.limit) || 20, 1), 100);
+      const projectId = await resolveProjectId(token, projectInput);
+      const { deployments, error } = await listVercelDeployments(token, {
+        projectId,
+        limit,
+        state: args2.state ? String(args2.state) : void 0,
+        target: args2.target ? String(args2.target) : void 0
+      });
+      if (error) return { content: [{ type: "text", text: `Error: ${error}` }] };
+      return { content: [{ type: "text", text: formatDeploymentsTable(deployments) }] };
+    }
+    case "vercel-logs": {
+      const kind = (args2.kind ? String(args2.kind) : "build").toLowerCase();
+      if (kind === "build") {
+        if (!args2.deploymentId) {
+          return { content: [{ type: "text", text: 'Error: kind="build" requires deploymentId.' }] };
+        }
+        const token = await getVercelToken(deps);
+        const deploymentId = String(args2.deploymentId);
+        const limit = Math.min(Math.max(Number(args2.limit) || 500, 1), 5e3);
+        const { events, error } = await getDeploymentBuildEvents(token, deploymentId, limit);
+        if (error) return { content: [{ type: "text", text: `Error: ${error}` }] };
+        return { content: [{ type: "text", text: formatBuildEvents(events) }] };
+      }
+      if (kind === "runtime") {
+        if (!args2.project || !args2.deploymentId) {
+          return {
+            content: [
+              { type: "text", text: 'Error: kind="runtime" requires both project and deploymentId.' }
+            ]
+          };
+        }
+        const token = await getVercelToken(deps);
+        const projectInput = String(args2.project);
+        const deploymentId = String(args2.deploymentId);
+        const limit = Math.min(Math.max(Number(args2.limit) || 200, 1), 1e3);
+        const sinceMinutes = Math.min(Math.max(Number(args2.sinceMinutes) || 60, 1), 7 * 24 * 60);
+        const sinceMs = Date.now() - sinceMinutes * 6e4;
+        const projectId = await resolveProjectId(token, projectInput);
+        const { logs, error } = await getRuntimeLogs(
+          token,
+          projectId,
+          deploymentId,
+          limit,
+          sinceMs
+        );
+        if (error) {
+          const hint = error.includes("404") || error.includes("400") ? '\n\nThis endpoint requires both project ID and deployment ID and may not be available on every Vercel plan. Use kind="webhooks" or the supabase MCP (vercel_deployment_log table) for archived runtime logs.' : "";
+          return { content: [{ type: "text", text: `Error: ${error}${hint}` }] };
+        }
+        return { content: [{ type: "text", text: formatRuntimeLogs(logs) }] };
+      }
+      if (kind === "webhooks") {
+        const limit = Math.min(Math.max(Number(args2.limit) || 25, 1), 200);
+        let query = deps.supabase.from("vercel_webhook_logs").select(
+          "id, event_type, status, project_name, deployment_id, target, message, error_message, created_at"
+        ).order("created_at", { ascending: false }).limit(limit);
+        if (args2.projectName) query = query.eq("project_name", String(args2.projectName));
+        if (args2.status) query = query.eq("status", String(args2.status));
+        const { data, error } = await query;
+        if (error) return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+        return {
+          content: [{ type: "text", text: formatWebhookHistory(data ?? []) }]
+        };
+      }
+      return {
+        content: [
+          { type: "text", text: `Error: unknown kind "${kind}". Use build, runtime, or webhooks.` }
+        ]
+      };
+    }
+    default:
+      return { content: [{ type: "text", text: `Unknown vercel tool: ${name}` }] };
+  }
+}
 var args = process.argv.slice(2);
 function getArg2(name) {
   return args.find((a) => a.startsWith(`--${name}=`))?.split("=").slice(1).join("=");
@@ -1388,7 +1775,8 @@ var TOOL_MODULE_MAP = {
   "dns-update": "domains",
   "dns-delete": "domains",
   ...TRIGGER_TOOL_MODULE_MAP,
-  ...AGENT_TOOL_MODULE_MAP
+  ...AGENT_TOOL_MODULE_MAP,
+  ...VERCEL_TOOL_MODULE_MAP
 };
 var authContext = null;
 async function validateApiKey(key) {
@@ -1691,7 +2079,7 @@ function decrypt(payload) {
   decrypted += decipher.final("utf8");
   return decrypted;
 }
-var VERCEL_API = "https://api.vercel.com";
+var VERCEL_API2 = "https://api.vercel.com";
 function parseEnvContent(content) {
   const result = {};
   for (const line of content.split("\n")) {
@@ -1721,7 +2109,7 @@ function getVercelEnvSyncTargetings(stageType, customEnvId) {
 async function syncEnvVarsToVercel(token, projectId, envVars) {
   if (envVars.length === 0) return { created: 0, error: null };
   const res = await fetch(
-    `${VERCEL_API}/v10/projects/${encodeURIComponent(projectId)}/env?upsert=true`,
+    `${VERCEL_API2}/v10/projects/${encodeURIComponent(projectId)}/env?upsert=true`,
     {
       method: "POST",
       headers: {
@@ -3792,9 +4180,11 @@ var TOOLS = [
   // ----- Trigger.dev -----
   ...TRIGGER_TOOLS,
   // ----- Agent Reporting -----
-  ...AGENT_TOOLS
+  ...AGENT_TOOLS,
+  // ----- Vercel -----
+  ...VERCEL_TOOLS
 ];
-var MCP_VERSION = "3.7.0";
+var MCP_VERSION = "3.14.0";
 async function handleListTools() {
   if (!authContext) return { tools: TOOLS };
   const accessible = TOOLS.filter((tool) => {
@@ -5120,6 +5510,9 @@ ${lines.join("\n")}` }] };
         if (AGENT_TOOL_NAMES.has(name)) {
           return handleAgentTool(name, a);
         }
+        if (VERCEL_TOOL_NAMES.has(name)) {
+          return handleVercelTool(name, a, { supabase, decrypt });
+        }
         return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
     }
   } catch (err) {