@mgsoftwarebv/mg-dashboard-mcp 2.1.0 → 2.2.0

package/dist/index.js

@@ -6,6 +6,416 @@ 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 TRIGGER_TOOLS = [
+  {
+    name: "trigger-list",
+    description: "List all Trigger.dev instances (Docker Compose projects) on a server. Returns the compose project name, webapp port, and status for each instance. Use the project name in other trigger-* tools.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        serverId: { type: "string", description: "UUID of the SSH server running Trigger.dev" }
+      },
+      required: ["serverId"]
+    }
+  },
+  {
+    name: "trigger-runs",
+    description: "List recent task runs for a Trigger.dev instance. Returns run ID, task name, status, duration, and timestamps.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        serverId: { type: "string", description: "UUID of the SSH server" },
+        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: ["serverId", "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: {
+        serverId: { type: "string", description: "UUID of the SSH server" },
+        project: { type: "string", description: "Compose project name" },
+        runId: { type: "string", description: "Run ID (e.g. run_xxxxx)" }
+      },
+      required: ["serverId", "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: {
+        serverId: { type: "string", description: "UUID of the SSH server" },
+        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: ["serverId", "project", "taskId"]
+    }
+  },
+  {
+    name: "trigger-cancel-run",
+    description: "Cancel a running or queued Trigger.dev task run.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        serverId: { type: "string", description: "UUID of the SSH server" },
+        project: { type: "string", description: "Compose project name" },
+        runId: { type: "string", description: "Run ID to cancel (e.g. run_xxxxx)" }
+      },
+      required: ["serverId", "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: {
+        serverId: { type: "string", description: "UUID of the SSH server" },
+        project: { type: "string", description: "Compose project name" },
+        runId: { type: "string", description: "Run ID to replay (e.g. run_xxxxx)" }
+      },
+      required: ["serverId", "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='production' 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;
+  switch (name) {
+    // -----------------------------------------------------------------
+    case "trigger-list": {
+      const { conn, proxy } = await getServerConnection2(String(args2.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(String(args2.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(String(args2.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(String(args2.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(String(args2.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(String(args2.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 +559,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) {
@@ -386,12 +797,29 @@ async function attemptVercelSync(appName, environment, knownStageId) {
     return `Vercel sync error: ${msg}`;
   }
 }
+var SSH_PROXY_SERVER_ID = "03659d55-e194-400d-b82a-bf6457371ded";
+var _proxyConnCache = null;
+async function getProxyConnection() {
+  if (_proxyConnCache) return _proxyConnCache;
+  const { data, error } = await supabase.from("ssh_server").select("hostname, port, username, password_encrypted, ssh_key_encrypted, ssh_key_passphrase_encrypted").eq("id", SSH_PROXY_SERVER_ID).single();
+  if (error || !data) throw new Error("SSH Proxy server not found in database");
+  if (!encryptionKey) throw new Error("ENCRYPTION_KEY required to decrypt server credentials");
+  _proxyConnCache = {
+    hostname: data.hostname,
+    port: data.port || 22,
+    username: data.username,
+    password: data.password_encrypted ? decrypt(data.password_encrypted) : void 0,
+    privateKey: data.ssh_key_encrypted ? decrypt(data.ssh_key_encrypted) : void 0,
+    passphrase: data.ssh_key_passphrase_encrypted ? decrypt(data.ssh_key_passphrase_encrypted) : void 0
+  };
+  return _proxyConnCache;
+}
 async function getServerConnection(serverId) {
   assertServerAccess(serverId);
-  const { data, error } = await supabase.from("ssh_server").select("hostname, port, username, password_encrypted, ssh_key_encrypted, ssh_key_passphrase_encrypted").eq("id", serverId).single();
+  const { data, error } = await supabase.from("ssh_server").select("hostname, port, username, password_encrypted, ssh_key_encrypted, ssh_key_passphrase_encrypted, allowed_ssh_ips").eq("id", serverId).single();
   if (error || !data) throw new Error(`Server not found: ${serverId}`);
   if (!encryptionKey) throw new Error("ENCRYPTION_KEY required to decrypt server credentials");
-  return {
+  const conn = {
     hostname: data.hostname,
     port: data.port || 22,
     username: data.username,
@@ -399,8 +827,12 @@ async function getServerConnection(serverId) {
     privateKey: data.ssh_key_encrypted ? decrypt(data.ssh_key_encrypted) : void 0,
     passphrase: data.ssh_key_passphrase_encrypted ? decrypt(data.ssh_key_passphrase_encrypted) : void 0
   };
+  const needsProxy = data.allowed_ssh_ips !== null && serverId !== SSH_PROXY_SERVER_ID;
+  const proxy = needsProxy ? await getProxyConnection() : void 0;
+  return { conn, proxy };
 }
-async function sshExec(opts, command) {
+async function sshExec(opts, command, proxy) {
+  if (proxy) return sshExecViaProxy(proxy, opts, command);
   return new Promise((resolve) => {
     const ssh = new Client();
     let stdout = "";
@@ -459,6 +891,98 @@ async function sshExec(opts, command) {
     });
   });
 }
+function sshExecViaProxy(proxyOpts, targetOpts, command) {
+  return new Promise((resolve) => {
+    const proxyClient = new Client();
+    let done = false;
+    const timeout = targetOpts.timeout || 6e4;
+    const timer = setTimeout(() => {
+      if (!done) {
+        done = true;
+        proxyClient.end();
+        resolve({ stdout: "", stderr: "SSH proxy command timeout", exitCode: -1 });
+      }
+    }, timeout);
+    const cleanup = () => {
+      clearTimeout(timer);
+      proxyClient.end();
+    };
+    proxyClient.on("ready", () => {
+      proxyClient.forwardOut("127.0.0.1", 0, targetOpts.hostname, targetOpts.port, (err, tunnel) => {
+        if (err) {
+          if (!done) {
+            done = true;
+            cleanup();
+            resolve({ stdout: "", stderr: err.message, exitCode: -1 });
+          }
+          return;
+        }
+        const targetClient = new Client();
+        let stdout = "";
+        let stderr = "";
+        targetClient.on("ready", () => {
+          targetClient.exec(command, (execErr, stream) => {
+            if (execErr) {
+              if (!done) {
+                done = true;
+                targetClient.end();
+                cleanup();
+                resolve({ stdout, stderr, exitCode: -1 });
+              }
+              return;
+            }
+            stream.on("data", (d) => {
+              stdout += d.toString();
+            });
+            stream.stderr.on("data", (d) => {
+              stderr += d.toString();
+            });
+            stream.on("close", (code) => {
+              if (!done) {
+                done = true;
+                targetClient.end();
+                cleanup();
+                resolve({ stdout, stderr, exitCode: code ?? 0 });
+              }
+            });
+          });
+        });
+        targetClient.on("error", (targetErr) => {
+          if (!done) {
+            done = true;
+            targetClient.end();
+            cleanup();
+            resolve({ stdout, stderr: targetErr.message, exitCode: -1 });
+          }
+        });
+        targetClient.connect({
+          sock: tunnel,
+          username: targetOpts.username,
+          password: targetOpts.password,
+          privateKey: targetOpts.privateKey,
+          passphrase: targetOpts.passphrase,
+          readyTimeout: timeout
+        });
+      });
+    });
+    proxyClient.on("error", (err) => {
+      if (!done) {
+        done = true;
+        cleanup();
+        resolve({ stdout: "", stderr: err.message, exitCode: -1 });
+      }
+    });
+    proxyClient.connect({
+      host: proxyOpts.hostname,
+      port: proxyOpts.port,
+      username: proxyOpts.username,
+      password: proxyOpts.password,
+      privateKey: proxyOpts.privateKey,
+      passphrase: proxyOpts.passphrase,
+      readyTimeout: proxyOpts.timeout || 3e4
+    });
+  });
+}
 function sanitizePath(path) {
   let normalized = path.replace(/\\/g, "/").replace(/\0/g, "");
   const parts = normalized.split("/");
@@ -743,7 +1267,7 @@ function assertAllowedLogPath(filePath) {
     throw new Error(`Path not allowed. Must be under: ${ALLOWED_LOG_PREFIXES.join(", ")}`);
   }
 }
-async function discoverSiteDatabases(conn) {
+async function discoverSiteDatabases(conn, proxy) {
   const script = `
 check_dir() {
   local base="$1" root="$2"
@@ -780,7 +1304,7 @@ for dir in /var/www/*/; do
   done
 done
 `.trim();
-  const result = await sshExec(conn, script);
+  const result = await sshExec(conn, script, proxy);
   const sites = [];
   for (const line of result.stdout.split("\n")) {
     if (!line.trim()) continue;
@@ -864,9 +1388,9 @@ DB_PORT=\${DB_PORT:-3306}
 mysql --user="$DB_USER" --password="$DB_PASS" --host="$DB_HOST" --port="$DB_PORT" -t -e '${safeQuery}' "$DB_NAME" 2>&1 | grep -v "\\[Warning\\].*password"
 `.trim();
 }
-async function execSiteMysql(conn, sitePath, query) {
+async function execSiteMysql(conn, sitePath, query, proxy) {
   const cmd = buildSiteMysqlCommand(sitePath, query);
-  const result = await sshExec(conn, cmd);
+  const result = await sshExec(conn, cmd, proxy);
   const output = (result.stdout || "").trim();
   if (output.startsWith("ERROR: No database config found")) {
     throw new Error(output);
@@ -891,7 +1415,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 || {}
     }
   });
@@ -1291,10 +1815,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 () => {
@@ -1338,9 +1864,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         return { content: [{ type: "text", text: lines.length ? lines.join("\n") : "No servers found" }] };
       }
       case "server-status": {
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
         const cmd = 'echo "=== UPTIME ===" && uptime && echo "=== DISK ===" && df -h --total && echo "=== MEMORY ===" && free -h && echo "=== LOAD ===" && cat /proc/loadavg';
-        const result = await sshExec(conn, cmd);
+        const result = await sshExec(conn, cmd, proxy);
         const output = result.exitCode === 0 ? result.stdout : `Exit ${result.exitCode}
 ${result.stdout}
 ${result.stderr}`;
@@ -1350,9 +1876,9 @@ ${result.stderr}`;
       case "ssh-execute": {
         const command = String(a.command);
         assertSafeCommand(command);
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
         if (a.timeout) conn.timeout = Number(a.timeout);
-        const result = await sshExec(conn, command);
+        const result = await sshExec(conn, command, proxy);
         const output = [`Exit code: ${result.exitCode}`];
         if (result.stdout) output.push(`--- stdout ---
 ${result.stdout}`);
@@ -1361,45 +1887,45 @@ ${result.stderr}`);
         return { content: [{ type: "text", text: output.join("\n") }] };
       }
       case "server-reboot": {
-        const conn = await getServerConnection(String(a.serverId));
-        const result = await sshExec(conn, "sudo reboot");
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const result = await sshExec(conn, "sudo reboot", proxy);
         return { content: [{ type: "text", text: result.exitCode === 0 ? "Reboot command sent. Server will be unavailable shortly." : `Reboot failed: ${result.stderr}` }] };
       }
       case "server-restart-service": {
         const service = String(a.serviceName).replace(/[^a-zA-Z0-9._@-]/g, "");
-        const conn = await getServerConnection(String(a.serverId));
-        const result = await sshExec(conn, `sudo systemctl restart ${service}`);
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const result = await sshExec(conn, `sudo systemctl restart ${service}`, proxy);
         if (result.exitCode === 0) {
-          const status = await sshExec(conn, `sudo systemctl is-active ${service}`);
+          const status = await sshExec(conn, `sudo systemctl is-active ${service}`, proxy);
           return { content: [{ type: "text", text: `Service "${service}" restarted. Status: ${status.stdout.trim()}` }] };
         }
         return { content: [{ type: "text", text: `Failed to restart "${service}": ${result.stderr}` }] };
       }
-      // ----- SFTP -----
+      // ----- SFTP (no proxy support yet — direct connection only) -----
       case "sftp-list": {
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn } = await getServerConnection(String(a.serverId));
         const listing = await sftpReaddir(conn, String(a.path || "/"));
         return { content: [{ type: "text", text: listing }] };
       }
       case "sftp-read": {
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn } = await getServerConnection(String(a.serverId));
         const content = await sftpRead(conn, String(a.path));
         return { content: [{ type: "text", text: content }] };
       }
       case "sftp-write": {
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn } = await getServerConnection(String(a.serverId));
         const result = await sftpWrite(conn, String(a.path), String(a.content));
         return { content: [{ type: "text", text: result }] };
       }
       case "sftp-delete": {
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn } = await getServerConnection(String(a.serverId));
         const result = await sftpDelete(conn, String(a.path));
         return { content: [{ type: "text", text: result }] };
       }
       // ----- Docker -----
       case "docker-list": {
-        const conn = await getServerConnection(String(a.serverId));
-        const result = await sshExec(conn, 'docker ps -a --format "table {{.Names}}	{{.Image}}	{{.Status}}	{{.Ports}}"');
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const result = await sshExec(conn, 'docker ps -a --format "table {{.Names}}	{{.Image}}	{{.Status}}	{{.Ports}}"', proxy);
         return { content: [{ type: "text", text: result.exitCode === 0 ? result.stdout : `Error: ${result.stderr}` }] };
       }
       case "docker-action": {
@@ -1408,22 +1934,22 @@ ${result.stderr}`);
         if (!["start", "stop", "restart", "remove"].includes(action)) {
           throw new Error(`Invalid action: ${action}. Use start, stop, restart, or remove.`);
         }
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
         const dockerCmd = action === "remove" ? `docker rm -f ${container}` : `docker ${action} ${container}`;
-        const result = await sshExec(conn, dockerCmd);
+        const result = await sshExec(conn, dockerCmd, proxy);
         return { content: [{ type: "text", text: result.exitCode === 0 ? `Container "${container}" ${action}ed successfully` : `Error: ${result.stderr}` }] };
       }
       case "docker-logs": {
         const container = String(a.containerName).replace(/[^a-zA-Z0-9._-]/g, "");
         const lines = Number(a.lines) || 100;
-        const conn = await getServerConnection(String(a.serverId));
-        const result = await sshExec(conn, `docker logs --tail ${lines} ${container} 2>&1`);
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const result = await sshExec(conn, `docker logs --tail ${lines} ${container} 2>&1`, proxy);
         return { content: [{ type: "text", text: result.exitCode === 0 ? result.stdout : `Error: ${result.stderr}` }] };
       }
       // ----- Database -----
       case "db-discover": {
-        const conn = await getServerConnection(String(a.serverId));
-        const sites = await discoverSiteDatabases(conn);
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const sites = await discoverSiteDatabases(conn, proxy);
         if (!sites.length) {
           return { content: [{ type: "text", text: "No web applications with database configs found in /var/www/" }] };
         }
@@ -1433,26 +1959,27 @@ ${result.stderr}`);
         return { content: [{ type: "text", text: lines.join("\n") }] };
       }
       case "db-tables": {
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
         const sql = "SELECT TABLE_NAME, ENGINE, TABLE_ROWS, ROUND(DATA_LENGTH/1024/1024, 2) AS `Size (MB)`, TABLE_COLLATION FROM information_schema.TABLES WHERE TABLE_SCHEMA = DATABASE() ORDER BY TABLE_NAME";
-        const output = await execSiteMysql(conn, String(a.sitePath), sql);
+        const output = await execSiteMysql(conn, String(a.sitePath), sql, proxy);
         return { content: [{ type: "text", text: output || "No tables found" }] };
       }
       case "db-describe": {
         const table = String(a.table).replace(/[^a-zA-Z0-9_]/g, "");
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
         const output = await execSiteMysql(
           conn,
           String(a.sitePath),
-          `DESCRIBE \`${table}\`; SHOW INDEX FROM \`${table}\``
+          `DESCRIBE \`${table}\`; SHOW INDEX FROM \`${table}\``,
+          proxy
         );
         return { content: [{ type: "text", text: output }] };
       }
       case "db-query": {
         const query = String(a.query).trim();
         assertSafeSql(query);
-        const conn = await getServerConnection(String(a.serverId));
-        const output = await execSiteMysql(conn, String(a.sitePath), query);
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const output = await execSiteMysql(conn, String(a.sitePath), query, proxy);
         return { content: [{ type: "text", text: output || "Query executed successfully (no output)" }] };
       }
       // ----- Env Config -----
@@ -1550,7 +2077,7 @@ ${result.stderr}`);
       }
       // ----- Cache Purge -----
       case "cache-purge": {
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
         conn.timeout = 12e4;
         const script = `
 R=""
@@ -1631,13 +2158,13 @@ else
 fi
 echo -e "$R"
 `.trim();
-        const result = await sshExec(conn, script);
+        const result = await sshExec(conn, script, proxy);
         const output = (result.stdout || "").trim();
         return { content: [{ type: "text", text: output || "Cache purge completed (no output)" }] };
       }
       // ----- Log Reading -----
       case "log-list": {
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
         const script = `
 {
   [ -d /usr/local/lsws/logs ] && find /usr/local/lsws/logs -maxdepth 2 -name "*.log" -type f 2>/dev/null
@@ -1663,7 +2190,7 @@ echo -e "$R"
   echo "$f  $HR  $MOD"
 done
 `.trim();
-        const result = await sshExec(conn, script);
+        const result = await sshExec(conn, script, proxy);
         return { content: [{ type: "text", text: result.stdout || "No log files found" }] };
       }
       case "log-read": {
@@ -1671,9 +2198,9 @@ done
         assertAllowedLogPath(logPath);
         const lineCount = Math.min(Math.max(Number(a.lines) || 100, 1), 500);
         const filter = a.filter ? String(a.filter).replace(/'/g, "'\\''") : "";
-        const conn = await getServerConnection(String(a.serverId));
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
         const cmd = filter ? `grep '${filter}' '${logPath}' 2>/dev/null | tail -n ${lineCount}` : `tail -n ${lineCount} '${logPath}' 2>/dev/null`;
-        const result = await sshExec(conn, cmd);
+        const result = await sshExec(conn, cmd, proxy);
         if (result.exitCode !== 0 && !result.stdout) {
           throw new Error(result.stderr || `Failed to read log: ${logPath}`);
         }
@@ -1681,21 +2208,21 @@ done
       }
       // ----- Cron Jobs -----
       case "cron-list": {
-        const conn = await getServerConnection(a.serverId);
+        const { conn, proxy } = await getServerConnection(a.serverId);
         const user = a.user ? String(a.user) : null;
         const parts = [];
         if (user) {
-          const result = await sshExec(conn, `crontab -l -u ${user} 2>/dev/null || echo '(no crontab for ${user})'`);
+          const result = await sshExec(conn, `crontab -l -u ${user} 2>/dev/null || echo '(no crontab for ${user})'`, proxy);
           parts.push(`## Crontab for ${user}
 ${result.stdout}`);
         } else {
-          const rootCron = await sshExec(conn, `crontab -l 2>/dev/null || echo '(no crontab for root)'`);
+          const rootCron = await sshExec(conn, `crontab -l 2>/dev/null || echo '(no crontab for root)'`, proxy);
           parts.push(`## Root crontab
 ${rootCron.stdout}`);
-          const wwwCron = await sshExec(conn, `crontab -l -u www-data 2>/dev/null || echo '(no crontab for www-data)'`);
+          const wwwCron = await sshExec(conn, `crontab -l -u www-data 2>/dev/null || echo '(no crontab for www-data)'`, proxy);
           parts.push(`## www-data crontab
 ${wwwCron.stdout}`);
-          const cronD = await sshExec(conn, `for f in /etc/cron.d/*; do [ -f "$f" ] && echo "--- $f ---" && cat "$f" && echo; done 2>/dev/null || echo '(no files in /etc/cron.d/)'`);
+          const cronD = await sshExec(conn, `for f in /etc/cron.d/*; do [ -f "$f" ] && echo "--- $f ---" && cat "$f" && echo; done 2>/dev/null || echo '(no files in /etc/cron.d/)'`, proxy);
           parts.push(`## /etc/cron.d/
 ${cronD.stdout}`);
           const summary = await sshExec(conn, [
@@ -1704,23 +2231,23 @@ ${cronD.stdout}`);
             `echo "cron.daily:   $(ls /etc/cron.daily/ 2>/dev/null | wc -l) scripts"`,
             `echo "cron.weekly:  $(ls /etc/cron.weekly/ 2>/dev/null | wc -l) scripts"`,
             `echo "cron.monthly: $(ls /etc/cron.monthly/ 2>/dev/null | wc -l) scripts"`
-          ].join(" && "));
+          ].join(" && "), proxy);
           parts.push(summary.stdout);
         }
         return { content: [{ type: "text", text: parts.join("\n\n") }] };
       }
       case "cron-add": {
-        const conn = await getServerConnection(a.serverId);
+        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} -`);
+        const result = await sshExec(conn, `(crontab -l -u ${user} 2>/dev/null; echo '${entry.replace(/'/g, "'\\''")}') | crontab -u ${user} -`, proxy);
         if (result.exitCode !== 0) {
           throw new Error(result.stderr || "Failed to add cron job");
         }
@@ -1728,13 +2255,13 @@ ${schedule} ${command}` : `${schedule} ${command}`;
 ${schedule} ${command}` }] };
       }
       case "cron-remove": {
-        const conn = await getServerConnection(a.serverId);
+        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`);
+        const current = await sshExec(conn, `crontab -l -u ${user} 2>/dev/null`, proxy);
         const lines = current.stdout.split("\n");
         const before = lines.length;
         const filtered = lines.filter((line) => {
@@ -1746,21 +2273,21 @@ ${schedule} ${command}` }] };
           return { content: [{ type: "text", text: `No cron entries found matching "${match}"` }] };
         }
         const escapedCrontab = filtered.join("\n").replace(/'/g, "'\\''");
-        const result = await sshExec(conn, `echo '${escapedCrontab}' | crontab -u ${user} -`);
+        const result = await sshExec(conn, `echo '${escapedCrontab}' | crontab -u ${user} -`, proxy);
         if (result.exitCode !== 0) {
           throw new Error(result.stderr || "Failed to update crontab");
         }
         return { content: [{ type: "text", text: `Removed ${removed} cron entry/entries matching "${match}" from ${user} crontab` }] };
       }
       case "cron-toggle": {
-        const conn = await getServerConnection(a.serverId);
+        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`);
+        const current = await sshExec(conn, `crontab -l -u ${user} 2>/dev/null`, proxy);
         const lines = current.stdout.split("\n");
         let toggled = 0;
         const updated = lines.map((line) => {
@@ -1779,7 +2306,7 @@ ${schedule} ${command}` }] };
           return { content: [{ type: "text", text: `No ${state} cron entries found matching "${match}"` }] };
         }
         const escapedCrontab = updated.join("\n").replace(/'/g, "'\\''");
-        const result = await sshExec(conn, `echo '${escapedCrontab}' | crontab -u ${user} -`);
+        const result = await sshExec(conn, `echo '${escapedCrontab}' | crontab -u ${user} -`, proxy);
         if (result.exitCode !== 0) {
           throw new Error(result.stderr || "Failed to update crontab");
         }
@@ -1924,6 +2451,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) {