@mgsoftwarebv/mg-dashboard-mcp 6.0.1 → 6.1.0

package/dist/index.js

@@ -10,7 +10,9 @@ import { ListToolsRequestSchema, CallToolRequestSchema, isInitializeRequest, Lis
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { createServer } from 'http';
 import { randomUUID, createHash, randomBytes, createDecipheriv, createCipheriv } from 'crypto';
-import { createClient } from '@supabase/supabase-js';
+import { sql } from 'drizzle-orm';
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
 import { readFile, mkdtemp, writeFile, rm } from 'fs/promises';
 import { tmpdir } from 'os';
 import { Client } from 'ssh2';
@@ -270,6 +272,44 @@ var init_proxy_mode = __esm({
   "src/proxy-mode.ts"() {
   }
 });
+var connectionConfig = {
+  prepare: false,
+  idle_timeout: 20,
+  max_lifetime: 60 * 60,
+  connect_timeout: 30,
+  max: 10,
+  onnotice: (notice) => {
+    if (notice.severity !== "INFO") {
+      console.warn("[mg-dashboard db]", notice.message);
+    }
+  },
+  connection: {
+    application_name: `mg-dashboard-${process.env.VERCEL ? "vercel" : process.env.TRIGGER_RUN_ID ? "trigger" : "local"}`
+  }
+};
+function getDatabaseUrl() {
+  const url = process.env.DATABASE_PRIMARY_POOLER_URL || process.env.DATABASE_PRIMARY_URL;
+  if (!url) {
+    throw new Error(
+      "[@mgboiler/db] DATABASE_PRIMARY_URL or DATABASE_PRIMARY_POOLER_URL must be set"
+    );
+  }
+  return url;
+}
+var _pool = null;
+var _db = null;
+function getPool() {
+  if (!_pool) {
+    _pool = postgres(getDatabaseUrl(), connectionConfig);
+  }
+  return _pool;
+}
+function getDb() {
+  if (!_db) {
+    _db = drizzle(getPool(), { casing: "snake_case" });
+  }
+  return _db;
+}
 
 // src/trigger-tools.ts
 var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
@@ -340,10 +380,10 @@ var TRIGGER_TOOL_MODULE_MAP = {
   "trigger-run": "ci_cd"
 };
 async function discoverInstance(projectSlug, conn, proxy, sshExec2) {
-  const sql = `SELECT re.\\"apiKey\\" FROM \\"RuntimeEnvironment\\" re JOIN \\"Project\\" p ON re.\\"projectId\\" = p.id WHERE p.slug='${projectSlug}' AND re.slug='prod' LIMIT 1`;
+  const sql4 = `SELECT re.\\"apiKey\\" FROM \\"RuntimeEnvironment\\" re JOIN \\"Project\\" p ON re.\\"projectId\\" = p.id WHERE p.slug='${projectSlug}' AND re.slug='prod' LIMIT 1`;
   const cmd = [
     `PORT=$(docker port "${WA_CONTAINER}" 3000/tcp 2>/dev/null | head -1 | sed 's/.*://')`,
-    `KEY=$(docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql}" 2>/dev/null | tr -d '[:space:]')`,
+    `KEY=$(docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql4}" 2>/dev/null | tr -d '[:space:]')`,
     'echo "$PORT|$KEY"'
   ].join(" && ");
   const result = await sshExec2(conn, cmd, proxy);
@@ -364,8 +404,8 @@ async function discoverInstance(projectSlug, conn, proxy, sshExec2) {
   return { port, apiKey: apiKey2 };
 }
 async function fetchRunLogs(runId, conn, proxy, sshExec2) {
-  const sql = `SELECT level, message, \\"isError\\", \\"createdAt\\" FROM \\"TaskEvent\\" WHERE \\"runId\\" = '${runId}' AND level IN ('INFO','WARN','ERROR','DEBUG','LOG','TRACE') ORDER BY \\"startTime\\" ASC LIMIT 200`;
-  const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql}" 2>/dev/null`;
+  const sql4 = `SELECT level, message, \\"isError\\", \\"createdAt\\" FROM \\"TaskEvent\\" WHERE \\"runId\\" = '${runId}' AND level IN ('INFO','WARN','ERROR','DEBUG','LOG','TRACE') ORDER BY \\"startTime\\" ASC LIMIT 200`;
+  const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql4}" 2>/dev/null`;
   const result = await sshExec2(conn, cmd, proxy);
   const output = result.stdout.trim();
   if (!output) return "";
@@ -447,8 +487,8 @@ async function handleTriggerTool(name, args2, deps) {
   switch (name) {
     // -----------------------------------------------------------------
     case "trigger-list": {
-      const sql = 'SELECT slug, name FROM \\"Project\\" ORDER BY name';
-      const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql}" 2>/dev/null`;
+      const sql4 = 'SELECT slug, name FROM \\"Project\\" ORDER BY name';
+      const cmd = `docker exec "${PG_CONTAINER}" psql -U postgres -d main -t -A -c "${sql4}" 2>/dev/null`;
       const result = await sshExec2(conn, cmd, proxy);
       const output = result.stdout.trim();
       if (!output) {
@@ -643,8 +683,6 @@ async function waitForCompletion(conn, proxy, sshExec2, instance, runId, waitSec
     }]
   };
 }
-
-// src/vercel-tools.ts
 var VERCEL_API = "https://api.vercel.com";
 var VERCEL_TOOLS = [
   {
@@ -934,8 +972,10 @@ async function getDomainConfig(token, domain) {
   return { config: res.data, 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}`);
+  const rows = await deps.db.execute(sql`
+    SELECT vercel_token_encrypted FROM app_setting LIMIT 1
+  `);
+  const data = rows[0];
   if (!data?.vercel_token_encrypted) {
     throw new Error("Vercel API token is not configured. Add it in dashboard Settings.");
   }
@@ -1166,16 +1206,26 @@ async function handleVercelTool(name, args2, deps) {
       }
       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 ?? []) }]
-        };
+        const conds = [sql`TRUE`];
+        if (args2.projectName) conds.push(sql`project_name = ${String(args2.projectName)}`);
+        if (args2.status) conds.push(sql`status = ${String(args2.status)}`);
+        const where = sql.join(conds, sql` AND `);
+        try {
+          const rows = await deps.db.execute(sql`
+            SELECT id, event_type, status, project_name, deployment_id, target,
+                   message, error_message, created_at
+            FROM vercel_webhook_logs
+            WHERE ${where}
+            ORDER BY created_at DESC
+            LIMIT ${limit}
+          `);
+          return {
+            content: [{ type: "text", text: formatWebhookHistory([...rows]) }]
+          };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { content: [{ type: "text", text: `Error: ${msg}` }] };
+        }
       }
       return {
         content: [
@@ -1248,6 +1298,672 @@ ${status}` }] };
       return { content: [{ type: "text", text: `Unknown vercel tool: ${name}` }] };
   }
 }
+var REPO_TOOLS = [
+  {
+    name: "repo-list",
+    description: "List registered reference repositories. Auto-discovered from configured GitHub orgs; each row carries an `enabled` flag \u2014 only enabled repos are clonable on the mcp-repo-host and reachable via the other repo-* tools. Filter with `enabledOnly` (default true), `org`, `topic`, or `search` (substring on full_name / description).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        enabledOnly: {
+          type: "boolean",
+          description: "When true (default), only return repos with enabled = true."
+        },
+        org: { type: "string", description: "Filter by org/owner login." },
+        topic: { type: "string", description: "Match against the repo's GitHub topics array." },
+        search: { type: "string", description: "Substring match (case-insensitive) on full_name or description." },
+        limit: {
+          type: "number",
+          description: "Max rows to return (default 200, cap 1000)."
+        }
+      }
+    }
+  },
+  {
+    name: "repo-tree",
+    description: 'List entries (files + directories) inside a repository at an optional path and ref. Uses `git ls-tree` on the central clone \u2014 no network round-trip to GitHub.\n\nIdentify the repo by `repo` (full_name like "MGSoftwareBV/mg-dashboard" or just the short name when unambiguous). `path` is the subdirectory to list (default repo root). `ref` accepts a branch, tag or SHA (default HEAD).\n\nUse `recursive: true` to walk into subdirectories; use `pattern` (glob on basename) to keep output focused (e.g. `*.tsx`). Output is bounded \u2014 pass `maxResults` to raise the cap (default 2000).',
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: 'Repo full_name (e.g. "MGSoftwareBV/mg-dashboard") or short name.' },
+        path: { type: "string", description: "Subdirectory inside the repo (default: repo root)." },
+        ref: { type: "string", description: "Branch, tag or commit SHA (default: HEAD aka default branch)." },
+        recursive: { type: "boolean", description: "Walk into subdirectories (default false)." },
+        pattern: { type: "string", description: "Glob filter on basename (e.g. `*.ts`)." },
+        maxResults: { type: "number", description: "Max entries to return (default 2000, cap 20000)." }
+      },
+      required: ["repo"]
+    }
+  },
+  {
+    name: "repo-read",
+    description: "Read a single text file from a repository at an optional ref. Uses `git show <ref>:<path>` so any branch / tag / commit works \u2014 not just the current checkout.\n\nIdentify the repo by full_name or short name. Capped at 1 MiB inline; use `offset` and/or `length` for ranged reads. Ranged reads include a `# range: bytes A-B of TOTAL` header so the caller knows what window they got.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repo full_name or short name." },
+        path: { type: "string", description: "File path inside the repo (relative to repo root)." },
+        ref: { type: "string", description: "Branch, tag or commit SHA (default: HEAD)." },
+        offset: { type: "number", description: "Byte offset to start reading (0-indexed). Triggers ranged-read mode." },
+        length: { type: "number", description: "Bytes to read (cap 1 MiB). Defaults to remaining-from-offset." }
+      },
+      required: ["repo", "path"]
+    }
+  },
+  {
+    name: "repo-search",
+    description: "ripgrep across one or more enabled repositories. Returns matching lines with file + line number, grouped by file.\n\nScope: pass `repo` for a single repo or `repos: [...]` for fan-out across multiple. Omit both to search every enabled repo (capped for safety).\n\n`pattern` is a regex (PCRE-lite ripgrep syntax). Toggle `caseSensitive` (default smart-case). Use `glob` to limit by filename (e.g. `*.tsx`), `path` to scope to a subdirectory, `context` for \xB1N lines, and `maxResults` to cap output (default 200 matches).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: "Regex to search for (ripgrep syntax)." },
+        repo: { type: "string", description: "Single repo full_name or short name." },
+        repos: { type: "array", items: { type: "string" }, description: "Multiple repos (mutually exclusive with `repo`)." },
+        path: { type: "string", description: "Subdirectory inside each repo to scope the search." },
+        glob: { type: "string", description: "Filename glob filter (e.g. `*.ts`)." },
+        caseSensitive: { type: "boolean", description: "When true, force case-sensitive (default: smart-case)." },
+        context: { type: "number", description: "Show \xB1N context lines per match (default 0, cap 5)." },
+        maxResults: { type: "number", description: "Cap total matches across all repos (default 200, cap 2000)." }
+      },
+      required: ["pattern"]
+    }
+  },
+  {
+    name: "repo-find-symbol",
+    description: "Locate the definition of a symbol (class / function / type / const) across one or more repos using language-aware regex presets layered on top of ripgrep. Faster and less noisy than a plain repo-search when you know the exact identifier.\n\nPresets cover TypeScript / JavaScript, Go, Python, Rust, Java/Kotlin, C#, and PHP by default; pass `languages` to narrow (e.g. `['ts','php']`). Scope with `repo` / `repos` like repo-search.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        symbol: { type: "string", description: "Exact identifier to find (no regex metacharacters)." },
+        repo: { type: "string", description: "Single repo full_name or short name." },
+        repos: { type: "array", items: { type: "string" }, description: "Multiple repos (mutually exclusive with `repo`)." },
+        languages: {
+          type: "array",
+          items: { type: "string", enum: ["ts", "js", "go", "py", "rs", "java", "cs", "php"] },
+          description: "Restrict to one or more language presets. Defaults to all."
+        },
+        maxResults: { type: "number", description: "Cap matches returned (default 50, cap 500)." }
+      },
+      required: ["symbol"]
+    }
+  },
+  {
+    name: "repo-log",
+    description: "git log for a repository or path. Returns one row per commit: SHA, short author, ISO date, subject. Use `path` to follow history of a specific file/directory; `limit` to cap entries (default 25, max 500); optional `since` / `until` / `author` filters.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repo full_name or short name." },
+        path: { type: "string", description: "Optional path filter (file or directory)." },
+        ref: { type: "string", description: "Branch / tag / SHA to start from (default HEAD)." },
+        limit: { type: "number", description: "Max commits to return (default 25, max 500)." },
+        since: { type: "string", description: "ISO date or git relative date (e.g. `2 weeks ago`)." },
+        until: { type: "string", description: "ISO date or git relative date." },
+        author: { type: "string", description: "Substring match on author name or email." }
+      },
+      required: ["repo"]
+    }
+  },
+  {
+    name: "repo-blame",
+    description: "git blame for a line range in a file. Returns `sha  author  iso-date  line` rows so it's easy to spot when a specific line was introduced. Provide `path` and a `startLine`/`endLine` window (max 500 lines per call).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        repo: { type: "string", description: "Repo full_name or short name." },
+        path: { type: "string", description: "File path inside the repo." },
+        startLine: { type: "number", description: "1-based start line (default 1)." },
+        endLine: { type: "number", description: "1-based end line (default startLine + 200, capped at startLine + 500)." },
+        ref: { type: "string", description: "Branch / tag / SHA to blame against (default HEAD)." }
+      },
+      required: ["repo", "path"]
+    }
+  }
+];
+var REPO_TOOL_NAMES = new Set(REPO_TOOLS.map((t) => t.name));
+var REPO_TOOL_MODULE_MAP = {
+  "repo-list": "repositories",
+  "repo-tree": "repositories",
+  "repo-read": "repositories",
+  "repo-search": "repositories",
+  "repo-find-symbol": "repositories",
+  "repo-log": "repositories",
+  "repo-blame": "repositories"
+};
+var READ_INLINE_LIMIT = 1024 * 1024;
+var SEARCH_DEFAULT_MAX = 200;
+var SEARCH_HARD_CAP = 2e3;
+var TREE_DEFAULT_MAX = 2e3;
+var TREE_HARD_CAP = 2e4;
+var LOG_DEFAULT_MAX = 25;
+var LOG_HARD_CAP = 500;
+var BLAME_WINDOW_DEFAULT = 200;
+var BLAME_WINDOW_MAX = 500;
+var FAN_OUT_HARD_CAP = 20;
+var hostCache = null;
+function bashQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+async function resolveRepoHost(deps) {
+  if (hostCache && hostCache.expiresAt > Date.now()) return hostCache;
+  const rows = await deps.db.execute(sql`
+    SELECT id FROM ssh_server
+    WHERE tags @> ARRAY['mcp-repo-host']::text[]
+    LIMIT 2
+  `);
+  if (rows.length === 0) {
+    throw new Error(
+      'No SSH server has the "mcp-repo-host" tag. Add the tag to exactly one server to enable repo-* tools.'
+    );
+  }
+  const serverId = rows[0].id;
+  const { conn, proxy } = await deps.getServerConnection(serverId);
+  hostCache = {
+    expiresAt: Date.now() + 6e4,
+    serverId,
+    conn,
+    proxy
+  };
+  return hostCache;
+}
+async function resolveRepo(deps, repoInput) {
+  const trimmed = repoInput.trim();
+  if (!trimmed) throw new Error("repo: empty input");
+  const isFullName = trimmed.includes("/");
+  const rows = isFullName ? await deps.db.execute(sql`
+        SELECT id, org, name, full_name, default_branch, visibility, description,
+               topics, enabled, clone_path, last_pulled_at, last_sync_error
+        FROM mcp_repositories
+        WHERE enabled = true AND full_name = ${trimmed}
+        LIMIT 5
+      `) : await deps.db.execute(sql`
+        SELECT id, org, name, full_name, default_branch, visibility, description,
+               topics, enabled, clone_path, last_pulled_at, last_sync_error
+        FROM mcp_repositories
+        WHERE enabled = true AND name = ${trimmed}
+        LIMIT 5
+      `);
+  if (rows.length === 0) {
+    throw new Error(
+      `Repo "${trimmed}" is not enabled (or not registered). Enable it in the Repositories module first; the sync job will then clone it on the mcp-repo-host.`
+    );
+  }
+  if (rows.length > 1) {
+    const options = rows.map((r) => r.full_name).join(", ");
+    throw new Error(`Ambiguous repo "${trimmed}". Pass the full_name. Candidates: ${options}`);
+  }
+  const row = rows[0];
+  if (!row.clone_path) {
+    throw new Error(
+      `Repo "${row.full_name}" is enabled but has not been cloned yet. Trigger sync-repository-clones or wait for the next scheduled run.`
+    );
+  }
+  return row;
+}
+async function resolveRepos(deps, args2) {
+  if (args2.repo) {
+    return [await resolveRepo(deps, args2.repo)];
+  }
+  if (args2.repos && args2.repos.length > 0) {
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const r of args2.repos) {
+      const row = await resolveRepo(deps, r);
+      if (!seen.has(row.id)) {
+        seen.add(row.id);
+        out.push(row);
+      }
+    }
+    return out;
+  }
+  const rows = await deps.db.execute(sql`
+    SELECT id, org, name, full_name, default_branch, visibility, description,
+           topics, enabled, clone_path, last_pulled_at, last_sync_error
+    FROM mcp_repositories
+    WHERE enabled = true AND clone_path IS NOT NULL
+    ORDER BY full_name
+    LIMIT ${FAN_OUT_HARD_CAP}
+  `);
+  return rows;
+}
+async function runRemote(deps, host, script, timeoutMs = 6e4) {
+  return deps.sshExec(
+    { ...host.conn, timeout: timeoutMs },
+    `bash -c ${bashQuote(script)}`,
+    host.proxy
+  );
+}
+function clampInt(value, def, min, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return def;
+  return Math.min(max, Math.max(min, Math.trunc(n)));
+}
+function basenameMatchesGlob(name, pattern) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  const re = new RegExp(`^${escaped}$`, "i");
+  return re.test(name);
+}
+async function handleRepoList(deps, args2) {
+  const enabledOnly = args2.enabledOnly !== false;
+  const limit = clampInt(args2.limit, 200, 1, 1e3);
+  const search = typeof args2.search === "string" ? args2.search.trim().toLowerCase() : "";
+  const orgFilter = typeof args2.org === "string" ? args2.org.trim() : "";
+  const topicFilter = typeof args2.topic === "string" ? args2.topic.trim() : "";
+  const conds = [sql`TRUE`];
+  if (enabledOnly) conds.push(sql`enabled = true`);
+  if (orgFilter) conds.push(sql`org = ${orgFilter}`);
+  if (topicFilter) conds.push(sql`topics @> ARRAY[${topicFilter}]::text[]`);
+  const where = sql.join(conds, sql` AND `);
+  const rowsRaw = await deps.db.execute(sql`
+    SELECT id, org, name, full_name, default_branch, visibility, description,
+           topics, enabled, clone_path, last_pulled_at, last_sync_error
+    FROM mcp_repositories
+    WHERE ${where}
+    ORDER BY full_name
+    LIMIT ${limit}
+  `);
+  let rows = [...rowsRaw];
+  if (search) {
+    rows = rows.filter((r) => {
+      const a = r.full_name.toLowerCase();
+      const b = (r.description || "").toLowerCase();
+      return a.includes(search) || b.includes(search);
+    });
+  }
+  if (rows.length === 0) {
+    const hint = enabledOnly ? "No enabled repositories match. Pass enabledOnly: false to also see disabled rows, or run discover-repositories first." : "No repositories registered. Run the discover-repositories task to populate this table.";
+    return { content: [{ type: "text", text: hint }] };
+  }
+  const header = `${"FULL_NAME".padEnd(45)}  ${"BRANCH".padEnd(15)}  ${"VIS".padEnd(8)}  ${"ENABLED".padEnd(8)}  ${"LAST_PULLED".padEnd(20)}  CLONE_PATH`;
+  const lines = rows.map((r) => {
+    const pulled = r.last_pulled_at ? new Date(r.last_pulled_at).toISOString().slice(0, 19).replace("T", " ") : "never";
+    const err = r.last_sync_error ? ` ERR:${r.last_sync_error.slice(0, 40)}` : "";
+    return `${r.full_name.padEnd(45)}  ${(r.default_branch || "").padEnd(15)}  ${(r.visibility || "").padEnd(8)}  ${(r.enabled ? "yes" : "no").padEnd(8)}  ${pulled.padEnd(20)}  ${r.clone_path || "-"}${err}`;
+  });
+  return {
+    content: [
+      { type: "text", text: `${header}
+${"-".repeat(header.length)}
+${lines.join("\n")}` }
+    ]
+  };
+}
+async function handleRepoTree(deps, args2) {
+  const row = await resolveRepo(deps, String(args2.repo || ""));
+  const host = await resolveRepoHost(deps);
+  const ref = typeof args2.ref === "string" && args2.ref ? args2.ref : row.default_branch;
+  const path = typeof args2.path === "string" ? args2.path.replace(/^\/+|\/+$/g, "") : "";
+  const recursive = args2.recursive === true;
+  const maxResults = clampInt(args2.maxResults, TREE_DEFAULT_MAX, 1, TREE_HARD_CAP);
+  const pattern = typeof args2.pattern === "string" ? args2.pattern : "";
+  const lsArgs = recursive ? "-r" : "";
+  const refSpec = path ? `${ref}:${bashQuote(path)}` : bashQuote(ref);
+  const cmd = `git -C ${bashQuote(row.clone_path)} ls-tree ${lsArgs} --long ${refSpec} 2>&1 | head -n ${maxResults + 1}`;
+  const res = await runRemote(deps, host, cmd, 3e4);
+  if (res.exitCode !== 0) {
+    return { content: [{ type: "text", text: `Error: ${(res.stderr || res.stdout || "git ls-tree failed").trim().slice(0, 500)}` }] };
+  }
+  const lines = [];
+  for (const raw of res.stdout.split("\n")) {
+    const line = raw.trimEnd();
+    if (!line) continue;
+    const tabIdx = line.indexOf("	");
+    if (tabIdx === -1) continue;
+    const left = line.slice(0, tabIdx).trim().split(/\s+/);
+    const entryPath = line.slice(tabIdx + 1);
+    if (left.length < 4) continue;
+    const [mode, type, object, size] = [left[0], left[1], left[2], left[3]];
+    if (pattern) {
+      const base = entryPath.split("/").pop() || entryPath;
+      if (!basenameMatchesGlob(base, pattern)) continue;
+    }
+    lines.push({ mode, type, object, size, path: entryPath });
+    if (lines.length >= maxResults) break;
+  }
+  if (lines.length === 0) {
+    return { content: [{ type: "text", text: `No entries at ${row.full_name}@${ref}${path ? `:${path}` : ""}` }] };
+  }
+  const header = `${"TYPE".padEnd(6)}  ${"SIZE".padEnd(10)}  ${"OBJECT".padEnd(12)}  PATH`;
+  const rendered = lines.map((e) => {
+    const size = e.type === "blob" ? e.size : "-";
+    return `${e.type.padEnd(6)}  ${size.padEnd(10)}  ${e.object.slice(0, 12).padEnd(12)}  ${e.path}`;
+  });
+  const footer = lines.length >= maxResults ? `
+
+[truncated at ${maxResults} entries \u2014 pass maxResults to widen]` : "";
+  return {
+    content: [
+      { type: "text", text: `repo: ${row.full_name}  ref: ${ref}${path ? `  path: ${path}` : ""}
+${header}
+${"-".repeat(header.length)}
+${rendered.join("\n")}${footer}` }
+    ]
+  };
+}
+async function handleRepoRead(deps, args2) {
+  const row = await resolveRepo(deps, String(args2.repo || ""));
+  const host = await resolveRepoHost(deps);
+  const filePath = String(args2.path || "").replace(/^\/+/, "");
+  if (!filePath) return { content: [{ type: "text", text: "Error: path is required" }] };
+  const ref = typeof args2.ref === "string" && args2.ref ? args2.ref : row.default_branch;
+  const ranged = args2.offset !== void 0 || args2.length !== void 0;
+  const offset = clampInt(args2.offset, 0, 0, Number.MAX_SAFE_INTEGER);
+  const length = clampInt(
+    args2.length,
+    READ_INLINE_LIMIT,
+    1,
+    READ_INLINE_LIMIT
+  );
+  const SENTINEL = "__MCP_REPO_READ_BODY__";
+  const refSpec = `${ref}:${filePath}`;
+  let body;
+  if (ranged) {
+    body = `git -C ${bashQuote(row.clone_path)} show ${bashQuote(refSpec)} | tail -c +${offset + 1} | head -c ${length}`;
+  } else {
+    body = `git -C ${bashQuote(row.clone_path)} show ${bashQuote(refSpec)} | head -c ${READ_INLINE_LIMIT}`;
+  }
+  const cmd = `set -o pipefail; SZ=$(git -C ${bashQuote(row.clone_path)} cat-file -s ${bashQuote(refSpec)}) && echo "$SZ" && echo "${SENTINEL}" && ${body}`;
+  const res = await runRemote(deps, host, cmd, 6e4);
+  if (res.exitCode !== 0) {
+    return {
+      content: [
+        { type: "text", text: `Error: ${(res.stderr || res.stdout || "git show failed").trim().slice(0, 500)}` }
+      ]
+    };
+  }
+  const idx = res.stdout.indexOf(`${SENTINEL}
+`);
+  if (idx === -1) {
+    return { content: [{ type: "text", text: `Error: malformed output reading ${filePath}` }] };
+  }
+  const totalSize = Number(res.stdout.slice(0, idx).trim());
+  const content = res.stdout.slice(idx + SENTINEL.length + 1);
+  if (ranged) {
+    const end = Math.min(totalSize, offset + length) - 1;
+    const header = `# range: bytes ${offset}-${end} of ${totalSize}
+`;
+    return { content: [{ type: "text", text: header + content }] };
+  }
+  if (totalSize > READ_INLINE_LIMIT) {
+    const header = `# truncated: showing first ${READ_INLINE_LIMIT} bytes of ${totalSize} \u2014 use offset/length for ranged reads
+`;
+    return { content: [{ type: "text", text: header + content }] };
+  }
+  return { content: [{ type: "text", text: content }] };
+}
+async function handleRepoSearch(deps, args2) {
+  const pattern = String(args2.pattern || "");
+  if (!pattern) return { content: [{ type: "text", text: "Error: pattern is required" }] };
+  const rows = await resolveRepos(deps, {
+    repo: typeof args2.repo === "string" ? args2.repo : void 0,
+    repos: Array.isArray(args2.repos) ? args2.repos.map(String) : void 0
+  });
+  if (rows.length === 0) {
+    return { content: [{ type: "text", text: "No enabled, cloned repositories available to search." }] };
+  }
+  const host = await resolveRepoHost(deps);
+  const path = typeof args2.path === "string" ? args2.path.replace(/^\/+|\/+$/g, "") : "";
+  const glob = typeof args2.glob === "string" ? args2.glob : "";
+  const caseSensitive = args2.caseSensitive === true;
+  const context = clampInt(args2.context, 0, 0, 5);
+  const cap = clampInt(args2.maxResults, SEARCH_DEFAULT_MAX, 1, SEARCH_HARD_CAP);
+  const rgFlags = [
+    "--with-filename",
+    "--line-number",
+    "--color=never",
+    caseSensitive ? "" : "--smart-case",
+    context > 0 ? `-C ${context}` : "",
+    glob ? `--glob ${bashQuote(glob)}` : "",
+    `--max-count ${Math.min(cap, 200)}`
+  ].filter(Boolean).join(" ");
+  const sections = [];
+  let remaining = cap;
+  for (const row of rows) {
+    if (remaining <= 0) break;
+    const target = path ? `${row.clone_path}/${path}` : row.clone_path;
+    const cmd = `rg ${rgFlags} -e ${bashQuote(pattern)} ${bashQuote(target)} 2>&1 | head -n ${remaining * (context * 2 + 1) + 200}`;
+    const res = await runRemote(deps, host, cmd, 6e4);
+    if (res.exitCode !== 0 && res.exitCode !== 1) {
+      sections.push(`=== ${row.full_name} ===
+Error: ${(res.stderr || res.stdout || "rg failed").trim().slice(0, 300)}`);
+      continue;
+    }
+    const body = res.stdout.trim();
+    if (!body) {
+      sections.push(`=== ${row.full_name} ===
+(no matches)`);
+      continue;
+    }
+    const prefix = `${row.clone_path}/`;
+    const cleaned = body.split("\n").map((l) => l.startsWith(prefix) ? l.slice(prefix.length) : l).join("\n");
+    const matchLines = cleaned.split("\n").filter((l) => /:\d+:/.test(l)).length;
+    remaining -= matchLines;
+    sections.push(`=== ${row.full_name} ===
+${cleaned}`);
+  }
+  const footer = remaining <= 0 ? `
+
+[hit cap of ${cap} matches across repos \u2014 narrow the pattern or pass maxResults]` : "";
+  return { content: [{ type: "text", text: sections.join("\n\n") + footer }] };
+}
+var SYMBOL_PRESETS = {
+  ts: {
+    exts: ["ts", "tsx"],
+    pattern: (s) => `(export\\s+(default\\s+)?)?(async\\s+)?(class|interface|type|enum|function|const|let|var)\\s+${s}\\b|\\b${s}\\s*[:=]\\s*(async\\s*)?\\(|^\\s*${s}\\s*\\(`
+  },
+  js: {
+    exts: ["js", "jsx", "mjs", "cjs"],
+    pattern: (s) => `(export\\s+(default\\s+)?)?(async\\s+)?(class|function|const|let|var)\\s+${s}\\b|\\b${s}\\s*[:=]\\s*(async\\s*)?\\(`
+  },
+  go: {
+    exts: ["go"],
+    pattern: (s) => `^func\\s+(\\([^)]*\\)\\s+)?${s}\\b|^type\\s+${s}\\b|^var\\s+${s}\\b|^const\\s+${s}\\b`
+  },
+  py: {
+    exts: ["py"],
+    pattern: (s) => `^\\s*(async\\s+)?def\\s+${s}\\b|^\\s*class\\s+${s}\\b`
+  },
+  rs: {
+    exts: ["rs"],
+    pattern: (s) => `\\b(fn|struct|enum|trait|type|const|static)\\s+${s}\\b`
+  },
+  java: {
+    exts: ["java", "kt"],
+    pattern: (s) => `(public|private|protected)?\\s*(static\\s+)?(class|interface|enum|record)\\s+${s}\\b|\\b\\w+\\s+${s}\\s*\\(`
+  },
+  cs: {
+    exts: ["cs"],
+    pattern: (s) => `(public|private|protected|internal)\\s+(static\\s+)?(class|interface|struct|enum|record)\\s+${s}\\b|\\b${s}\\s*\\(`
+  },
+  php: {
+    exts: ["php"],
+    pattern: (s) => `\\b(function|class|interface|trait)\\s+${s}\\b|\\bconst\\s+${s}\\b`
+  }
+};
+async function handleRepoFindSymbol(deps, args2) {
+  const symbol = String(args2.symbol || "").trim();
+  if (!symbol) return { content: [{ type: "text", text: "Error: symbol is required" }] };
+  if (!/^[A-Za-z_$][\w$]*$/.test(symbol)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: symbol "${symbol}" must be a plain identifier (letters, digits, underscore, $). Use repo-search for regex matches.`
+        }
+      ]
+    };
+  }
+  const rows = await resolveRepos(deps, {
+    repo: typeof args2.repo === "string" ? args2.repo : void 0,
+    repos: Array.isArray(args2.repos) ? args2.repos.map(String) : void 0
+  });
+  if (rows.length === 0) {
+    return { content: [{ type: "text", text: "No enabled, cloned repositories available to search." }] };
+  }
+  const host = await resolveRepoHost(deps);
+  const langs = Array.isArray(args2.languages) && args2.languages.length > 0 ? args2.languages.map(String).filter((l) => l in SYMBOL_PRESETS) : Object.keys(SYMBOL_PRESETS);
+  const cap = clampInt(args2.maxResults, 50, 1, 500);
+  const sections = [];
+  let remaining = cap;
+  for (const row of rows) {
+    if (remaining <= 0) break;
+    const perLang = [];
+    const extGlobs = [];
+    for (const lang of langs) {
+      const preset = SYMBOL_PRESETS[lang];
+      perLang.push(`(?:${preset.pattern(symbol)})`);
+      for (const ext of preset.exts) extGlobs.push(`*.${ext}`);
+    }
+    const combined = perLang.join("|");
+    const globArgs = extGlobs.map((g) => `--glob ${bashQuote(g)}`).join(" ");
+    const cmd = `rg --with-filename --line-number --color=never --smart-case ${globArgs} -e ${bashQuote(combined)} ${bashQuote(row.clone_path)} 2>&1 | head -n ${remaining * 2}`;
+    const res = await runRemote(deps, host, cmd, 45e3);
+    if (res.exitCode !== 0 && res.exitCode !== 1) {
+      sections.push(`=== ${row.full_name} ===
+Error: ${(res.stderr || res.stdout || "rg failed").trim().slice(0, 300)}`);
+      continue;
+    }
+    const body = res.stdout.trim();
+    if (!body) {
+      sections.push(`=== ${row.full_name} ===
+(no match for "${symbol}")`);
+      continue;
+    }
+    const prefix = `${row.clone_path}/`;
+    const cleaned = body.split("\n").map((l) => l.startsWith(prefix) ? l.slice(prefix.length) : l).join("\n");
+    const matchCount = cleaned.split("\n").length;
+    remaining -= matchCount;
+    sections.push(`=== ${row.full_name} ===
+${cleaned}`);
+  }
+  const footer = remaining <= 0 ? `
+
+[hit cap of ${cap} matches \u2014 pass maxResults to widen]` : "";
+  return { content: [{ type: "text", text: sections.join("\n\n") + footer }] };
+}
+async function handleRepoLog(deps, args2) {
+  const row = await resolveRepo(deps, String(args2.repo || ""));
+  const host = await resolveRepoHost(deps);
+  const limit = clampInt(args2.limit, LOG_DEFAULT_MAX, 1, LOG_HARD_CAP);
+  const ref = typeof args2.ref === "string" && args2.ref ? args2.ref : row.default_branch;
+  const path = typeof args2.path === "string" ? args2.path.replace(/^\/+/, "") : "";
+  const since = typeof args2.since === "string" ? args2.since : "";
+  const until = typeof args2.until === "string" ? args2.until : "";
+  const author = typeof args2.author === "string" ? args2.author : "";
+  const fmt = "%H%x09%an%x09%aI%x09%s";
+  const optParts = [
+    `-n ${limit}`,
+    `--pretty=format:${fmt}`,
+    since ? `--since=${bashQuote(since)}` : "",
+    until ? `--until=${bashQuote(until)}` : "",
+    author ? `--author=${bashQuote(author)}` : ""
+  ].filter(Boolean).join(" ");
+  const refPart = bashQuote(ref);
+  const pathPart = path ? ` -- ${bashQuote(path)}` : "";
+  const cmd = `git -C ${bashQuote(row.clone_path)} log ${optParts} ${refPart}${pathPart} 2>&1`;
+  const res = await runRemote(deps, host, cmd, 45e3);
+  if (res.exitCode !== 0) {
+    return { content: [{ type: "text", text: `Error: ${(res.stderr || res.stdout || "git log failed").trim().slice(0, 500)}` }] };
+  }
+  const lines = res.stdout.trim().split("\n").filter(Boolean);
+  if (lines.length === 0) {
+    return { content: [{ type: "text", text: `No commits found for ${row.full_name}@${ref}${path ? `:${path}` : ""}` }] };
+  }
+  const rendered = lines.map((l) => {
+    const parts = l.split("	");
+    const sha = (parts[0] || "").slice(0, 12);
+    const author2 = parts[1] || "";
+    const date = parts[2] || "";
+    const subject = parts[3] || "";
+    return `${sha.padEnd(12)}  ${date.padEnd(25)}  ${author2.padEnd(25)}  ${subject}`;
+  });
+  const header = `${"SHA".padEnd(12)}  ${"DATE".padEnd(25)}  ${"AUTHOR".padEnd(25)}  SUBJECT`;
+  return { content: [{ type: "text", text: `${header}
+${"-".repeat(header.length)}
+${rendered.join("\n")}` }] };
+}
+async function handleRepoBlame(deps, args2) {
+  const row = await resolveRepo(deps, String(args2.repo || ""));
+  const host = await resolveRepoHost(deps);
+  const filePath = String(args2.path || "").replace(/^\/+/, "");
+  if (!filePath) return { content: [{ type: "text", text: "Error: path is required" }] };
+  const ref = typeof args2.ref === "string" && args2.ref ? args2.ref : row.default_branch;
+  const startLine = clampInt(args2.startLine, 1, 1, Number.MAX_SAFE_INTEGER);
+  const endLine = clampInt(
+    args2.endLine,
+    startLine + BLAME_WINDOW_DEFAULT - 1,
+    startLine,
+    startLine + BLAME_WINDOW_MAX - 1
+  );
+  const cmd = `git -C ${bashQuote(row.clone_path)} blame --line-porcelain -L ${startLine},${endLine} ${bashQuote(ref)} -- ${bashQuote(filePath)} 2>&1`;
+  const res = await runRemote(deps, host, cmd, 45e3);
+  if (res.exitCode !== 0) {
+    return { content: [{ type: "text", text: `Error: ${(res.stderr || res.stdout || "git blame failed").trim().slice(0, 500)}` }] };
+  }
+  const blocks = res.stdout.split("\n	");
+  const out = [];
+  for (const block of blocks) {
+    const lines = block.split("\n");
+    let sha = "";
+    let author = "";
+    let authorTime = "";
+    let authorTz = "";
+    let sourceLine = "";
+    let inHeader = true;
+    for (const raw of lines) {
+      if (inHeader) {
+        if (!sha) {
+          const m = raw.match(/^([0-9a-f]{40})\s/);
+          if (m) {
+            sha = m[1];
+            continue;
+          }
+        }
+        if (raw.startsWith("author ")) author = raw.slice(7);
+        else if (raw.startsWith("author-time ")) authorTime = raw.slice(12);
+        else if (raw.startsWith("author-tz ")) authorTz = raw.slice(10);
+        else if (raw.startsWith("	")) {
+          sourceLine = raw.slice(1);
+          inHeader = false;
+        }
+      } else {
+        sourceLine += "\n" + raw;
+      }
+    }
+    if (!sha) continue;
+    const date = authorTime ? new Date(Number(authorTime) * 1e3).toISOString().slice(0, 19) : "";
+    out.push(`${sha.slice(0, 12)}  ${date}${authorTz ? " " + authorTz : ""}  ${author.padEnd(25)}  ${sourceLine}`);
+  }
+  if (out.length === 0) {
+    return { content: [{ type: "text", text: `No blame data for ${row.full_name}:${filePath} L${startLine}-${endLine}` }] };
+  }
+  return {
+    content: [
+      { type: "text", text: `repo: ${row.full_name}  file: ${filePath}  ref: ${ref}  lines: ${startLine}-${endLine}
+${out.join("\n")}` }
+    ]
+  };
+}
+async function handleRepoTool(name, args2, deps) {
+  switch (name) {
+    case "repo-list":
+      return handleRepoList(deps, args2);
+    case "repo-tree":
+      return handleRepoTree(deps, args2);
+    case "repo-read":
+      return handleRepoRead(deps, args2);
+    case "repo-search":
+      return handleRepoSearch(deps, args2);
+    case "repo-find-symbol":
+      return handleRepoFindSymbol(deps, args2);
+    case "repo-log":
+      return handleRepoLog(deps, args2);
+    case "repo-blame":
+      return handleRepoBlame(deps, args2);
+    default:
+      return { content: [{ type: "text", text: `Unknown repo tool: ${name}` }] };
+  }
+}
 var args = process.argv.slice(2);
 function getArg2(name) {
   return args.find((a) => a.startsWith(`--${name}=`))?.split("=").slice(1).join("=");
@@ -1260,8 +1976,7 @@ if (proxyUrl) {
 }
 var apiKey = getArg2("api-key") || process.env.MG_DASHBOARD_API_KEY;
 var sshKeyPath = getArg2("ssh-key") || process.env.MG_DASHBOARD_SSH_KEY;
-var supabaseUrl = getArg2("supabase-url") || process.env.SUPABASE_URL;
-var supabaseKey = getArg2("supabase-key") || process.env.SUPABASE_SERVICE_ROLE_KEY;
+var databaseUrl = getArg2("database-url") || process.env.DATABASE_PRIMARY_POOLER_URL || process.env.DATABASE_PRIMARY_URL;
 var encryptionKey = getArg2("encryption-key") || process.env.ENCRYPTION_KEY;
 var mijnhostApiKey = getArg2("mijnhost-api-key") || process.env.MIJNHOST_API_KEY;
 var httpMode = args.includes("--http");
@@ -1270,11 +1985,14 @@ if (!apiKey || !sshKeyPath) {
   console.error("Authentication required. Use both --api-key=dk_xxx and --ssh-key=PATH (path to your SSH private or public key), or set MG_DASHBOARD_API_KEY and MG_DASHBOARD_SSH_KEY.");
   process.exit(1);
 }
-if (!supabaseUrl || !supabaseKey) {
-  console.error("Supabase credentials required. Use --supabase-url and --supabase-key or set SUPABASE_URL and SUPABASE_SERVICE_ROLE_KEY");
+if (!databaseUrl) {
+  console.error("Database URL required. Use --database-url=postgres://... or set DATABASE_PRIMARY_URL (or DATABASE_PRIMARY_POOLER_URL).");
   process.exit(1);
 }
-var supabase = createClient(supabaseUrl, supabaseKey);
+if (!process.env.DATABASE_PRIMARY_URL && !process.env.DATABASE_PRIMARY_POOLER_URL) {
+  process.env.DATABASE_PRIMARY_URL = databaseUrl;
+}
+var db = getDb();
 var RateLimiter = class {
   buckets = /* @__PURE__ */ new Map();
   maxAttempts;
@@ -1337,17 +2055,23 @@ function redactSensitiveArgs(args2) {
 async function writeAuditLog(entry) {
   if (!authContext) return;
   try {
-    await supabase.from("mcp_audit_log").insert({
-      api_key_id: authContext.apiKeyId,
-      user_id: authContext.userId,
-      tool_name: entry.toolName,
-      arguments: entry.arguments ? redactSensitiveArgs(entry.arguments) : null,
-      ip_address: entry.ipAddress || null,
-      server_id: entry.serverId || null,
-      result_status: entry.resultStatus,
-      error_message: entry.errorMessage?.slice(0, 1e3) || null,
-      duration_ms: entry.durationMs || null
-    });
+    const argsJson = entry.arguments ? JSON.stringify(redactSensitiveArgs(entry.arguments)) : null;
+    await db.execute(sql`
+      INSERT INTO mcp_audit_log (
+        api_key_id, user_id, tool_name, arguments, ip_address,
+        server_id, result_status, error_message, duration_ms
+      ) VALUES (
+        ${authContext.apiKeyId},
+        ${authContext.userId},
+        ${entry.toolName},
+        ${argsJson}::jsonb,
+        ${entry.ipAddress || null},
+        ${entry.serverId || null},
+        ${entry.resultStatus},
+        ${entry.errorMessage?.slice(0, 1e3) || null},
+        ${entry.durationMs || null}
+      )
+    `);
   } catch (err) {
     console.error("[Audit] Failed to write audit log:", err instanceof Error ? err.message : err);
   }
@@ -1359,7 +2083,8 @@ var MODULE_KEYS = [
   "wiki",
   "ci_cd",
   "domains",
-  "settings"
+  "settings",
+  "repositories"
 ];
 var FULL_PERMISSIONS = {
   modules: Object.fromEntries(MODULE_KEYS.map((k) => [k, true])),
@@ -1411,6 +2136,8 @@ var TOOL_MODULE_MAP = {
   "db-discover": "ssh_servers",
   "db-tables": "ssh_servers",
   "db-query": "ssh_servers",
+  "db-apply-migration": "ssh_servers",
+  "db-list-migrations": "ssh_servers",
   "cache-purge": "ssh_servers",
   "env-list": "ci_cd",
   "env-get": "ci_cd",
@@ -1419,7 +2146,8 @@ var TOOL_MODULE_MAP = {
   "dns-list": "domains",
   "dns-record": "domains",
   ...TRIGGER_TOOL_MODULE_MAP,
-  ...VERCEL_TOOL_MODULE_MAP
+  ...VERCEL_TOOL_MODULE_MAP,
+  ...REPO_TOOL_MODULE_MAP
 };
 var authContext = null;
 async function validateApiKey(key) {
@@ -1434,8 +2162,14 @@ async function validateApiKey(key) {
     console.error(`Rate limited: too many failed auth attempts. Retry in ${retryMin} minute(s).`);
     return null;
   }
-  const { data, error } = await supabase.from("dashboard_mcp_api_key").select("id, name, created_by, allowed_server_ids, is_active, expires_at").eq("api_key_hash", keyHash).eq("is_active", true).single();
-  if (error || !data) {
+  const apiKeyRows = await db.execute(sql`
+    SELECT id, name, created_by, allowed_server_ids, is_active, expires_at
+    FROM dashboard_mcp_api_key
+    WHERE api_key_hash = ${keyHash} AND is_active = true
+    LIMIT 1
+  `);
+  const data = apiKeyRows[0];
+  if (!data) {
     console.error(`API key not found or inactive (${rateCheck.remaining} attempts remaining)`);
     return null;
   }
@@ -1443,20 +2177,31 @@ async function validateApiKey(key) {
     console.error(`API key has expired (${rateCheck.remaining} attempts remaining)`);
     return null;
   }
-  const { data: userData, error: userError } = await supabase.from("user").select("permissions, role:role!role_id(name, default_permissions)").eq("id", data.created_by).single();
-  if (userError || !userData) {
+  const userRows = await db.execute(sql`
+    SELECT u.permissions, r.name AS role_name, r.default_permissions AS role_default_permissions
+    FROM "user" u
+    LEFT JOIN role r ON r.id = u.role_id
+    WHERE u.id = ${data.created_by}
+    LIMIT 1
+  `);
+  const userData = userRows[0];
+  if (!userData) {
     console.error(`User not found for API key creator: ${data.created_by}`);
     return null;
   }
-  const roleName = userData.role?.name || "user";
-  const roleDefaults = userData.role?.default_permissions ?? {};
+  const roleName = userData.role_name || "user";
+  const roleDefaults = userData.role_default_permissions ?? {};
   const userOverrides = userData.permissions ?? null;
   const permissions = resolvePermissions(roleName, roleDefaults, userOverrides);
   const allowedServerIds = intersectServerAccess(
     data.allowed_server_ids,
     permissions.resources.ssh_servers
   );
-  await supabase.from("dashboard_mcp_api_key").update({ last_used_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", data.id);
+  await db.execute(sql`
+    UPDATE dashboard_mcp_api_key
+    SET last_used_at = ${(/* @__PURE__ */ new Date()).toISOString()}
+    WHERE id = ${data.id}
+  `);
   const moduleCount = MODULE_KEYS.filter((k) => permissions.modules[k]).length;
   console.error(`Authenticated as user ${data.created_by} (role: ${roleName}, modules: ${moduleCount}/${MODULE_KEYS.length})`);
   return {
@@ -1596,8 +2341,14 @@ async function validateSshKey(pubkeyPathInput, expectedApiKeyId) {
       return null;
     }
   }
-  const { data: keyRow, error: keyErr } = await supabase.from("dashboard_mcp_ssh_key").select("id, name, api_key_id, is_active").eq("fingerprint_sha256", fingerprint).eq("is_active", true).maybeSingle();
-  if (keyErr || !keyRow) {
+  const keyRows = await db.execute(sql`
+    SELECT id, name, api_key_id, is_active
+    FROM dashboard_mcp_ssh_key
+    WHERE fingerprint_sha256 = ${fingerprint} AND is_active = true
+    LIMIT 1
+  `);
+  const keyRow = keyRows[0];
+  if (!keyRow) {
     console.error(
       `SSH key not registered (fingerprint ${fingerprint}; ${rateCheck.remaining} attempts remaining). Add it under MCP API Keys \u2192 SSH Keys in the dashboard.`
     );
@@ -1609,8 +2360,14 @@ async function validateSshKey(pubkeyPathInput, expectedApiKeyId) {
     );
     return null;
   }
-  const { data: apiRow, error: apiErr } = await supabase.from("dashboard_mcp_api_key").select("id, name, created_by, allowed_server_ids, is_active, expires_at").eq("id", keyRow.api_key_id).eq("is_active", true).maybeSingle();
-  if (apiErr || !apiRow) {
+  const apiRows = await db.execute(sql`
+    SELECT id, name, created_by, allowed_server_ids, is_active, expires_at
+    FROM dashboard_mcp_api_key
+    WHERE id = ${keyRow.api_key_id} AND is_active = true
+    LIMIT 1
+  `);
+  const apiRow = apiRows[0];
+  if (!apiRow) {
     console.error("SSH key is linked to an inactive or missing MCP API key entry.");
     return null;
   }
@@ -1618,13 +2375,20 @@ async function validateSshKey(pubkeyPathInput, expectedApiKeyId) {
     console.error("Linked MCP API key entry has expired.");
     return null;
   }
-  const { data: userData, error: userError } = await supabase.from("user").select("permissions, role:role!role_id(name, default_permissions)").eq("id", apiRow.created_by).single();
-  if (userError || !userData) {
+  const userRows = await db.execute(sql`
+    SELECT u.permissions, r.name AS role_name, r.default_permissions AS role_default_permissions
+    FROM "user" u
+    LEFT JOIN role r ON r.id = u.role_id
+    WHERE u.id = ${apiRow.created_by}
+    LIMIT 1
+  `);
+  const userData = userRows[0];
+  if (!userData) {
     console.error(`User not found for SSH key creator: ${apiRow.created_by}`);
     return null;
   }
-  const roleName = userData.role?.name || "user";
-  const roleDefaults = userData.role?.default_permissions ?? {};
+  const roleName = userData.role_name || "user";
+  const roleDefaults = userData.role_default_permissions ?? {};
   const userOverrides = userData.permissions ?? null;
   const permissions = resolvePermissions(roleName, roleDefaults, userOverrides);
   const allowedServerIds = intersectServerAccess(
@@ -1633,8 +2397,8 @@ async function validateSshKey(pubkeyPathInput, expectedApiKeyId) {
   );
   const nowIso = (/* @__PURE__ */ new Date()).toISOString();
   await Promise.all([
-    supabase.from("dashboard_mcp_ssh_key").update({ last_used_at: nowIso }).eq("id", keyRow.id),
-    supabase.from("dashboard_mcp_api_key").update({ last_used_at: nowIso }).eq("id", apiRow.id)
+    db.execute(sql`UPDATE dashboard_mcp_ssh_key SET last_used_at = ${nowIso} WHERE id = ${keyRow.id}`),
+    db.execute(sql`UPDATE dashboard_mcp_api_key SET last_used_at = ${nowIso} WHERE id = ${apiRow.id}`)
   ]);
   const moduleCount = MODULE_KEYS.filter((k) => permissions.modules[k]).length;
   console.error(
@@ -1657,29 +2421,42 @@ function assertServerAccess(serverId) {
   }
 }
 async function resolveReleaseProfileStageIds(profileName) {
-  const { data: profile, error } = await supabase.from("release_profile").select("id, name").ilike("name", profileName).maybeSingle();
-  if (error) throw new Error(`Failed to look up release profile: ${error.message}`);
+  const profileRows = await db.execute(sql`
+    SELECT id, name FROM release_profile
+    WHERE name ILIKE ${profileName}
+    LIMIT 1
+  `);
+  const profile = profileRows[0];
   if (!profile) {
-    const { data: all } = await supabase.from("release_profile").select("name").order("name");
-    const names = (all || []).map((p) => p.name).join(", ");
+    const all = await db.execute(
+      sql`SELECT name FROM release_profile ORDER BY name`
+    );
+    const names = all.map((p) => p.name).join(", ");
     throw new Error(
       `Release profile "${profileName}" not found. Available profiles: ${names || "(none)"}`
     );
   }
-  const { data: stages, error: stageErr } = await supabase.from("release_profile_stage").select("id").eq("release_profile_id", profile.id);
-  if (stageErr) throw new Error(`Failed to look up stages: ${stageErr.message}`);
-  if (!stages || stages.length === 0) {
+  const stages = await db.execute(sql`
+    SELECT id FROM release_profile_stage
+    WHERE release_profile_id = ${profile.id}
+  `);
+  if (stages.length === 0) {
     throw new Error(`Release profile "${profile.name}" has no stages configured`);
   }
   return { stageIds: stages.map((s) => s.id), profileId: profile.id };
 }
 async function getProfileNamesForStageIds(stageIds) {
   if (stageIds.length === 0) return {};
-  const { data: stages } = await supabase.from("release_profile_stage").select("id, release_profile_id").in("id", stageIds);
-  if (!stages || stages.length === 0) return {};
+  const stages = await db.execute(sql`
+    SELECT id, release_profile_id FROM release_profile_stage
+    WHERE id = ANY(${stageIds}::uuid[])
+  `);
+  if (stages.length === 0) return {};
   const profileIds = [...new Set(stages.map((s) => s.release_profile_id))];
-  const { data: profiles } = await supabase.from("release_profile").select("id, name").in("id", profileIds);
-  if (!profiles) return {};
+  const profiles = await db.execute(sql`
+    SELECT id, name FROM release_profile
+    WHERE id = ANY(${profileIds}::uuid[])
+  `);
   const profileMap = {};
   for (const p of profiles) profileMap[p.id] = p.name;
   const result = {};
@@ -1773,11 +2550,19 @@ async function attemptVercelSync(appName, environment, knownStageId) {
   try {
     let stageId = knownStageId;
     if (!stageId) {
-      const { data: direct } = await supabase.from("env_config").select("release_profile_stage_id").eq("app_name", appName).not("release_profile_stage_id", "is", null).limit(1).single();
-      stageId = direct?.release_profile_stage_id;
+      const directRows = await db.execute(sql`
+        SELECT release_profile_stage_id
+        FROM env_config
+        WHERE app_name = ${appName} AND release_profile_stage_id IS NOT NULL
+        LIMIT 1
+      `);
+      stageId = directRows[0]?.release_profile_stage_id;
     }
     if (!stageId) return "Vercel sync skipped: no stage link found";
-    const { data: settings } = await supabase.from("app_setting").select("vercel_token_encrypted").maybeSingle();
+    const settingsRows = await db.execute(sql`
+      SELECT vercel_token_encrypted FROM app_setting LIMIT 1
+    `);
+    const settings = settingsRows[0];
     if (!settings?.vercel_token_encrypted) return "Vercel sync skipped: no Vercel token configured";
     let token;
     try {
@@ -1785,7 +2570,12 @@ async function attemptVercelSync(appName, environment, knownStageId) {
     } catch {
       return "Vercel sync failed: could not decrypt Vercel token";
     }
-    const { data: stage } = await supabase.from("release_profile_stage").select("id, stage, stage_apps").eq("id", stageId).single();
+    const stageRows = await db.execute(sql`
+      SELECT id, stage, stage_apps FROM release_profile_stage
+      WHERE id = ${stageId}
+      LIMIT 1
+    `);
+    const stage = stageRows[0];
     if (!stage) return "Vercel sync skipped: stage not found";
     const stageType = stage.stage;
     const stageApps = stage.stage_apps || [];
@@ -1793,8 +2583,12 @@ async function attemptVercelSync(appName, environment, knownStageId) {
       (a) => a.deployMethod === "vercel" && a.enabled && a.vercelProjectId
     );
     if (vercelApps.length === 0) return "Vercel sync skipped: no Vercel apps in stage";
-    const { data: envConfigs } = await supabase.from("env_config").select("*").eq("release_profile_stage_id", stageId);
-    if (!envConfigs || envConfigs.length === 0) return "Vercel sync skipped: no env configs for stage";
+    const envConfigs = await db.execute(sql`
+      SELECT id, app_name, environment, variant, env_data_encrypted, release_profile_stage_id
+      FROM env_config
+      WHERE release_profile_stage_id = ${stageId}
+    `);
+    if (envConfigs.length === 0) return "Vercel sync skipped: no env configs for stage";
     const variantMap = {
       dev: "development",
       staging: "staging",
@@ -1877,8 +2671,14 @@ 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");
+  const rows = await db.execute(sql`
+    SELECT hostname, port, username, password_encrypted, ssh_key_encrypted, ssh_key_passphrase_encrypted
+    FROM ssh_server
+    WHERE id = ${SSH_PROXY_SERVER_ID}
+    LIMIT 1
+  `);
+  const data = rows[0];
+  if (!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,
@@ -1892,8 +2692,15 @@ async function getProxyConnection() {
 }
 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, allowed_ssh_ips, os_type").eq("id", serverId).single();
-  if (error || !data) {
+  const rows = await db.execute(sql`
+    SELECT hostname, port, username, password_encrypted, ssh_key_encrypted,
+           ssh_key_passphrase_encrypted, allowed_ssh_ips, os_type
+    FROM ssh_server
+    WHERE id = ${serverId}
+    LIMIT 1
+  `);
+  const data = rows[0];
+  if (!data) {
     const candidates = Array.from(KNOWN_SERVER_NAMES.values()).flatMap((s) => [s.name, s.id]);
     const hits = suggestSimilar(serverId, candidates);
     const hint = hits.length ? ` Did you mean: ${hits.join(", ")}?` : "";
@@ -2981,10 +3788,13 @@ async function resolveServerLabel(serverId, serverIds) {
   const cached = KNOWN_SERVER_NAMES.get(serverId);
   if (cached) return cached.name;
   try {
-    const { data } = await supabase.from("ssh_server").select("id, name").eq("id", serverId).maybeSingle();
-    if (data?.name) {
-      KNOWN_SERVER_NAMES.set(serverId, { id: serverId, name: data.name });
-      return data.name;
+    const rows = await db.execute(sql`
+      SELECT id, name FROM ssh_server WHERE id = ${serverId} LIMIT 1
+    `);
+    const name = rows[0]?.name;
+    if (name) {
+      KNOWN_SERVER_NAMES.set(serverId, { id: serverId, name });
+      return name;
     }
   } catch {
   }
@@ -3359,6 +4169,72 @@ done
 function escapeMysqlShell(value) {
   return value.replace(/'/g, "'\\''");
 }
+async function discoverPostgresContainers(conn, proxy) {
+  const script = `
+docker ps --format '{{.Names}}' 2>/dev/null | while IFS= read -r name; do
+  [ -n "$name" ] || continue
+  envs=$(docker exec "$name" env 2>/dev/null | grep -E '^POSTGRES_(USER|DB|PASSWORD)=' || true)
+  if [ -z "$envs" ]; then continue; fi
+  user=$(printf '%s\\n' "$envs" | grep '^POSTGRES_USER=' | head -n1 | cut -d= -f2-)
+  db=$(printf '%s\\n' "$envs" | grep '^POSTGRES_DB=' | head -n1 | cut -d= -f2-)
+  if printf '%s\\n' "$envs" | grep -q '^POSTGRES_PASSWORD='; then hp=1; else hp=0; fi
+  port=$(docker port "$name" 5432/tcp 2>/dev/null | head -n1 | awk -F: '{print $NF}')
+  echo "PG|$name|\${db:-postgres}|\${user:-postgres}|$hp|\${port:-}"
+done
+`.trim();
+  const result = await sshExec(conn, script, proxy);
+  const out = [];
+  for (const line of result.stdout.split("\n")) {
+    if (!line.startsWith("PG|")) continue;
+    const parts = line.split("|");
+    if (parts.length < 6) continue;
+    const [, container, db2, user, hasPass, hostPort] = parts;
+    if (!container) continue;
+    out.push({
+      container,
+      db: db2 || "postgres",
+      user: user || "postgres",
+      hostPort: hostPort || null,
+      hasPassword: hasPass === "1"
+    });
+  }
+  return out;
+}
+async function psqlInContainer(conn, proxy, containerName, dbUser, dbName, scriptSql, flags) {
+  const safeContainer = containerName.replace(/[^a-zA-Z0-9._-]/g, "");
+  const safeUser = dbUser.replace(/[^a-zA-Z0-9_-]/g, "") || "postgres";
+  const safeDb = dbName.replace(/[^a-zA-Z0-9_-]/g, "") || "postgres";
+  const cmd = `docker exec -i -e PGOPTIONS=--client-min-messages=warning ${safeContainer} psql -U ${safeUser} -d ${safeDb} -v ON_ERROR_STOP=1 -P pager=off ${flags}`;
+  const res = await sshExec(conn, cmd, proxy, { stdin: scriptSql });
+  return { stdout: res.stdout || "", stderr: res.stderr || "", exitCode: res.exitCode };
+}
+var MIGRATION_LEDGER_DDL = `
+CREATE TABLE IF NOT EXISTS _mcp_migrations (
+  name        TEXT PRIMARY KEY,
+  sha256      TEXT NOT NULL,
+  applied_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+  applied_by  TEXT
+);
+`.trim();
+function normaliseMigrationSql(sql4) {
+  return sql4.replace(/\r\n/g, "\n").trim() + "\n";
+}
+function migrationSha256(sql4) {
+  return createHash("sha256").update(normaliseMigrationSql(sql4), "utf8").digest("hex");
+}
+function dollarQuoteTag(value) {
+  let tag = "_mcp";
+  let i = 0;
+  while (value.includes(`$${tag}$`)) {
+    i += 1;
+    tag = `_mcp${i}`;
+  }
+  return tag;
+}
+function dollarQuote(value) {
+  const tag = dollarQuoteTag(value);
+  return `$${tag}$${value}$${tag}$`;
+}
 var BLOCKED_SQL_PATTERNS = [
   /\bDROP\s+DATABASE\b/i,
   /\bDROP\s+TABLE\b/i,
@@ -3522,6 +4398,28 @@ function formatDnsDiff(domain, before, after, change) {
   lines.push("", "Re-run without `dryRun: true` to apply.");
   return lines.join("\n");
 }
+function describeDnsCandidates(records, type, name, attemptedValue) {
+  const sameTypeAndName = records.filter((r) => r.type === type && r.name === name);
+  const fmt = (r) => `  - ${r.type.padEnd(6)} ${r.name.padEnd(30)} ttl=${String(r.ttl).padEnd(5)} ${r.value}`;
+  if (sameTypeAndName.length > 0) {
+    const lines = ["Current records with this type + name (use one of these values verbatim):"];
+    for (const r of sameTypeAndName.slice(0, 10)) lines.push(fmt(r));
+    if (sameTypeAndName.length > 10) lines.push(`  ...and ${sameTypeAndName.length - 10} more`);
+    lines.push(`(attempted value: ${attemptedValue})`);
+    return lines.join("\n");
+  }
+  const sameName = records.filter((r) => r.name === name);
+  if (sameName.length > 0) {
+    const types = [...new Set(sameName.map((r) => r.type))].sort().join(", ");
+    const lines = [
+      `No ${type} records exist for "${name}", but other records do (types: ${types}). Sample:`
+    ];
+    for (const r of sameName.slice(0, 10)) lines.push(fmt(r));
+    if (sameName.length > 10) lines.push(`  ...and ${sameName.length - 10} more`);
+    return lines.join("\n");
+  }
+  return `No records found at all for name "${name}". Run dns-list to inspect the zone.`;
+}
 async function mijnhostFetch(path, options = {}) {
   const key = requireMijnhostApiKey();
   const res = await fetch(`${MIJNHOST_BASE_URL}${path}`, {
@@ -3741,48 +4639,92 @@ var TOOLS = [
   },
   {
     name: "db-discover",
-    description: "Scan /var/www on a server for web applications (WordPress, PrestaShop, Laravel, .env) and list their database credentials. Use this first to find available sites before running other db-* tools.",
+    description: 'Discover databases available on an SSH server. Use this first to find what is reachable before running other db-* tools.\n\nModes (pass via `include` array, default `["www"]`):\n- `"www"` \u2014 scan `/var/www` for WordPress / PrestaShop / Laravel / generic .env apps. Returns sitePath, db name, user, host, port.\n- `"postgres-containers"` \u2014 enumerate running Docker containers that expose `POSTGRES_USER` / `POSTGRES_DB` env vars (vanilla `postgres:*` / `pgvector/*` images). Returns container name, db, user, host port mapping, and whether a password is set. Use the returned (container, db, user) tuple directly with `db-query containerName=\u2026` or `db-apply-migration`.\n\nPass multiple modes to scan in parallel: `{ include: ["www", "postgres-containers"] }`.',
     inputSchema: {
       type: "object",
       properties: {
-        serverId: { type: "string", description: "UUID of the SSH server" }
+        serverId: { type: "string", description: "UUID of the SSH server" },
+        include: {
+          type: "array",
+          description: 'Which discovery modes to run. Defaults to `["www"]` for back-compat. Add `"postgres-containers"` to enumerate vanilla Postgres Docker containers with their credentials.',
+          items: { type: "string", enum: ["www", "postgres-containers"] }
+        }
       },
       required: ["serverId"]
     }
   },
   {
     name: "db-tables",
-    description: "List all tables in a site database with row counts and sizes. Credentials are auto-discovered from the site config files (wp-config.php, parameters.php, .env).",
+    description: "List tables with row counts + sizes. Two routing modes:\n- MySQL via `/var/www` autodiscover: pass `sitePath`. Credentials are read from wp-config.php / parameters.php / .env.\n- Postgres container: pass `containerName` (and optionally `dbName` / `dbUser`, defaulting to `postgres`). Returns one row per user table sorted by total size, with estimated row count from pg_class.reltuples.",
     inputSchema: {
       type: "object",
       properties: {
         serverId: { type: "string", description: "UUID of the SSH server" },
-        sitePath: { type: "string", description: "Site root path (e.g. /var/www/example.com)" }
+        sitePath: { type: "string", description: "Site root path (e.g. /var/www/example.com). MySQL autodiscover mode." },
+        containerName: { type: "string", description: "Postgres container name. Activates direct Postgres mode." },
+        dbName: { type: "string", description: 'Database name (containerName mode, defaults to "postgres")' },
+        dbUser: { type: "string", description: 'Database user (containerName mode, defaults to "postgres")' }
       },
-      required: ["serverId", "sitePath"]
+      required: ["serverId"]
     }
   },
   {
     name: "db-query",
-    description: 'Execute a SQL query against any database. Two routing modes:\n- MySQL via `/var/www` autodiscover (default): pass `sitePath` (and `engine: "mysql"` implicitly). Credentials are read from wp-config.php, parameters.php, .env. Same behaviour as before.\n- Direct via Docker container: pass `containerName` (the container running the DB server). Engine defaults to `postgres`; pass `engine: "mysql"` or `"mssql"` to override. The query is piped via stdin so quotes / `$` / `;` are never re-interpreted.\n\nPostgres example: `{ serverId, containerName: "supabase-db", engine: "postgres", dbName: "main", dbUser: "postgres", query: "SELECT 1" }`. Defaults: dbUser=postgres, dbName=postgres.\nMSSQL example: `{ serverId, containerName: "mssql-1", engine: "mssql", dbUser: "sa", dbPass: "...", query: "SELECT 1" }`.\n\nResult safety: `maxRows` (default 1000, max 10000) auto-injects a `LIMIT` for SELECT queries that don\'t have one, so unbounded scans never blow up the token budget. The footer reports whether the cap was applied. Pass `maxRows: 0` to disable.\n\nDiagnostics: `explain: true` prepends EXPLAIN (postgres / mysql) or runs `SET SHOWPLAN_TEXT ON` (mssql) so you can inspect the query plan without rewriting the query.\n\nSchema introspection: pass `describe: "tablename"` to get columns + indexes (replaces the old db-describe tool, works for mysql, postgres, and mssql). Pass `describe: "*"` to list all tables in the current database. When `describe` is set, `query` is ignored.\n\nDestructive operations (DROP, TRUNCATE, etc.) are blocked.',
+    description: 'Execute SQL against any database. **Use this for ALL queries (SELECT, INSERT, UPDATE, DELETE, schema introspection) against vanilla Postgres / MySQL / MSSQL containers** \u2014 do NOT fall back to `ssh-execute` + `docker cp` + `psql -f` with .tmp.sql files; the container path here already pipes via stdin so quotes / `$` / `;` are safe. Multi-statement scripts work fine: separate with `;` and they will all be executed by psql/mysql.\n\nTwo routing modes:\n- MySQL via `/var/www` autodiscover (default): pass `sitePath` (and `engine: "mysql"` implicitly). Credentials are read from wp-config.php, parameters.php, .env.\n- Direct via Docker container: pass `containerName` (the container running the DB server). Engine defaults to `postgres`; pass `engine: "mysql"` or `"mssql"` to override. Use `db-discover include=["postgres-containers"]` to find available containers + creds.\n\nPostgres example: `{ serverId, containerName: "refront-postgres-vanilla", dbName: "main", dbUser: "postgres", query: "SELECT 1" }`. Defaults: dbUser=postgres, dbName=postgres.\nMSSQL example: `{ serverId, containerName: "mssql-1", engine: "mssql", dbUser: "sa", dbPass: "...", query: "SELECT 1" }`.\n\nResult safety: `maxRows` (default 1000, max 10000) auto-injects a `LIMIT` for SELECT queries that don\'t have one. The footer reports whether the cap was applied. Pass `maxRows: 0` to disable.\n\nDiagnostics: `explain: true` prepends EXPLAIN (postgres / mysql) or runs `SET SHOWPLAN_TEXT ON` (mssql).\n\nSchema introspection: pass `describe: "tablename"` to get columns + indexes (works for mysql, postgres, and mssql). Pass `describe: "*"` to list all tables. When `describe` is set, `query` is ignored.\n\nDestructive operations (DROP, TRUNCATE, ALTER \u2026 DROP, naked DELETE) are blocked by default. For schema migrations, **prefer `db-apply-migration`** \u2014 it has an audit ledger and idempotency. As an escape hatch for ad-hoc hot-fixes, pass `allowDestructive: "yes-i-understand-this-is-not-logged"` (literal string) to bypass the gate. The bypass is logged in the response footer.',
     inputSchema: {
       type: "object",
       properties: {
         serverId: { type: "string", description: "UUID of the SSH server" },
-        query: { type: "string", description: "SQL query to execute (ignored when describe is set)" },
+        query: { type: "string", description: "SQL query to execute (ignored when describe is set). Multiple statements separated by `;` are piped together to the client." },
         describe: { type: "string", description: 'Schema introspection shortcut. Pass a table name for columns + indexes, or "*" to list all tables. Works for mysql / postgres / mssql.' },
         sitePath: { type: "string", description: "Site root path (e.g. /var/www/example.com). Used only with engine=mysql autodiscover." },
-        containerName: { type: "string", description: 'Docker container running the DB server (e.g. "supabase-db", "trigger-postgres"). Activates direct-query mode.' },
+        containerName: { type: "string", description: 'Docker container running the DB server (e.g. "refront-postgres-vanilla", "supabase-db"). Activates direct-query mode.' },
         engine: { type: "string", enum: ["mysql", "postgres", "mssql"], description: 'DB engine. Defaults to "mysql" with sitePath, "postgres" with containerName.' },
         dbName: { type: "string", description: 'Database name (containerName mode). Defaults: postgres \u2192 "postgres", mysql \u2192 server default, mssql \u2192 server default.' },
         dbUser: { type: "string", description: 'Database user (containerName mode). Defaults: postgres \u2192 "postgres", mysql \u2192 "root", mssql \u2192 "sa".' },
         dbPass: { type: "string", description: "Database password (containerName mode). Required for mssql; optional for mysql; postgres uses trust auth by default." },
         maxRows: { type: "number", description: "Auto-inject LIMIT for unbounded SELECTs. Default 1000, max 10000, set 0 to disable." },
-        explain: { type: "boolean", description: "Prepend EXPLAIN (postgres/mysql) or SHOWPLAN (mssql) instead of executing. Useful for slow-query diagnosis." }
+        explain: { type: "boolean", description: "Prepend EXPLAIN (postgres/mysql) or SHOWPLAN (mssql) instead of executing. Useful for slow-query diagnosis." },
+        allowDestructive: { type: "string", description: 'Escape hatch for ad-hoc DROP/TRUNCATE/ALTER\u2026DROP/naked DELETE. Pass the literal string "yes-i-understand-this-is-not-logged". For schema migrations prefer db-apply-migration (audit-logged, idempotent).' }
       },
       required: ["serverId"]
     }
   },
+  {
+    name: "db-apply-migration",
+    description: 'Apply a SQL migration to a Postgres container and record it in an MCP-managed ledger table (`_mcp_migrations`) so re-runs are idempotent. Use this for ALL schema changes (CREATE/ALTER/DROP/TRUNCATE) \u2014 it allows DDL that `db-query` blocks, and gives you audit + drift detection in exchange.\n\nLedger schema (auto-created on first call): `_mcp_migrations(name TEXT PRIMARY KEY, sha256 TEXT, applied_at TIMESTAMPTZ, applied_by TEXT)`.\n\nBehaviour:\n- If `name` is already in the ledger AND the sha256 of the supplied SQL matches \u2192 no-op, returns "already applied".\n- If `name` is already in the ledger with a DIFFERENT sha256 \u2192 fails loudly ("drift detected"). Pass `force: true` to overwrite (logged).\n- Otherwise the SQL is wrapped in BEGIN/COMMIT and applied, then a row is inserted into `_mcp_migrations`.\n\nPass `noTransaction: true` for statements that cannot run inside a transaction (`CREATE INDEX CONCURRENTLY`, `ALTER TYPE \u2026 ADD VALUE`, `VACUUM`, etc.). In that mode the user SQL runs first and the ledger is recorded in a separate follow-up call.\n\nSQL source: provide ONE of `sql` (inline string), `localFile` (path on this machine, read and piped via stdin), or `remoteFile` (absolute path on the SSH server, read with `cat` first).\n\nExample: `{ serverId, containerName: "refront-postgres-vanilla", dbName: "main", name: "20260517120000_add_unified_classification", localFile: "./migrations/20260517120000_add_unified_classification.sql" }`.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        serverId: { type: "string", description: "UUID of the SSH server" },
+        containerName: { type: "string", description: 'Postgres container name (e.g. "refront-postgres-vanilla")' },
+        dbName: { type: "string", description: 'Database (defaults to "postgres" \u2014 set explicitly to your app DB)' },
+        dbUser: { type: "string", description: 'User (defaults to "postgres")' },
+        name: { type: "string", description: "Unique migration name (recommended format: `YYYYMMDDhhmmss_description`)" },
+        sql: { type: "string", description: "Inline SQL string (mutually exclusive with localFile / remoteFile)" },
+        localFile: { type: "string", description: "Path on this machine to a .sql file (read here, streamed via stdin)" },
+        remoteFile: { type: "string", description: "Absolute path of a .sql file already on the server (read with `cat`)" },
+        noTransaction: { type: "boolean", description: "Skip the implicit BEGIN/COMMIT wrapper. Required for CONCURRENTLY / ALTER TYPE ADD VALUE / VACUUM. Default false." },
+        force: { type: "boolean", description: "Re-apply even when the ledger says it ran with a different sha256. Use after a deliberate edit; logged in the response." }
+      },
+      required: ["serverId", "containerName", "name"]
+    }
+  },
+  {
+    name: "db-list-migrations",
+    description: 'List entries from the `_mcp_migrations` ledger on a Postgres container. Answers "what migrations have already been applied here?" without having to write SQL. Returns name, sha256 (truncated), applied_at, applied_by, ordered by most recent first. If the ledger table does not exist yet (no migrations applied via db-apply-migration), returns an empty list.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        serverId: { type: "string", description: "UUID of the SSH server" },
+        containerName: { type: "string", description: "Postgres container name" },
+        dbName: { type: "string", description: 'Database (defaults to "postgres")' },
+        dbUser: { type: "string", description: 'User (defaults to "postgres")' },
+        limit: { type: "number", description: "Max number of entries (default 50, max 500)" }
+      },
+      required: ["serverId", "containerName"]
+    }
+  },
   {
     name: "env-list",
     description: "List all stored environment configurations with their release profile names.",
@@ -3878,9 +4820,11 @@ var TOOLS = [
   // ----- Trigger.dev -----
   ...TRIGGER_TOOLS,
   // ----- Vercel -----
-  ...VERCEL_TOOLS
+  ...VERCEL_TOOLS,
+  // ----- Repo reference -----
+  ...REPO_TOOLS
 ];
-var MCP_VERSION = "6.0.1";
+var MCP_VERSION = "6.1.0";
 async function handleListTools() {
   if (!authContext) return { tools: TOOLS };
   const accessible = TOOLS.filter((tool) => {
@@ -3945,14 +4889,18 @@ async function executeToolCall(name, a, _serverId) {
     switch (name) {
       // ----- Servers -----
       case "list-servers": {
-        let query = supabase.from("ssh_server").select("id, name, hostname, port, username, tags, hosted_by, os_type, created_at").order("name");
-        if (ctx.allowedServerIds !== null) {
-          query = query.in("id", ctx.allowedServerIds);
-        }
-        const { data, error } = await query;
-        if (error) throw new Error(error.message);
+        const data = ctx.allowedServerIds !== null ? await db.execute(sql`
+              SELECT id, name, hostname, port, username, tags, hosted_by, os_type, created_at
+              FROM ssh_server
+              WHERE id = ANY(${ctx.allowedServerIds}::uuid[])
+              ORDER BY name
+            `) : await db.execute(sql`
+              SELECT id, name, hostname, port, username, tags, hosted_by, os_type, created_at
+              FROM ssh_server
+              ORDER BY name
+            `);
         const includeStats = a.includeStats === true;
-        const servers = data || [];
+        const servers = data;
         rememberServers(servers.map((s) => ({ id: s.id, name: s.name })));
         let statsByServer = /* @__PURE__ */ new Map();
         if (includeStats && servers.length > 0) {
@@ -4080,8 +5028,10 @@ ${contextHints.join("\n")}` : out }] };
             const last = iterations[iterations.length - 1].result;
             let serverName2 = serverId;
             try {
-              const { data } = await supabase.from("ssh_server").select("name").eq("id", serverId).maybeSingle();
-              if (data?.name) serverName2 = data.name;
+              const nameRows = await db.execute(
+                sql`SELECT name FROM ssh_server WHERE id = ${serverId} LIMIT 1`
+              );
+              if (nameRows[0]?.name) serverName2 = nameRows[0].name;
             } catch {
             }
             return { serverId, serverName: serverName2, os, shell, result: last, iterations };
@@ -4096,8 +5046,10 @@ ${contextHints.join("\n")}` : out }] };
           }
           let serverName = serverId;
           try {
-            const { data } = await supabase.from("ssh_server").select("name").eq("id", serverId).maybeSingle();
-            if (data?.name) serverName = data.name;
+            const nameRows = await db.execute(
+              sql`SELECT name FROM ssh_server WHERE id = ${serverId} LIMIT 1`
+            );
+            if (nameRows[0]?.name) serverName = nameRows[0].name;
           } catch {
           }
           return { serverId, serverName, os, shell, result, pipelineSegments };
@@ -4829,19 +5781,66 @@ ${trail.join("\n")}` }] };
       // ----- Database -----
       case "db-discover": {
         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/" }] };
+        const rawInclude = Array.isArray(a.include) ? a.include.map(String) : ["www"];
+        const include = new Set(rawInclude.filter((m) => m === "www" || m === "postgres-containers"));
+        if (include.size === 0) include.add("www");
+        const sections = [];
+        if (include.has("www")) {
+          const sites = await discoverSiteDatabases(conn, proxy);
+          if (!sites.length) {
+            sections.push("## /var/www\n(none)");
+          } else {
+            const lines = sites.map(
+              (s) => `${s.sitePath}  [${s.appType}]  db=${s.database}  user=${s.user}  host=${s.host}:${s.port}`
+            );
+            sections.push(`## /var/www (${sites.length})
+${lines.join("\n")}`);
+          }
         }
-        const lines = sites.map(
-          (s) => `${s.sitePath}  [${s.appType}]  db=${s.database}  user=${s.user}  host=${s.host}:${s.port}`
-        );
-        return { content: [{ type: "text", text: lines.join("\n") }] };
+        if (include.has("postgres-containers")) {
+          const containers = await discoverPostgresContainers(conn, proxy);
+          if (!containers.length) {
+            sections.push("## Postgres containers\n(none \u2014 no running container exposes POSTGRES_USER/POSTGRES_DB)");
+          } else {
+            const lines = containers.map(
+              (c) => `${c.container}  db=${c.db}  user=${c.user}  hostPort=${c.hostPort ?? "(internal-only)"}  password=${c.hasPassword ? "set" : "unset"}`
+            );
+            sections.push(`## Postgres containers (${containers.length})
+${lines.join("\n")}
+
+Tip: use these directly with \`db-query containerName=\u2026 dbName=\u2026 dbUser=\u2026\` or \`db-apply-migration\`.`);
+          }
+        }
+        return { content: [{ type: "text", text: sections.join("\n\n") }] };
       }
       case "db-tables": {
         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, proxy);
+        const containerName = typeof a.containerName === "string" && a.containerName ? a.containerName : "";
+        if (containerName) {
+          const dbUser = typeof a.dbUser === "string" && a.dbUser ? a.dbUser : "postgres";
+          const dbName = typeof a.dbName === "string" && a.dbName ? a.dbName : "postgres";
+          const sqlText2 = `SELECT n.nspname AS schema,
+       c.relname AS "table",
+       pg_size_pretty(pg_total_relation_size(c.oid)) AS size,
+       c.reltuples::bigint AS estimated_rows
+FROM pg_class c
+JOIN pg_namespace n ON n.oid = c.relnamespace
+WHERE c.relkind = 'r'
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+ORDER BY pg_total_relation_size(c.oid) DESC;
+`;
+          const res = await psqlInContainer(conn, proxy, containerName, dbUser, dbName, sqlText2, "");
+          const output2 = res.stdout.trim() || res.stderr.trim() || "(no output)";
+          if (res.exitCode !== 0 && !res.stdout) {
+            return { content: [{ type: "text", text: `Error (exit ${res.exitCode}): ${output2}` }] };
+          }
+          return { content: [{ type: "text", text: output2 || "No tables found" }] };
+        }
+        if (!a.sitePath) {
+          return { content: [{ type: "text", text: "Error: pass `sitePath` (MySQL autodiscover) or `containerName` (Postgres container)." }] };
+        }
+        const sqlText = "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), sqlText, proxy);
         return { content: [{ type: "text", text: output || "No tables found" }] };
       }
       case "db-query": {
@@ -4859,7 +5858,24 @@ ${trail.join("\n")}` }] };
           rawQuery = String(a.query ?? "").trim();
           if (!rawQuery) return { content: [{ type: "text", text: "Error: query (or describe) is required" }] };
         }
-        assertSafeSql(rawQuery);
+        const allowDestructivePhrase = "yes-i-understand-this-is-not-logged";
+        const allowDestructive = a.allowDestructive === allowDestructivePhrase;
+        if (!allowDestructive && !describeArg) {
+          try {
+            assertSafeSql(rawQuery);
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return {
+              content: [{
+                type: "text",
+                text: `${msg}
+
+For schema migrations use \`db-apply-migration\` \u2014 it allows DDL and records every change in the \`_mcp_migrations\` ledger for audit and idempotency.
+For a one-off ad-hoc destructive query, pass \`allowDestructive: "${allowDestructivePhrase}"\`.`
+              }]
+            };
+          }
+        }
         let query = rawQuery.replace(/;\s*$/, "");
         let appliedLimit = false;
         if (explainMode && !describeArg) {
@@ -4878,12 +5894,13 @@ LIMIT ${maxRows + 1}`;
             appliedLimit = true;
           }
         }
+        const destructiveBanner = allowDestructive ? "\n\n[allowDestructive] safety gate bypassed for this query \u2014 NOT recorded in any audit ledger. Consider db-apply-migration for repeatable schema changes." : "";
         if (!containerName && engine === "mysql") {
           if (!a.sitePath) return { content: [{ type: "text", text: "Error: sitePath is required for mysql autodiscover (or pass containerName + engine for direct DB queries)" }] };
           const { conn: conn2, proxy: proxy2 } = await getServerConnection(String(a.serverId));
           const output2 = await execSiteMysql(conn2, String(a.sitePath), query, proxy2);
           const footer2 = formatDbQueryFooter(output2, appliedLimit, maxRows, explainMode);
-          return { content: [{ type: "text", text: (output2 || "Query executed successfully (no output)") + footer2 }] };
+          return { content: [{ type: "text", text: (output2 || "Query executed successfully (no output)") + footer2 + destructiveBanner }] };
         }
         if (!containerName) {
           return { content: [{ type: "text", text: `Error: engine=${engine} requires containerName (the docker container running the DB server, e.g. "supabase-db" or "trigger-postgres")` }] };
@@ -4895,8 +5912,8 @@ LIMIT ${maxRows + 1}`;
         let stdinPayload;
         if (engine === "postgres") {
           const user = dbUser || "postgres";
-          const db = dbName || "postgres";
-          cmd = `docker exec -i ${containerName} psql -U ${user} -d ${db} -P pager=off`;
+          const db2 = dbName || "postgres";
+          cmd = `docker exec -i ${containerName} psql -U ${user} -d ${db2} -P pager=off`;
           stdinPayload = query.endsWith(";") ? query : `${query};`;
         } else if (engine === "mssql") {
           const user = dbUser || "sa";
@@ -4911,10 +5928,10 @@ GO
 `;
         } else {
           const user = dbUser || "root";
-          const db = dbName ? ` ${dbName}` : "";
+          const db2 = dbName ? ` ${dbName}` : "";
           const dbPass = typeof a.dbPass === "string" ? a.dbPass : "";
           const passArg = dbPass ? `-p${posixQuote(dbPass)} ` : "";
-          cmd = `docker exec -i ${containerName} mysql -t -u ${user} ${passArg}${db}`;
+          cmd = `docker exec -i ${containerName} mysql -t -u ${user} ${passArg}${db2}`;
           stdinPayload = query.endsWith(";") ? query : `${query};`;
         }
         const result = await sshExec(conn, cmd, proxy, { stdin: stdinPayload });
@@ -4923,38 +5940,233 @@ GO
           return { content: [{ type: "text", text: `Error (exit ${result.exitCode}, ${engine}): ${output}` }] };
         }
         const footer = formatDbQueryFooter(output, appliedLimit, maxRows, explainMode);
-        return { content: [{ type: "text", text: output + footer }] };
+        return { content: [{ type: "text", text: output + footer + destructiveBanner }] };
+      }
+      case "db-apply-migration": {
+        const containerName = String(a.containerName || "").replace(/[^a-zA-Z0-9._-]/g, "");
+        if (!containerName) return { content: [{ type: "text", text: "Error: containerName is required" }] };
+        const dbUser = (typeof a.dbUser === "string" && a.dbUser ? a.dbUser : "postgres").replace(/[^a-zA-Z0-9_-]/g, "") || "postgres";
+        const dbName = (typeof a.dbName === "string" && a.dbName ? a.dbName : "postgres").replace(/[^a-zA-Z0-9_-]/g, "") || "postgres";
+        const name2 = String(a.name || "").trim();
+        if (!name2) return { content: [{ type: "text", text: 'Error: name is required (e.g. "20260517120000_add_foo")' }] };
+        if (!/^[\w.@:+\-]+$/.test(name2) || name2.length > 200) {
+          return { content: [{ type: "text", text: "Error: name must be \u2264200 chars and contain only [A-Za-z0-9_.@:+-]" }] };
+        }
+        const noTransaction = a.noTransaction === true;
+        const force = a.force === true;
+        const sources = [
+          typeof a.sql === "string" && a.sql ? "sql" : null,
+          typeof a.localFile === "string" && a.localFile ? "localFile" : null,
+          typeof a.remoteFile === "string" && a.remoteFile ? "remoteFile" : null
+        ].filter((v) => v !== null);
+        if (sources.length !== 1) {
+          return { content: [{ type: "text", text: `Error: pass exactly one of \`sql\`, \`localFile\`, or \`remoteFile\` (got ${sources.length || "none"}: ${sources.join(", ") || "\u2014"})` }] };
+        }
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        let migrationSql;
+        if (typeof a.sql === "string" && a.sql) {
+          migrationSql = a.sql;
+        } else if (typeof a.localFile === "string" && a.localFile) {
+          const p = a.localFile;
+          if (!isAbsolute(p) && !p.startsWith("./") && !p.startsWith("../")) {
+            return { content: [{ type: "text", text: "Error: localFile must be an absolute path or start with ./ or ../" }] };
+          }
+          try {
+            migrationSql = await readFile(p, "utf8");
+          } catch (err) {
+            return { content: [{ type: "text", text: `Error reading localFile "${p}": ${err instanceof Error ? err.message : String(err)}` }] };
+          }
+        } else {
+          const remotePath = String(a.remoteFile);
+          if (!remotePath.startsWith("/")) {
+            return { content: [{ type: "text", text: "Error: remoteFile must be an absolute path on the SSH server" }] };
+          }
+          const catRes = await sshExec(conn, `cat ${posixQuote(remotePath)}`, proxy);
+          if (catRes.exitCode !== 0) {
+            return { content: [{ type: "text", text: `Error reading remoteFile "${remotePath}" on server: ${catRes.stderr || `exit ${catRes.exitCode}`}` }] };
+          }
+          migrationSql = catRes.stdout;
+        }
+        const normalised = normaliseMigrationSql(migrationSql);
+        if (!normalised.trim()) {
+          return { content: [{ type: "text", text: "Error: resolved SQL is empty" }] };
+        }
+        const sha = migrationSha256(migrationSql);
+        const probeSql = `${MIGRATION_LEDGER_DDL}
+SELECT sha256 FROM _mcp_migrations WHERE name = ${dollarQuote(name2)};
+`;
+        const probe = await psqlInContainer(conn, proxy, containerName, dbUser, dbName, probeSql, "-tA");
+        if (probe.exitCode !== 0) {
+          return { content: [{ type: "text", text: `Error initialising ledger on ${containerName} (${dbName}): ${probe.stderr || probe.stdout || `exit ${probe.exitCode}`}` }] };
+        }
+        const probeLines = probe.stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+        const existingSha = probeLines.length > 0 ? probeLines[probeLines.length - 1] : "";
+        if (existingSha && existingSha === sha) {
+          return {
+            content: [{
+              type: "text",
+              text: `[noop] Migration "${name2}" already applied on ${containerName}/${dbName} (sha256 matches).
+Ledger sha: ${sha.slice(0, 12)}\u2026`
+            }]
+          };
+        }
+        if (existingSha && existingSha !== sha && !force) {
+          return {
+            content: [{
+              type: "text",
+              text: `[drift] Migration "${name2}" exists in ledger with DIFFERENT sha256.
+  ledger sha: ${existingSha.slice(0, 12)}\u2026
+  new sha:    ${sha.slice(0, 12)}\u2026
+
+This usually means the migration file was edited after it was first applied. Inspect the differences and either revert the source file or call again with \`force: true\` to overwrite the ledger entry (the SQL will be re-executed).`
+            }]
+          };
+        }
+        const appliedBy = `${authContext.apiKeyName} (${authContext.roleName})`;
+        const ledgerInsert = `INSERT INTO _mcp_migrations (name, sha256, applied_by) VALUES (${dollarQuote(name2)}, ${dollarQuote(sha)}, ${dollarQuote(appliedBy)})
+ON CONFLICT (name) DO UPDATE SET sha256 = EXCLUDED.sha256, applied_at = now(), applied_by = EXCLUDED.applied_by;
+`;
+        if (noTransaction) {
+          const apply = await psqlInContainer(conn, proxy, containerName, dbUser, dbName, normalised, "");
+          if (apply.exitCode !== 0) {
+            return {
+              content: [{
+                type: "text",
+                text: `[failed] Migration "${name2}" did not apply cleanly (noTransaction=true, no ledger entry recorded).
+psql exit: ${apply.exitCode}
+` + (apply.stderr ? `--- stderr ---
+${apply.stderr}
+` : "") + (apply.stdout ? `--- stdout ---
+${apply.stdout}` : "")
+              }]
+            };
+          }
+          const record = await psqlInContainer(conn, proxy, containerName, dbUser, dbName, ledgerInsert, "");
+          if (record.exitCode !== 0) {
+            return {
+              content: [{
+                type: "text",
+                text: `[partial] Migration "${name2}" applied but ledger insert FAILED. Re-run with \`force: true\` after the issue is resolved.
+psql exit: ${record.exitCode}
+` + (record.stderr ? `--- stderr ---
+${record.stderr}
+` : "") + (record.stdout ? `--- stdout ---
+${record.stdout}` : "")
+              }]
+            };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: `[applied] "${name2}" on ${containerName}/${dbName} (noTransaction=true${existingSha ? ", force" : ""}).
+ledger sha: ${sha.slice(0, 12)}\u2026
+` + (apply.stdout ? `--- output ---
+${apply.stdout.trim()}` : "(no output)")
+            }]
+          };
+        }
+        const wrappedSql = `BEGIN;
+${normalised}
+${ledgerInsert}COMMIT;
+`;
+        const res = await psqlInContainer(conn, proxy, containerName, dbUser, dbName, wrappedSql, "");
+        if (res.exitCode !== 0) {
+          return {
+            content: [{
+              type: "text",
+              text: `[failed] Migration "${name2}" did not apply (transaction rolled back, ledger unchanged).
+psql exit: ${res.exitCode}
+` + (res.stderr ? `--- stderr ---
+${res.stderr}
+` : "") + (res.stdout ? `--- stdout ---
+${res.stdout}` : "")
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `[applied] "${name2}" on ${containerName}/${dbName}${existingSha ? " (forced overwrite)" : ""}.
+ledger sha: ${sha.slice(0, 12)}\u2026
+` + (res.stdout ? `--- output ---
+${res.stdout.trim()}` : "(no output)")
+          }]
+        };
+      }
+      case "db-list-migrations": {
+        const containerName = String(a.containerName || "").replace(/[^a-zA-Z0-9._-]/g, "");
+        if (!containerName) return { content: [{ type: "text", text: "Error: containerName is required" }] };
+        const dbUser = (typeof a.dbUser === "string" && a.dbUser ? a.dbUser : "postgres").replace(/[^a-zA-Z0-9_-]/g, "") || "postgres";
+        const dbName = (typeof a.dbName === "string" && a.dbName ? a.dbName : "postgres").replace(/[^a-zA-Z0-9_-]/g, "") || "postgres";
+        const limitRaw = Number(a.limit);
+        const limit = Math.min(Math.max(Number.isFinite(limitRaw) && limitRaw > 0 ? Math.floor(limitRaw) : 50, 1), 500);
+        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const sqlText = `DO $$ BEGIN IF NOT EXISTS (SELECT 1 FROM pg_class WHERE relname = '_mcp_migrations') THEN RAISE NOTICE 'NO_LEDGER'; END IF; END $$;
+SELECT name, substr(sha256, 1, 12) || '\u2026' AS sha, applied_at, applied_by
+FROM _mcp_migrations
+ORDER BY applied_at DESC
+LIMIT ${limit};
+`;
+        const res = await psqlInContainer(conn, proxy, containerName, dbUser, dbName, sqlText, "");
+        if (res.exitCode !== 0) {
+          if (/relation "_mcp_migrations" does not exist/.test(res.stderr) || /relation "_mcp_migrations" does not exist/.test(res.stdout)) {
+            return { content: [{ type: "text", text: `No \`_mcp_migrations\` ledger on ${containerName}/${dbName} yet. Apply your first migration with \`db-apply-migration\` to create it.` }] };
+          }
+          return { content: [{ type: "text", text: `Error (exit ${res.exitCode}): ${res.stderr || res.stdout}` }] };
+        }
+        const output = res.stdout.trim();
+        return { content: [{ type: "text", text: output || `Ledger exists on ${containerName}/${dbName} but is empty.` }] };
       }
       // ----- Env Config -----
       case "env-list": {
-        let query = supabase.from("env_config").select("id, app_name, environment, description, updated_at, release_profile_stage_id").order("app_name").order("environment");
+        let stageFilterIds = null;
         if (a.releaseProfile) {
           const { stageIds: stageIds2 } = await resolveReleaseProfileStageIds(String(a.releaseProfile));
-          query = query.in("release_profile_stage_id", stageIds2);
+          stageFilterIds = stageIds2;
         }
-        const { data, error } = await query;
-        if (error) throw new Error(error.message);
-        const stageIds = (data || []).map((e) => e.release_profile_stage_id).filter(Boolean);
+        const data = stageFilterIds ? await db.execute(sql`
+              SELECT id, app_name, environment, description, updated_at, release_profile_stage_id
+              FROM env_config
+              WHERE release_profile_stage_id = ANY(${stageFilterIds}::uuid[])
+              ORDER BY app_name, environment
+            `) : await db.execute(sql`
+              SELECT id, app_name, environment, description, updated_at, release_profile_stage_id
+              FROM env_config
+              ORDER BY app_name, environment
+            `);
+        const stageIds = data.map((e) => e.release_profile_stage_id).filter((v) => Boolean(v));
         const profileNames = await getProfileNamesForStageIds(stageIds);
-        const lines = (data || []).map((e) => {
+        const lines = data.map((e) => {
           const profile = e.release_profile_stage_id ? profileNames[e.release_profile_stage_id] || "unknown" : "unlinked";
           return `${e.app_name}/${e.environment}  [${profile}]  (updated: ${e.updated_at})`;
         });
         return { content: [{ type: "text", text: lines.length ? lines.join("\n") : "No environment configs stored" }] };
       }
       case "env-get": {
-        let query = supabase.from("env_config").select("env_data_encrypted, release_profile_stage_id").eq("app_name", String(a.appName)).eq("environment", String(a.environment));
+        const appName = String(a.appName);
+        const environment = String(a.environment);
+        let stageFilterIds = null;
         if (a.releaseProfile) {
           const { stageIds } = await resolveReleaseProfileStageIds(String(a.releaseProfile));
-          query = query.in("release_profile_stage_id", stageIds);
+          stageFilterIds = stageIds;
         }
-        const { data, error } = await query;
-        if (error) throw new Error(`Env config query failed: ${error.message}`);
-        if (!data || data.length === 0) {
+        const data = stageFilterIds ? await db.execute(sql`
+              SELECT env_data_encrypted, release_profile_stage_id
+              FROM env_config
+              WHERE app_name = ${appName}
+                AND environment = ${environment}
+                AND release_profile_stage_id = ANY(${stageFilterIds}::uuid[])
+            `) : await db.execute(sql`
+              SELECT env_data_encrypted, release_profile_stage_id
+              FROM env_config
+              WHERE app_name = ${appName}
+                AND environment = ${environment}
+            `);
+        if (data.length === 0) {
           throw new Error(`Env config not found: ${a.appName}/${a.environment}${a.releaseProfile ? ` (profile: ${a.releaseProfile})` : ""}`);
         }
         if (data.length > 1) {
-          const stageIds = data.map((r) => r.release_profile_stage_id).filter(Boolean);
+          const stageIds = data.map((r) => r.release_profile_stage_id).filter((v) => Boolean(v));
           const profileNames = await getProfileNamesForStageIds(stageIds);
           const names = [...new Set(Object.values(profileNames))].join(", ");
           throw new Error(
@@ -4973,45 +6185,56 @@ GO
           const { stageIds } = await resolveReleaseProfileStageIds(String(a.releaseProfile));
           resolvedStageIds = stageIds;
         }
-        let existQuery = supabase.from("env_config").select("id, release_profile_stage_id").eq("app_name", appName).eq("environment", environment);
-        if (resolvedStageIds) {
-          existQuery = existQuery.in("release_profile_stage_id", resolvedStageIds);
-        }
-        const { data: existingRows, error: existErr } = await existQuery;
-        if (existErr) throw new Error(`Lookup failed: ${existErr.message}`);
-        if (existingRows && existingRows.length > 1 && !resolvedStageIds) {
-          const stageIds = existingRows.map((r) => r.release_profile_stage_id).filter(Boolean);
+        const existingRows = resolvedStageIds ? await db.execute(sql`
+              SELECT id, release_profile_stage_id
+              FROM env_config
+              WHERE app_name = ${appName}
+                AND environment = ${environment}
+                AND release_profile_stage_id = ANY(${resolvedStageIds}::uuid[])
+            `) : await db.execute(sql`
+              SELECT id, release_profile_stage_id
+              FROM env_config
+              WHERE app_name = ${appName}
+                AND environment = ${environment}
+            `);
+        if (existingRows.length > 1 && !resolvedStageIds) {
+          const stageIds = existingRows.map((r) => r.release_profile_stage_id).filter((v) => Boolean(v));
           const profileNames = await getProfileNamesForStageIds(stageIds);
           const names = [...new Set(Object.values(profileNames))].join(", ");
           throw new Error(
             `Multiple env configs found for ${appName}/${environment} across profiles: ${names}. Pass releaseProfile parameter to select one.`
           );
         }
-        const existing = existingRows?.[0] ?? null;
+        const existing = existingRows[0] ?? null;
+        const description = a.description ? String(a.description) : null;
+        const updatedBy = authContext.userId;
         let saveMsg;
         if (existing) {
-          const { error } = await supabase.from("env_config").update({
-            env_data_encrypted: encrypted,
-            description: a.description ? String(a.description) : void 0,
-            updated_by: authContext.userId,
-            updated_at: (/* @__PURE__ */ new Date()).toISOString()
-          }).eq("id", existing.id);
-          if (error) throw new Error(error.message);
+          await db.execute(sql`
+            UPDATE env_config
+            SET env_data_encrypted = ${encrypted},
+                description = COALESCE(${description}, description),
+                updated_by = ${updatedBy},
+                updated_at = ${(/* @__PURE__ */ new Date()).toISOString()}
+            WHERE id = ${existing.id}
+          `);
           saveMsg = `Updated env config: ${appName}/${environment}`;
         } else {
-          const insertData = {
-            app_name: appName,
-            environment,
-            env_data_encrypted: encrypted,
-            description: a.description ? String(a.description) : null,
-            created_by: authContext.userId,
-            updated_by: authContext.userId
-          };
-          if (resolvedStageIds?.[0]) {
-            insertData.release_profile_stage_id = resolvedStageIds[0];
-          }
-          const { error } = await supabase.from("env_config").insert(insertData);
-          if (error) throw new Error(error.message);
+          const stageId = resolvedStageIds?.[0] ?? null;
+          await db.execute(sql`
+            INSERT INTO env_config (
+              app_name, environment, env_data_encrypted, description,
+              created_by, updated_by, release_profile_stage_id
+            ) VALUES (
+              ${appName},
+              ${environment},
+              ${encrypted},
+              ${description},
+              ${updatedBy},
+              ${updatedBy},
+              ${stageId}
+            )
+          `);
           saveMsg = `Stored env config: ${appName}/${environment}`;
         }
         const syncStageId = existing?.release_profile_stage_id ?? resolvedStageIds?.[0];
@@ -5227,7 +6450,10 @@ ${lines.join("\n")}` }] };
             (r) => r.type === type && r.name === dnsName && r.value === oldValue
           );
           if (idx === -1) {
-            throw new Error(`No matching DNS record found: ${type} ${dnsName} = ${oldValue}`);
+            throw new Error(
+              `No matching DNS record found: ${type} ${dnsName} = ${oldValue}
+` + describeDnsCandidates(current.data.records, type, dnsName, oldValue)
+            );
           }
           const updated = [...current.data.records];
           const before = updated[idx];
@@ -5251,7 +6477,10 @@ ${lines.join("\n")}` }] };
             (r) => !(r.type === type && r.name === dnsName && r.value === value)
           );
           if (removed.length === 0) {
-            throw new Error(`No matching DNS record found: ${type} ${dnsName} = ${value}`);
+            throw new Error(
+              `No matching DNS record found: ${type} ${dnsName} = ${value}
+` + describeDnsCandidates(current.data.records, type, dnsName, value)
+            );
           }
           nextRecords = remaining;
           diffArgs = { verb: "delete", removed };
@@ -5272,7 +6501,10 @@ ${lines.join("\n")}` }] };
           return handleTriggerTool(name, a, { sshExec, getServerConnection });
         }
         if (VERCEL_TOOL_NAMES.has(name)) {
-          return handleVercelTool(name, a, { supabase, decrypt });
+          return handleVercelTool(name, a, { db, decrypt });
+        }
+        if (REPO_TOOL_NAMES.has(name)) {
+          return handleRepoTool(name, a, { db, sshExec, getServerConnection });
         }
         return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
     }