@mgsoftwarebv/mg-dashboard-mcp 2.1.1 → 2.2.1

package/dist/index.js

@@ -6,6 +6,410 @@ import { createClient } from '@supabase/supabase-js';
 import { createHash, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
 import { Client } from 'ssh2';
 
+// src/trigger-tools.ts
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "COMPLETED",
+  "FAILED",
+  "CRASHED",
+  "CANCELED",
+  "SYSTEM_FAILURE",
+  "INTERRUPTED",
+  "EXPIRED"
+]);
+var DEFAULT_TRIGGER_SERVER_ID = "03659d55-e194-400d-b82a-bf6457371ded";
+var TRIGGER_TOOLS = [
+  {
+    name: "trigger-list",
+    description: "List all Trigger.dev projects on the Trigger server. Returns the compose project name, webapp port, and status. Use the project name in other trigger-* tools.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "trigger-runs",
+    description: "List recent task runs for a Trigger.dev project. Returns run ID, task name, status, duration, and timestamps.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Compose project name (from trigger-list)" },
+        status: {
+          type: "string",
+          description: "Comma-separated status filter: QUEUED,EXECUTING,COMPLETED,FAILED,CRASHED,CANCELED,SYSTEM_FAILURE"
+        },
+        taskIdentifier: { type: "string", description: 'Filter by task identifier (e.g. "hello-world")' },
+        limit: { type: "number", description: "Max runs to return (default 20, max 100)" }
+      },
+      required: ["project"]
+    }
+  },
+  {
+    name: "trigger-run-detail",
+    description: "Get full details of a specific run: status, payload, output, and error stack traces. Use after trigger-runs or trigger-test-task to inspect results.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Compose project name" },
+        runId: { type: "string", description: "Run ID (e.g. run_xxxxx)" }
+      },
+      required: ["project", "runId"]
+    }
+  },
+  {
+    name: "trigger-test-task",
+    description: "Trigger a task run and wait for it to complete. Returns the final status, output, or error with stack trace. The main tool for testing trigger tasks from Cursor.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Compose project name" },
+        taskId: { type: "string", description: 'Task identifier (e.g. "hello-world", "execute-pipeline")' },
+        payload: { type: "string", description: "JSON payload string to pass to the task (optional)" },
+        waitSeconds: { type: "number", description: "Max seconds to wait for completion (default 60, max 300)" }
+      },
+      required: ["project", "taskId"]
+    }
+  },
+  {
+    name: "trigger-cancel-run",
+    description: "Cancel a running or queued Trigger.dev task run.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Compose project name" },
+        runId: { type: "string", description: "Run ID to cancel (e.g. run_xxxxx)" }
+      },
+      required: ["project", "runId"]
+    }
+  },
+  {
+    name: "trigger-replay-run",
+    description: "Replay a previously failed or completed run with the same payload. Returns the new run ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Compose project name" },
+        runId: { type: "string", description: "Run ID to replay (e.g. run_xxxxx)" }
+      },
+      required: ["project", "runId"]
+    }
+  }
+];
+var TRIGGER_TOOL_NAMES = new Set(TRIGGER_TOOLS.map((t) => t.name));
+var TRIGGER_TOOL_MODULE_MAP = {
+  "trigger-list": "ci_cd",
+  "trigger-runs": "ci_cd",
+  "trigger-run-detail": "ci_cd",
+  "trigger-test-task": "ci_cd",
+  "trigger-cancel-run": "ci_cd",
+  "trigger-replay-run": "ci_cd"
+};
+async function discoverInstance(project, conn, proxy, sshExec2) {
+  const pg = `${project}-postgres-1`;
+  const wa = `${project}-webapp-1`;
+  const cmd = [
+    `PORT=$(docker port "${wa}" 3000/tcp 2>/dev/null | head -1 | sed 's/.*://')`,
+    `KEY=$(docker exec "${pg}" psql -U postgres -d main -t -A -c "SELECT \\"apiKey\\" FROM \\"RuntimeEnvironment\\" WHERE slug='prod' LIMIT 1" 2>/dev/null | tr -d '[:space:]')`,
+    'echo "$PORT|$KEY"'
+  ].join(" && ");
+  const result = await sshExec2(conn, cmd, proxy);
+  const output = result.stdout.trim();
+  const sepIdx = output.indexOf("|");
+  const port = sepIdx > 0 ? output.substring(0, sepIdx) : "";
+  const apiKey2 = sepIdx > 0 ? output.substring(sepIdx + 1) : "";
+  if (!port) {
+    throw new Error(
+      `Could not find webapp port for ${wa}. Is the container running? Use trigger-list to see available instances.`
+    );
+  }
+  if (!apiKey2) {
+    throw new Error(
+      `Could not get API key from ${pg}. Check if the Trigger.dev database is accessible and the RuntimeEnvironment table exists.`
+    );
+  }
+  return { port, apiKey: apiKey2 };
+}
+async function triggerApi(conn, proxy, sshExec2, instance, method, path, body) {
+  const parts = ["curl", "-s", "--max-time", "30"];
+  if (method !== "GET") parts.push("-X", method);
+  parts.push(`"http://localhost:${instance.port}${path}"`);
+  parts.push(`-H "Authorization: Bearer ${instance.apiKey}"`);
+  if (body) {
+    parts.push('-H "Content-Type: application/json"');
+    parts.push(`-d '${body.replace(/'/g, "'\\''")}'`);
+  }
+  const result = await sshExec2(conn, parts.join(" "), proxy);
+  if (result.exitCode !== 0 && !result.stdout) {
+    throw new Error(
+      `Trigger.dev API call failed (${method} ${path}): ${result.stderr || `exit code ${result.exitCode}`}`
+    );
+  }
+  return result.stdout;
+}
+function formatRunsTable(runs) {
+  if (runs.length === 0) return "No runs found";
+  const lines = runs.map((r) => {
+    const duration = r.durationMs != null ? `${(r.durationMs / 1e3).toFixed(1)}s` : "-";
+    const test = r.isTest ? " [TEST]" : "";
+    const created = r.createdAt ? new Date(r.createdAt).toLocaleString("nl-NL", { timeZone: "Europe/Amsterdam" }) : "";
+    return `${r.id}  ${r.taskIdentifier.padEnd(35)}  ${r.status.padEnd(16)}  ${duration.padStart(8)}  ${created}${test}`;
+  });
+  return `${"ID".padEnd(20)}  ${"TASK".padEnd(35)}  ${"STATUS".padEnd(16)}  ${"DURATION".padStart(8)}  CREATED
+` + "-".repeat(110) + "\n" + lines.join("\n");
+}
+function formatRunDetail(run) {
+  const sections = [];
+  sections.push(`=== Run ${run.id} ===`);
+  sections.push(`Task:     ${run.taskIdentifier}`);
+  sections.push(`Status:   ${run.status}`);
+  sections.push(`Version:  ${run.version || "-"}`);
+  if (run.startedAt) sections.push(`Started:  ${new Date(run.startedAt).toLocaleString("nl-NL", { timeZone: "Europe/Amsterdam" })}`);
+  if (run.finishedAt) sections.push(`Finished: ${new Date(run.finishedAt).toLocaleString("nl-NL", { timeZone: "Europe/Amsterdam" })}`);
+  if (run.durationMs != null) sections.push(`Duration: ${(run.durationMs / 1e3).toFixed(2)}s`);
+  if (run.payload !== void 0) {
+    const payloadStr = typeof run.payload === "string" ? run.payload : JSON.stringify(run.payload, null, 2);
+    sections.push("", "--- Payload ---", payloadStr);
+  }
+  if (run.output !== void 0) {
+    const outputStr = typeof run.output === "string" ? run.output : JSON.stringify(run.output, null, 2);
+    sections.push("", "--- Output ---", outputStr);
+  }
+  if (run.attempts && run.attempts.length > 0) {
+    for (const attempt of run.attempts) {
+      if (attempt.error) {
+        sections.push(
+          "",
+          `--- Error (${attempt.id}) ---`,
+          `${attempt.error.name || "Error"}: ${attempt.error.message}`
+        );
+        if (attempt.error.stackTrace) {
+          sections.push("", attempt.error.stackTrace);
+        }
+      }
+    }
+  }
+  return sections.join("\n");
+}
+async function handleTriggerTool(name, args2, deps) {
+  const { sshExec: sshExec2, getServerConnection: getServerConnection2 } = deps;
+  const serverId = DEFAULT_TRIGGER_SERVER_ID;
+  switch (name) {
+    // -----------------------------------------------------------------
+    case "trigger-list": {
+      const { conn, proxy } = await getServerConnection2(serverId);
+      const script = [
+        "FOUND=0",
+        "for PG in $(docker ps --format '{{.Names}}' | grep -E 'trigger.*-postgres-[0-9]+$'); do",
+        `  PROJECT=$(echo "$PG" | sed 's/-postgres-[0-9]*$//')`,
+        '  WA="${PROJECT}-webapp-1"',
+        `  PORT=$(docker port "$WA" 3000/tcp 2>/dev/null | head -1 | sed 's/.*://')`,
+        `  STATUS=$(docker inspect -f '{{.State.Status}}' "$WA" 2>/dev/null || echo 'not_found')`,
+        `  RUNNING=$(docker ps --filter "label=com.docker.compose.project=\${PROJECT}" --format '{{.Names}}' 2>/dev/null | wc -l)`,
+        `  TOTAL=$(docker ps -a --filter "label=com.docker.compose.project=\${PROJECT}" --format '{{.Names}}' 2>/dev/null | wc -l)`,
+        '  echo "${PROJECT}|${PORT:-?}|${STATUS}|${RUNNING}/${TOTAL}"',
+        "  FOUND=1",
+        "done",
+        '[ "$FOUND" = "0" ] && echo "NO_INSTANCES"'
+      ].join("\n");
+      const result = await sshExec2(conn, script, proxy);
+      const output = result.stdout.trim();
+      if (!output || output === "NO_INSTANCES") {
+        return { content: [{ type: "text", text: "No Trigger.dev instances found on this server. Check if Docker containers are running." }] };
+      }
+      const header = `${"PROJECT".padEnd(45)}  ${"PORT".padEnd(6)}  ${"WEBAPP".padEnd(12)}  CONTAINERS`;
+      const sep = "-".repeat(85);
+      const lines = output.split("\n").map((line) => {
+        const [project, port, status, containers] = line.split("|");
+        return `${(project || "").padEnd(45)}  ${(port || "?").padEnd(6)}  ${(status || "?").padEnd(12)}  ${containers || "?"}`;
+      });
+      return { content: [{ type: "text", text: `${header}
+${sep}
+${lines.join("\n")}` }] };
+    }
+    // -----------------------------------------------------------------
+    case "trigger-runs": {
+      const project = String(args2.project);
+      const { conn, proxy } = await getServerConnection2(serverId);
+      const instance = await discoverInstance(project, conn, proxy, sshExec2);
+      const limit = Math.min(Math.max(Number(args2.limit) || 20, 1), 100);
+      const queryParts = [`page[size]=${limit}`];
+      if (args2.status) queryParts.push(`filter[status]=${String(args2.status)}`);
+      if (args2.taskIdentifier) queryParts.push(`filter[taskIdentifier]=${String(args2.taskIdentifier)}`);
+      const rawJson = await triggerApi(
+        conn,
+        proxy,
+        sshExec2,
+        instance,
+        "GET",
+        `/api/v1/runs?${queryParts.join("&")}`
+      );
+      let parsed;
+      try {
+        parsed = JSON.parse(rawJson);
+      } catch {
+        return { content: [{ type: "text", text: `Invalid API response:
+${rawJson.substring(0, 500)}` }] };
+      }
+      const runs = parsed.data || [];
+      return { content: [{ type: "text", text: formatRunsTable(runs) }] };
+    }
+    // -----------------------------------------------------------------
+    case "trigger-run-detail": {
+      const project = String(args2.project);
+      const runId = String(args2.runId);
+      const { conn, proxy } = await getServerConnection2(serverId);
+      const instance = await discoverInstance(project, conn, proxy, sshExec2);
+      const rawJson = await triggerApi(
+        conn,
+        proxy,
+        sshExec2,
+        instance,
+        "GET",
+        `/api/v3/runs/${encodeURIComponent(runId)}`
+      );
+      let run;
+      try {
+        run = JSON.parse(rawJson);
+      } catch {
+        return { content: [{ type: "text", text: `Invalid API response:
+${rawJson.substring(0, 500)}` }] };
+      }
+      return { content: [{ type: "text", text: formatRunDetail(run) }] };
+    }
+    // -----------------------------------------------------------------
+    case "trigger-test-task": {
+      const project = String(args2.project);
+      const taskId = String(args2.taskId);
+      const waitSeconds = Math.min(Math.max(Number(args2.waitSeconds) || 60, 5), 300);
+      const { conn, proxy } = await getServerConnection2(serverId);
+      conn.timeout = (waitSeconds + 30) * 1e3;
+      const instance = await discoverInstance(project, conn, proxy, sshExec2);
+      let payload = "{}";
+      if (args2.payload) {
+        try {
+          JSON.parse(String(args2.payload));
+          payload = String(args2.payload);
+        } catch {
+          throw new Error(`Invalid JSON payload: ${String(args2.payload).substring(0, 200)}`);
+        }
+      }
+      const triggerBody = JSON.stringify({
+        payload: JSON.parse(payload),
+        options: { tags: ["mcp-test"], test: true }
+      });
+      const triggerJson = await triggerApi(
+        conn,
+        proxy,
+        sshExec2,
+        instance,
+        "POST",
+        `/api/v1/tasks/${encodeURIComponent(taskId)}/trigger`,
+        triggerBody
+      );
+      let triggerResp;
+      try {
+        triggerResp = JSON.parse(triggerJson);
+      } catch {
+        return { content: [{ type: "text", text: `Failed to trigger task. API response:
+${triggerJson.substring(0, 500)}` }] };
+      }
+      const runId = triggerResp.id;
+      if (!runId) {
+        return { content: [{ type: "text", text: `Trigger API did not return a run ID:
+${triggerJson.substring(0, 500)}` }] };
+      }
+      const pollInterval = 3e3;
+      const maxPolls = Math.ceil(waitSeconds * 1e3 / pollInterval);
+      for (let i = 0; i < maxPolls; i++) {
+        await new Promise((r) => setTimeout(r, pollInterval));
+        const pollJson = await triggerApi(
+          conn,
+          proxy,
+          sshExec2,
+          instance,
+          "GET",
+          `/api/v3/runs/${encodeURIComponent(runId)}`
+        );
+        let run;
+        try {
+          run = JSON.parse(pollJson);
+        } catch {
+          continue;
+        }
+        if (TERMINAL_STATUSES.has(run.status)) {
+          return { content: [{ type: "text", text: formatRunDetail(run) }] };
+        }
+      }
+      return {
+        content: [{
+          type: "text",
+          text: `Run ${runId} did not complete within ${waitSeconds}s (still running). Use trigger-run-detail to check later.`
+        }]
+      };
+    }
+    // -----------------------------------------------------------------
+    case "trigger-cancel-run": {
+      const project = String(args2.project);
+      const runId = String(args2.runId);
+      const { conn, proxy } = await getServerConnection2(serverId);
+      const instance = await discoverInstance(project, conn, proxy, sshExec2);
+      const rawJson = await triggerApi(
+        conn,
+        proxy,
+        sshExec2,
+        instance,
+        "POST",
+        `/api/v3/runs/${encodeURIComponent(runId)}/cancel`
+      );
+      let result;
+      try {
+        result = JSON.parse(rawJson);
+      } catch {
+        return { content: [{ type: "text", text: `Cancel response:
+${rawJson.substring(0, 500)}` }] };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: `Run ${result.id || runId} canceled (status: ${result.status || "unknown"})`
+        }]
+      };
+    }
+    // -----------------------------------------------------------------
+    case "trigger-replay-run": {
+      const project = String(args2.project);
+      const runId = String(args2.runId);
+      const { conn, proxy } = await getServerConnection2(serverId);
+      const instance = await discoverInstance(project, conn, proxy, sshExec2);
+      const rawJson = await triggerApi(
+        conn,
+        proxy,
+        sshExec2,
+        instance,
+        "POST",
+        `/api/v3/runs/${encodeURIComponent(runId)}/replay`
+      );
+      let result;
+      try {
+        result = JSON.parse(rawJson);
+      } catch {
+        return { content: [{ type: "text", text: `Replay response:
+${rawJson.substring(0, 500)}` }] };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: result.id ? `Run replayed. New run ID: ${result.id}` : `Replay response:
+${rawJson.substring(0, 500)}`
+        }]
+      };
+    }
+    // -----------------------------------------------------------------
+    default:
+      return { content: [{ type: "text", text: `Unknown trigger tool: ${name}` }] };
+  }
+}
+
+// src/index.ts
 var args = process.argv.slice(2);
 function getArg(name) {
   return args.find((a) => a.startsWith(`--${name}=`))?.split("=").slice(1).join("=");
@@ -149,7 +553,8 @@ var TOOL_MODULE_MAP = {
   "dns-list": "domains",
   "dns-create": "domains",
   "dns-update": "domains",
-  "dns-delete": "domains"
+  "dns-delete": "domains",
+  ...TRIGGER_TOOL_MODULE_MAP
 };
 var authContext = null;
 async function validateApiKey(key) {
@@ -1004,7 +1409,7 @@ async function mijnhostFetch(path, options = {}) {
       "API-Key": key,
       "Accept": "application/json",
       "Content-Type": "application/json",
-      "User-Agent": "mg-dashboard-mcp/1.7.0",
+      "User-Agent": "mg-dashboard-mcp/2.2.0",
       ...options.headers || {}
     }
   });
@@ -1404,10 +1809,12 @@ var TOOLS = [
       },
       required: ["domain", "type", "name", "value"]
     }
-  }
+  },
+  // ----- Trigger.dev -----
+  ...TRIGGER_TOOLS
 ];
 var server = new Server(
-  { name: "mg-dashboard-mcp", version: "1.7.0" },
+  { name: "mg-dashboard-mcp", version: "2.2.0" },
   { capabilities: { tools: {} } }
 );
 server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -1824,14 +2231,14 @@ ${cronD.stdout}`);
         return { content: [{ type: "text", text: parts.join("\n\n") }] };
       }
       case "cron-add": {
+        if (!a.schedule || !a.command) {
+          throw new Error("Both schedule and command are required");
+        }
         const { conn, proxy } = await getServerConnection(a.serverId);
         const user = a.user ? String(a.user) : "root";
         const schedule = String(a.schedule).trim();
         const command = String(a.command).trim();
         const commentText = a.comment ? String(a.comment).trim() : "";
-        if (!schedule || !command) {
-          throw new Error("Both schedule and command are required");
-        }
         const entry = commentText ? `# ${commentText}
 ${schedule} ${command}` : `${schedule} ${command}`;
         const result = await sshExec(conn, `(crontab -l -u ${user} 2>/dev/null; echo '${entry.replace(/'/g, "'\\''")}') | crontab -u ${user} -`, proxy);
@@ -1842,12 +2249,12 @@ ${schedule} ${command}` : `${schedule} ${command}`;
 ${schedule} ${command}` }] };
       }
       case "cron-remove": {
+        if (!a.commandMatch) {
+          throw new Error("commandMatch is required \u2013 pass a (partial) command string to identify the cron entry");
+        }
         const { conn, proxy } = await getServerConnection(a.serverId);
         const user = a.user ? String(a.user) : "root";
         const match = String(a.commandMatch).trim();
-        if (!match) {
-          throw new Error("commandMatch is required");
-        }
         const current = await sshExec(conn, `crontab -l -u ${user} 2>/dev/null`, proxy);
         const lines = current.stdout.split("\n");
         const before = lines.length;
@@ -1867,13 +2274,13 @@ ${schedule} ${command}` }] };
         return { content: [{ type: "text", text: `Removed ${removed} cron entry/entries matching "${match}" from ${user} crontab` }] };
       }
       case "cron-toggle": {
+        if (!a.commandMatch) {
+          throw new Error("commandMatch is required \u2013 pass a (partial) command string to identify the cron entry");
+        }
         const { conn, proxy } = await getServerConnection(a.serverId);
         const user = a.user ? String(a.user) : "root";
         const match = String(a.commandMatch).trim();
         const enable = Boolean(a.enable);
-        if (!match) {
-          throw new Error("commandMatch is required");
-        }
         const current = await sshExec(conn, `crontab -l -u ${user} 2>/dev/null`, proxy);
         const lines = current.stdout.split("\n");
         let toggled = 0;
@@ -2038,6 +2445,9 @@ ${lines.join("\n")}` }] };
         return { content: [{ type: "text", text: `DNS record deleted: ${type} ${dnsName} = ${value} (${remaining.length} records remaining)` }] };
       }
       default:
+        if (TRIGGER_TOOL_NAMES.has(name)) {
+          return handleTriggerTool(name, a, { sshExec, getServerConnection });
+        }
         return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
     }
   } catch (err) {