@mgsoftwarebv/mg-dashboard-mcp 3.10.1 → 3.11.0

package/dist/index.js

@@ -14,7 +14,7 @@ import { createClient } from '@supabase/supabase-js';
 import { readFile, mkdtemp, writeFile, rm } from 'fs/promises';
 import { tmpdir } from 'os';
 import { Client } from 'ssh2';
-import { ListObjectsV2Command, DeleteObjectsCommand, DeleteObjectCommand, CreateMultipartUploadCommand, UploadPartCommand, CompleteMultipartUploadCommand, AbortMultipartUploadCommand, PutObjectCommand, HeadObjectCommand, GetObjectCommand, S3Client } from '@aws-sdk/client-s3';
+import { HeadObjectCommand, S3Client, ListObjectsV2Command, DeleteObjectsCommand, DeleteObjectCommand, CreateMultipartUploadCommand, UploadPartCommand, CompleteMultipartUploadCommand, AbortMultipartUploadCommand, PutObjectCommand, GetObjectCommand, CopyObjectCommand } from '@aws-sdk/client-s3';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -1373,6 +1373,7 @@ var TOOL_MODULE_MAP = {
   "docker-logs": "ssh_servers",
   "docker-exec": "ssh_servers",
   "docker-compose": "ssh_servers",
+  "wait-for": "ssh_servers",
   "db-discover": "ssh_servers",
   "db-tables": "ssh_servers",
   "db-describe": "ssh_servers",
@@ -1861,7 +1862,12 @@ 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) throw new Error(`Server not found: ${serverId}`);
+  if (error || !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(", ")}?` : "";
+    throw new Error(`Server not found: ${serverId}.${hint}`);
+  }
   if (!encryptionKey) throw new Error("ENCRYPTION_KEY required to decrypt server credentials");
   const conn = {
     hostname: data.hostname,
@@ -1877,42 +1883,73 @@ async function getServerConnection(serverId) {
   return { conn, proxy, os };
 }
 async function sshExec(opts, command, proxy, options) {
+  const first = await sshExecOnce(opts, command, proxy, options);
+  if (options?.noRetry) return first;
+  if (!isTransientSshError(first.stderr, first.exitCode)) return first;
+  await new Promise((r) => setTimeout(r, 1e3));
+  const second = await sshExecOnce(opts, command, proxy, options);
+  if (second.exitCode === -1 && second.stderr) {
+    second.stderr = `[retry-1 also failed] ${second.stderr}`;
+  }
+  return second;
+}
+async function sshExecOnce(opts, command, proxy, options) {
   if (proxy) return sshExecViaProxy(proxy, opts, command, options);
   return new Promise((resolve) => {
     const ssh = new Client();
     let stdout = "";
     let stderr = "";
     let done = false;
-    const timeout = opts.timeout || 6e4;
-    const timer = setTimeout(() => {
+    const wallTimeout = opts.timeout || 6e4;
+    const idleTimeout = options?.idleTimeoutMs;
+    const wallTimer = setTimeout(() => {
       if (!done) {
         done = true;
+        clearTimeout(idleTimer);
         ssh.end();
-        resolve({ stdout, stderr, exitCode: -1 });
+        resolve({ stdout, stderr: stderr || `idle/wall timeout after ${wallTimeout}ms`, exitCode: -1 });
       }
-    }, timeout);
+    }, wallTimeout);
+    let idleTimer;
+    const armIdle = () => {
+      if (!idleTimeout) return;
+      if (idleTimer) clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        if (!done) {
+          done = true;
+          clearTimeout(wallTimer);
+          ssh.end();
+          resolve({ stdout, stderr: stderr || `idle timeout after ${idleTimeout}ms with no output`, exitCode: -1 });
+        }
+      }, idleTimeout);
+    };
+    armIdle();
     ssh.on("ready", () => {
       const execOpts = options?.pty ? { pty: true } : {};
       ssh.exec(command, execOpts, (err, stream) => {
         if (err) {
           if (!done) {
             done = true;
-            clearTimeout(timer);
+            clearTimeout(wallTimer);
+            if (idleTimer) clearTimeout(idleTimer);
             ssh.end();
-            resolve({ stdout, stderr, exitCode: -1 });
+            resolve({ stdout, stderr: err.message || stderr, exitCode: -1 });
           }
           return;
         }
         stream.on("data", (d) => {
           stdout += d.toString();
+          armIdle();
         });
         stream.stderr.on("data", (d) => {
           stderr += d.toString();
+          armIdle();
         });
         stream.on("close", (code) => {
           if (!done) {
             done = true;
-            clearTimeout(timer);
+            clearTimeout(wallTimer);
+            if (idleTimer) clearTimeout(idleTimer);
             ssh.end();
             resolve({ stdout, stderr, exitCode: code ?? 0 });
           }
@@ -1925,7 +1962,8 @@ async function sshExec(opts, command, proxy, options) {
     ssh.on("error", (err) => {
       if (!done) {
         done = true;
-        clearTimeout(timer);
+        clearTimeout(wallTimer);
+        if (idleTimer) clearTimeout(idleTimer);
         resolve({ stdout, stderr: err.message, exitCode: -1 });
       }
     });
@@ -1936,7 +1974,7 @@ async function sshExec(opts, command, proxy, options) {
       password: opts.password,
       privateKey: opts.privateKey,
       passphrase: opts.passphrase,
-      readyTimeout: timeout
+      readyTimeout: wallTimeout
     });
   });
 }
@@ -1944,16 +1982,35 @@ function sshExecViaProxy(proxyOpts, targetOpts, command, options) {
   return new Promise((resolve) => {
     const proxyClient = new Client();
     let done = false;
-    const timeout = targetOpts.timeout || 6e4;
-    const timer = setTimeout(() => {
+    const wallTimeout = targetOpts.timeout || 6e4;
+    const idleTimeout = options?.idleTimeoutMs;
+    const wallTimer = setTimeout(() => {
       if (!done) {
         done = true;
+        clearTimeout(idleTimer);
         proxyClient.end();
         resolve({ stdout: "", stderr: "SSH proxy command timeout", exitCode: -1 });
       }
-    }, timeout);
+    }, wallTimeout);
+    let idleTimer;
+    let stdoutBuf = "";
+    let stderrBuf = "";
+    const armIdle = () => {
+      if (!idleTimeout) return;
+      if (idleTimer) clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        if (!done) {
+          done = true;
+          clearTimeout(wallTimer);
+          proxyClient.end();
+          resolve({ stdout: stdoutBuf, stderr: stderrBuf || `idle timeout after ${idleTimeout}ms with no output`, exitCode: -1 });
+        }
+      }, idleTimeout);
+    };
+    armIdle();
     const cleanup = () => {
-      clearTimeout(timer);
+      clearTimeout(wallTimer);
+      if (idleTimer) clearTimeout(idleTimer);
       proxyClient.end();
     };
     proxyClient.on("ready", () => {
@@ -1967,8 +2024,6 @@ function sshExecViaProxy(proxyOpts, targetOpts, command, options) {
           return;
         }
         const targetClient = new Client();
-        let stdout = "";
-        let stderr = "";
         targetClient.on("ready", () => {
           const execOpts = options?.pty ? { pty: true } : {};
           targetClient.exec(command, execOpts, (execErr, stream) => {
@@ -1977,22 +2032,24 @@ function sshExecViaProxy(proxyOpts, targetOpts, command, options) {
                 done = true;
                 targetClient.end();
                 cleanup();
-                resolve({ stdout, stderr, exitCode: -1 });
+                resolve({ stdout: stdoutBuf, stderr: stderrBuf, exitCode: -1 });
               }
               return;
             }
             stream.on("data", (d) => {
-              stdout += d.toString();
+              stdoutBuf += d.toString();
+              armIdle();
             });
             stream.stderr.on("data", (d) => {
-              stderr += d.toString();
+              stderrBuf += d.toString();
+              armIdle();
             });
             stream.on("close", (code) => {
               if (!done) {
                 done = true;
                 targetClient.end();
                 cleanup();
-                resolve({ stdout, stderr, exitCode: code ?? 0 });
+                resolve({ stdout: stdoutBuf, stderr: stderrBuf, exitCode: code ?? 0 });
               }
             });
             if (options?.stdin !== void 0) {
@@ -2005,7 +2062,7 @@ function sshExecViaProxy(proxyOpts, targetOpts, command, options) {
             done = true;
             targetClient.end();
             cleanup();
-            resolve({ stdout, stderr: targetErr.message, exitCode: -1 });
+            resolve({ stdout: stdoutBuf, stderr: targetErr.message, exitCode: -1 });
           }
         });
         targetClient.connect({
@@ -2014,7 +2071,7 @@ function sshExecViaProxy(proxyOpts, targetOpts, command, options) {
           password: targetOpts.password,
           privateKey: targetOpts.privateKey,
           passphrase: targetOpts.passphrase,
-          readyTimeout: timeout
+          readyTimeout: wallTimeout
         });
       });
     });
@@ -2149,52 +2206,89 @@ async function r2List(bucket, prefix, options) {
   } while (continuationToken && entries.length < options.maxResults);
   return entries;
 }
+function r2WrapError(bucket, key, e) {
+  const err = e;
+  const status = err?.$metadata?.httpStatusCode;
+  const name = err?.name || "";
+  if (name === "NoSuchKey" || name === "NotFound" || status === 404) {
+    return new Error(`r2://${bucket}/${key} not found`);
+  }
+  if (name === "NoSuchBucket") return new Error(`R2 bucket "${bucket}" not found`);
+  if (status === 403 || name === "AccessDenied") return new Error(`Access denied for r2://${bucket}/${key} (check R2_ACCESS_KEY_ID / R2_SECRET_ACCESS_KEY)`);
+  return new Error(`R2 error (${name || "unknown"}${status ? ` ${status}` : ""}): ${err?.message || String(e)}`);
+}
 async function r2GetObject(bucket, key, maxBytes) {
   const client = getR2Client();
-  const head = await client.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
-  const size = head.ContentLength || 0;
+  let size = 0;
+  try {
+    const head = await client.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
+    size = head.ContentLength || 0;
+  } catch (e) {
+    throw r2WrapError(bucket, key, e);
+  }
   if (size > maxBytes) {
     throw new Error(`Object too large: ${size} bytes (max ${maxBytes} for inline read; use sftp-write with sourcePath to mirror locally instead, or pass { offset, length } for a ranged read)`);
   }
-  const result = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
-  const body = result.Body;
-  if (!body?.transformToString) throw new Error("R2 returned no readable body");
-  return body.transformToString();
+  try {
+    const result = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    const body = result.Body;
+    if (!body?.transformToString) throw new Error("R2 returned no readable body");
+    return await body.transformToString();
+  } catch (e) {
+    throw r2WrapError(bucket, key, e);
+  }
 }
 async function r2GetObjectRange(bucket, key, range) {
   const client = getR2Client();
-  const head = await client.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
-  const size = head.ContentLength || 0;
+  let size = 0;
+  try {
+    const head = await client.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
+    size = head.ContentLength || 0;
+  } catch (e) {
+    throw r2WrapError(bucket, key, e);
+  }
   if (range.offset >= size && size > 0) throw new Error(`offset ${range.offset} is past end of object (size ${size})`);
   const MAX = 1048576;
   const remaining = Math.max(0, size - range.offset);
   const effectiveLen = range.length !== void 0 ? Math.min(range.length, remaining, MAX) : Math.min(remaining, MAX);
   const end = range.offset + effectiveLen - 1;
-  const result = await client.send(new GetObjectCommand({
-    Bucket: bucket,
-    Key: key,
-    Range: `bytes=${range.offset}-${end}`
-  }));
-  const body = result.Body;
-  if (!body?.transformToString) throw new Error("R2 returned no readable body");
-  const text = await body.transformToString();
-  const header = `# range: bytes ${range.offset}-${end} of ${size} (${effectiveLen} bytes)`;
-  return `${header}
+  try {
+    const result = await client.send(new GetObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      Range: `bytes=${range.offset}-${end}`
+    }));
+    const body = result.Body;
+    if (!body?.transformToString) throw new Error("R2 returned no readable body");
+    const text = await body.transformToString();
+    const header = `# range: bytes ${range.offset}-${end} of ${size} (${effectiveLen} bytes)`;
+    return `${header}
 ${text}`;
+  } catch (e) {
+    throw r2WrapError(bucket, key, e);
+  }
 }
 async function r2PutObject(bucket, key, body, contentLength) {
   const client = getR2Client();
-  await client.send(new PutObjectCommand({
-    Bucket: bucket,
-    Key: key,
-    Body: body,
-    ContentLength: contentLength,
-    ContentType: "application/octet-stream"
-  }));
+  try {
+    await client.send(new PutObjectCommand({
+      Bucket: bucket,
+      Key: key,
+      Body: body,
+      ContentLength: contentLength,
+      ContentType: "application/octet-stream"
+    }));
+  } catch (e) {
+    throw r2WrapError(bucket, key, e);
+  }
 }
 async function r2DeleteObject(bucket, key) {
   const client = getR2Client();
-  await client.send(new DeleteObjectCommand({ Bucket: bucket, Key: key }));
+  try {
+    await client.send(new DeleteObjectCommand({ Bucket: bucket, Key: key }));
+  } catch (e) {
+    throw r2WrapError(bucket, key, e);
+  }
 }
 async function r2DeletePrefix(bucket, prefix) {
   const client = getR2Client();
@@ -2270,6 +2364,44 @@ async function r2PutObjectMultipart(bucket, key, localPath, totalBytes, onProgre
     throw e;
   }
 }
+async function r2CopyObject(srcBucket, srcKey, dstBucket, dstKey) {
+  const client = getR2Client();
+  let size = 0;
+  try {
+    const head = await client.send(new HeadObjectCommand({ Bucket: srcBucket, Key: srcKey }));
+    size = head.ContentLength || 0;
+  } catch (e) {
+    throw r2WrapError(srcBucket, srcKey, e);
+  }
+  try {
+    await client.send(new CopyObjectCommand({
+      CopySource: encodeURIComponent(`${srcBucket}/${srcKey}`).replace(/%2F/g, "/"),
+      Bucket: dstBucket,
+      Key: dstKey
+    }));
+  } catch (e) {
+    throw r2WrapError(dstBucket, dstKey, e);
+  }
+  return { size };
+}
+async function r2GetObjectStream(bucket, key) {
+  const client = getR2Client();
+  let size = 0;
+  try {
+    const head = await client.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
+    size = head.ContentLength || 0;
+  } catch (e) {
+    throw r2WrapError(bucket, key, e);
+  }
+  try {
+    const result = await client.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    const body = result.Body;
+    if (!body) throw new Error("R2 returned no readable body");
+    return { stream: body, size };
+  } catch (e) {
+    throw r2WrapError(bucket, key, e);
+  }
+}
 function sanitizePath(path) {
   let normalized = path.replace(/\\/g, "/").replace(/\0/g, "");
   const parts = normalized.split("/");
@@ -2464,6 +2596,368 @@ function formatBytes(bytes) {
   if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
   return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
 }
+var RESPONSE_MAX_BYTES = 8192;
+var NO_FOOTER_TOOLS = /* @__PURE__ */ new Set();
+var TOOL_CACHE_TTL_MS = {
+  "list-servers": 6e4,
+  "docker-list": 3e4
+};
+var TOOL_CACHE = /* @__PURE__ */ new Map();
+function cacheKeyFor(name, args2) {
+  const { noCache: _ignored, ...rest } = args2;
+  const sorted = Object.fromEntries(Object.entries(rest).sort(([a], [b]) => a.localeCompare(b)));
+  return `${name}::${JSON.stringify(sorted)}`;
+}
+function getCachedTool(name, args2) {
+  const ttl = TOOL_CACHE_TTL_MS[name];
+  if (!ttl || ttl <= 0) return void 0;
+  if (args2.noCache === true) return void 0;
+  const k = cacheKeyFor(name, args2);
+  const e = TOOL_CACHE.get(k);
+  if (!e) return void 0;
+  if (e.expiresAt < Date.now()) {
+    TOOL_CACHE.delete(k);
+    return void 0;
+  }
+  return e.value;
+}
+function setCachedTool(name, args2, value) {
+  const ttl = TOOL_CACHE_TTL_MS[name];
+  if (!ttl || ttl <= 0) return;
+  if (args2.noCache === true) return;
+  TOOL_CACHE.set(cacheKeyFor(name, args2), { value, expiresAt: Date.now() + ttl });
+}
+function levenshtein(a, b) {
+  if (a === b) return 0;
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  const dp = new Array(n + 1);
+  for (let j = 0; j <= n; j++) dp[j] = j;
+  for (let i = 1; i <= m; i++) {
+    let prev = dp[0];
+    dp[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const tmp = dp[j];
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[j] = Math.min(dp[j] + 1, dp[j - 1] + 1, prev + cost);
+      prev = tmp;
+    }
+  }
+  return dp[n];
+}
+function suggestSimilar(input, candidates, max = 3) {
+  if (!input || !candidates.length) return [];
+  const lo = input.toLowerCase();
+  const threshold = Math.max(2, Math.ceil(input.length / 3));
+  return candidates.map((c) => ({ c, d: levenshtein(lo, c.toLowerCase()) })).filter((x) => x.d <= threshold).sort((a, b) => a.d - b.d).slice(0, max).map((x) => x.c);
+}
+var KNOWN_SERVER_NAMES = /* @__PURE__ */ new Map();
+var KNOWN_CONTAINERS_BY_SERVER = /* @__PURE__ */ new Map();
+function rememberServers(servers) {
+  for (const s of servers) KNOWN_SERVER_NAMES.set(s.id, s);
+}
+function rememberContainers(serverId, names) {
+  KNOWN_CONTAINERS_BY_SERVER.set(serverId, { names, capturedAt: Date.now() });
+}
+function buildServerContextHints(servers) {
+  const hints = [];
+  for (const s of servers) {
+    const tagSet = new Set((s.tags || []).map((t) => String(t).toLowerCase()));
+    const name = (s.name || "").toLowerCase();
+    const host = (s.hostname || "").toLowerCase();
+    const found = [];
+    if (tagSet.has("trigger") || /trigger/.test(name) || /trigger/.test(host)) found.push("Trigger.dev self-hosted");
+    if (tagSet.has("supabase") || /supabase/.test(name) || /supabase/.test(host)) found.push("Supabase stack");
+    if (tagSet.has("proxy") || /proxy|jump/.test(name)) found.push("SSH ProxyJump host");
+    if (tagSet.has("giga") || /giga/.test(name)) found.push("shared workloads");
+    if (tagSet.has("vca") || /vca/.test(name)) found.push("VCA hosting");
+    if (tagSet.has("mg-boilers") || /boiler/.test(name)) found.push("boiler API");
+    if (tagSet.has("refront") || /refront|tickets/.test(name) || /refront|tickets/.test(host)) found.push("Refront/tickets");
+    if (found.length) hints.push(`- ${s.name}: ${found.join(", ")}`);
+  }
+  return hints;
+}
+function getKnownContainers(serverId, maxAgeMs = 5 * 6e4) {
+  const e = KNOWN_CONTAINERS_BY_SERVER.get(serverId);
+  if (!e) return void 0;
+  if (Date.now() - e.capturedAt > maxAgeMs) return void 0;
+  return e.names;
+}
+function truncateForLLM(text, maxBytes) {
+  const totalBytes = Buffer.byteLength(text, "utf8");
+  if (totalBytes <= maxBytes) return { text, truncated: false, totalBytes, shownBytes: totalBytes };
+  const buf = Buffer.from(text, "utf8");
+  let cut = maxBytes;
+  while (cut > 0 && (buf[cut] & 192) === 128) cut--;
+  const head = buf.subarray(0, cut).toString("utf8");
+  return { text: head, truncated: true, totalBytes, shownBytes: cut };
+}
+function buildTruncationHint(name, args2, total, shown) {
+  const base = `(showing first ${shown} of ${total} bytes;`;
+  if (name === "sftp-read") {
+    const off = Number(args2.offset) || 0;
+    const next = off + shown;
+    return `${base} pass { offset: ${next}, length: ${RESPONSE_MAX_BYTES} } to read more)`;
+  }
+  if (name === "docker-logs") {
+    return `${base} use \`tail\`, \`since\`, or \`grep\` to narrow the window)`;
+  }
+  if (name === "ssh-execute") {
+    return `${base} pipe through head/tail/grep server-side, or use sftp-read with offset for huge logs)`;
+  }
+  return `${base} narrow your query, paginate, or grep server-side to read the rest)`;
+}
+var TRANSIENT_RE = /(ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|ENETUNREACH|EHOSTUNREACH|connection\s+refused|connection\s+reset|getaddrinfo|connect\s+ETIMEDOUT|socket\s+hang\s*up|read\s+ECONNRESET|All configured authentication methods failed)/i;
+function isTransientSshError(stderr, exitCode) {
+  if (exitCode !== -1) return false;
+  if (!stderr) return false;
+  return TRANSIENT_RE.test(stderr);
+}
+function postprocessResult(result, meta) {
+  if (!result.content?.length) return result;
+  const block = result.content[0];
+  let text = String(block.text ?? "");
+  const trunc = truncateForLLM(text, RESPONSE_MAX_BYTES);
+  if (trunc.truncated) {
+    text = trunc.text + "\n\n... " + buildTruncationHint(meta.toolName, meta.args, trunc.totalBytes, trunc.shownBytes);
+  }
+  if (!NO_FOOTER_TOOLS.has(meta.toolName)) {
+    const tookMs = Date.now() - meta.startedAtMs;
+    const tookStr = tookMs < 1e3 ? `${tookMs}ms` : `${(tookMs / 1e3).toFixed(1)}s`;
+    const sizeStr = trunc.totalBytes >= 1024 ? `${(trunc.totalBytes / 1024).toFixed(1)} KB` : `${trunc.totalBytes} B`;
+    const parts = [`took ${tookStr}`, sizeStr];
+    if (meta.serverIdLabel) parts.push(`server: ${meta.serverIdLabel}`);
+    if (meta.cached) parts.push("cached");
+    text = `${text}
+
+[${parts.join(", ")}]`;
+  }
+  return { ...result, content: [{ ...block, text }] };
+}
+function buildPipelineScript(commands, shell, marker, stopOnError) {
+  if (shell === "powershell") {
+    const lines = ["$ErrorActionPreference='Continue'", "$ProgressPreference='SilentlyContinue'"];
+    for (let i = 0; i < commands.length; i++) {
+      lines.push(`Write-Output '${marker} ${i} begin'`);
+      lines.push(`& { ${commands[i]} } 2>&1`);
+      lines.push(`$__c = if ($null -eq $LASTEXITCODE) { 0 } else { $LASTEXITCODE }`);
+      lines.push(`Write-Output ('${marker} ' + ${i} + ' end exit=' + $__c)`);
+      if (stopOnError) lines.push(`if ($__c -ne 0) { exit $__c }`);
+    }
+    return buildPowerShellEncodedCommand(lines.join("; "), []);
+  }
+  const sh = [];
+  for (let i = 0; i < commands.length; i++) {
+    sh.push(`echo "${marker} ${i} begin"`);
+    sh.push(`{ ${commands[i]}; } 2>&1`);
+    sh.push(`__c=$?`);
+    sh.push(`echo "${marker} ${i} end exit=$__c"`);
+    if (stopOnError) sh.push(`if [ "$__c" -ne 0 ]; then exit "$__c"; fi`);
+  }
+  return `bash -c ${posixQuote(sh.join("; "))}`;
+}
+function parsePipelineOutput(stdout, commands, marker) {
+  const segments = [];
+  for (let i = 0; i < commands.length; i++) {
+    const beginRe = new RegExp(`^${escapeRegex(marker)}\\s+${i}\\s+begin\\s*$`, "m");
+    const endRe = new RegExp(`^${escapeRegex(marker)}\\s+${i}\\s+end\\s+exit=(-?\\d+)\\s*$`, "m");
+    const beginMatch = beginRe.exec(stdout);
+    const endMatch = endRe.exec(stdout);
+    if (!beginMatch || !endMatch) {
+      segments.push({ index: i, command: commands[i], output: "(no output captured \u2014 pipeline aborted before this step?)", exitCode: -1 });
+      continue;
+    }
+    const start = beginMatch.index + beginMatch[0].length + 1;
+    const end = endMatch.index;
+    const body = stdout.slice(start, end).replace(/\n$/, "");
+    const code = parseInt(endMatch[1], 10);
+    segments.push({ index: i, command: commands[i], output: body, exitCode: Number.isFinite(code) ? code : -1 });
+  }
+  return segments;
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function renderPipelineSegments(segments, overall, format) {
+  const sections = [];
+  for (const seg of segments) {
+    sections.push(`>>> [${seg.index + 1}/${segments.length}] ${seg.command}  (exit ${seg.exitCode})`);
+    let body = seg.output;
+    if (format === "ndjson") {
+      const parsed = tryParseNdjsonFromCommand(seg.command, body);
+      if (parsed) body = parsed;
+    }
+    sections.push(body || "(no output)");
+  }
+  if (overall.stderr) sections.push(`--- aggregate stderr ---
+${overall.stderr.trimEnd()}`);
+  return sections.join("\n");
+}
+function renderRepeatResult(iters, mode, format) {
+  const formatBody = (s) => {
+    if (format !== "ndjson") return s;
+    return tryParseNdjsonFromCommand("", s) || s;
+  };
+  if (mode === "last") {
+    const last = iters[iters.length - 1];
+    return `--- iteration ${last.index + 1}/${iters.length} (exit ${last.result.exitCode}, ${last.durationMs}ms) ---
+${formatBody(last.result.stdout) || "(empty)"}${last.result.stderr ? `
+[stderr] ${last.result.stderr.trimEnd()}` : ""}`;
+  }
+  if (mode === "diff") {
+    const sections2 = [`(repeat: ${iters.length} runs, diff mode \u2014 only differences vs. previous run shown)`];
+    let prev = "";
+    for (let i = 0; i < iters.length; i++) {
+      const cur = iters[i].result.stdout;
+      if (i === 0) {
+        sections2.push(`--- iteration 1 (initial, ${iters[i].durationMs}ms) ---
+${formatBody(cur) || "(empty)"}`);
+      } else {
+        const changes = diffLines(prev, cur);
+        const header = `--- iteration ${i + 1} (${iters[i].durationMs}ms, +${changes.added.length} -${changes.removed.length}) ---`;
+        const block = [header];
+        if (changes.added.length === 0 && changes.removed.length === 0) {
+          block.push("(no changes)");
+        } else {
+          for (const line of changes.added) block.push(`+ ${line}`);
+          for (const line of changes.removed) block.push(`- ${line}`);
+        }
+        sections2.push(block.join("\n"));
+      }
+      prev = cur;
+    }
+    return sections2.join("\n");
+  }
+  const sections = [`(repeat: ${iters.length} runs, all output)`];
+  for (const it of iters) {
+    sections.push(`--- iteration ${it.index + 1}/${iters.length} (exit ${it.result.exitCode}, ${it.durationMs}ms) ---`);
+    sections.push(formatBody(it.result.stdout) || "(empty)");
+    if (it.result.stderr) sections.push(`[stderr] ${it.result.stderr.trimEnd()}`);
+  }
+  return sections.join("\n");
+}
+function diffLines(a, b) {
+  const aSet = new Set(a.split("\n"));
+  const bSet = new Set(b.split("\n"));
+  const added = [];
+  const removed = [];
+  for (const line of bSet) if (!aSet.has(line) && line) added.push(line);
+  for (const line of aSet) if (!bSet.has(line) && line) removed.push(line);
+  return { added, removed };
+}
+function tryParseNdjsonFromCommand(command, stdout) {
+  if (!stdout.trim()) return null;
+  const c = command.toLowerCase();
+  const looksLike = (re) => re.test(c);
+  if (looksLike(/\bdf\b/) || /^Filesystem\s+\S+\s+Used\s+/m.test(stdout)) {
+    return parseDf(stdout);
+  }
+  if (looksLike(/\bfree\b/) || /^\s*total\s+used\s+free/m.test(stdout)) {
+    return parseFree(stdout);
+  }
+  if (looksLike(/\bps\b/) || /^USER\s+PID\s+%CPU\s+%MEM/m.test(stdout)) {
+    return parsePsAux(stdout);
+  }
+  if (looksLike(/\bss\b/) || /^State\s+Recv-Q\s+Send-Q/m.test(stdout)) {
+    return parseSs(stdout);
+  }
+  if (looksLike(/\blsblk\b/) || /^NAME\s+MAJ:MIN/m.test(stdout)) {
+    return parseLsblk(stdout);
+  }
+  return null;
+}
+function splitCols(line, max) {
+  const parts = line.trim().split(/\s+/);
+  if (max && parts.length > max) {
+    return [...parts.slice(0, max - 1), parts.slice(max - 1).join(" ")];
+  }
+  return parts;
+}
+function parseDf(s) {
+  const lines = s.split("\n").filter(Boolean);
+  const header = lines[0];
+  if (!header || !/Filesystem/i.test(header)) return null;
+  const cols = header.trim().split(/\s+/);
+  const out = [];
+  for (const ln of lines.slice(1)) {
+    const parts = splitCols(ln, cols.length);
+    if (parts.length < 4) continue;
+    const obj = {};
+    for (let i = 0; i < cols.length; i++) obj[cols[i]] = parts[i] || "";
+    out.push(JSON.stringify(obj));
+  }
+  return out.length ? out.join("\n") : null;
+}
+function parseFree(s) {
+  const lines = s.split("\n").filter(Boolean);
+  const out = [];
+  for (const ln of lines) {
+    if (/^\s*total\s+used\s+free/i.test(ln)) continue;
+    const m = ln.match(/^(\S+):?\s+(.+)$/);
+    if (!m) continue;
+    const [type, rest] = [m[1], m[2]];
+    const cols = rest.trim().split(/\s+/);
+    out.push(JSON.stringify({ type: type.replace(/:$/, ""), values: cols.map(Number) }));
+  }
+  return out.length ? out.join("\n") : null;
+}
+function parsePsAux(s) {
+  const lines = s.split("\n").filter(Boolean);
+  if (!lines[0] || !/USER\s+PID/i.test(lines[0])) return null;
+  const headers = lines[0].trim().split(/\s+/);
+  const out = [];
+  for (const ln of lines.slice(1)) {
+    const parts = splitCols(ln, headers.length);
+    if (parts.length < headers.length) continue;
+    const obj = {};
+    for (let i = 0; i < headers.length; i++) obj[headers[i]] = parts[i] || "";
+    out.push(JSON.stringify(obj));
+  }
+  return out.length ? out.join("\n") : null;
+}
+function parseSs(s) {
+  const lines = s.split("\n").filter(Boolean);
+  if (!lines[0] || !/(State|Netid)/i.test(lines[0])) return null;
+  const headers = lines[0].trim().split(/\s+/);
+  const out = [];
+  for (const ln of lines.slice(1)) {
+    const parts = splitCols(ln, headers.length);
+    const obj = {};
+    for (let i = 0; i < headers.length; i++) obj[headers[i]] = parts[i] || "";
+    out.push(JSON.stringify(obj));
+  }
+  return out.length ? out.join("\n") : null;
+}
+function parseLsblk(s) {
+  const lines = s.split("\n").filter(Boolean);
+  if (!lines[0] || !/NAME\s+MAJ:MIN/i.test(lines[0])) return null;
+  const headers = lines[0].trim().split(/\s+/);
+  const out = [];
+  for (const ln of lines.slice(1)) {
+    const parts = splitCols(ln, headers.length);
+    const obj = {};
+    for (let i = 0; i < headers.length; i++) obj[headers[i]] = parts[i] || "";
+    out.push(JSON.stringify(obj));
+  }
+  return out.length ? out.join("\n") : null;
+}
+async function resolveServerLabel(serverId, serverIds) {
+  if (Array.isArray(serverIds) && serverIds.length > 0) return `${serverIds.length} servers`;
+  if (!serverId) return void 0;
+  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;
+    }
+  } catch {
+  }
+  return serverId.slice(0, 8);
+}
 async function sftpWrite(opts, filePath, input, proxy, meta) {
   const safe = sanitizePath(filePath);
   assertWritablePath(safe);
@@ -2664,6 +3158,92 @@ async function sftpDelete(opts, filePath, proxy, options) {
     return `Error: ${e.message}`;
   }
 }
+async function sftpCopy(src, dst) {
+  const startedAt = Date.now();
+  if (src.kind === "r2" && dst.kind === "r2") {
+    const { size } = await r2CopyObject(src.bucket, src.key, dst.bucket, dst.key);
+    return { bytes: size, elapsedMs: Date.now() - startedAt, mode: "r2-server-side" };
+  }
+  if (src.kind === "r2" && dst.kind === "ssh") {
+    const safe = sanitizePath(dst.path);
+    assertWritablePath(safe);
+    const { stream, size } = await r2GetObjectStream(src.bucket, src.key);
+    const { client, cleanup } = await connectSshClient(dst.opts, dst.proxy, 6e4);
+    try {
+      await new Promise((resolve, reject) => {
+        client.sftp((err, sftp) => {
+          if (err) return reject(err);
+          const ws = sftp.createWriteStream(safe);
+          ws.on("close", () => resolve());
+          ws.on("error", reject);
+          stream.on("error", reject);
+          stream.pipe(ws);
+        });
+      });
+    } finally {
+      cleanup();
+    }
+    return { bytes: size, elapsedMs: Date.now() - startedAt, mode: "r2\u2192ssh-stream" };
+  }
+  if (src.kind === "ssh" && dst.kind === "r2") {
+    const safeSrc = sanitizePath(src.path);
+    const { client, cleanup } = await connectSshClient(src.opts, src.proxy, 6e4);
+    try {
+      const { stream, size } = await new Promise((resolve, reject) => {
+        client.sftp((err, sftp) => {
+          if (err) return reject(err);
+          sftp.stat(safeSrc, (statErr, stats) => {
+            if (statErr) return reject(statErr);
+            const s = stats.size || 0;
+            const rs = sftp.createReadStream(safeSrc);
+            resolve({ stream: rs, size: s });
+          });
+        });
+      });
+      if (size > R2_MULTIPART_THRESHOLD) {
+        cleanup();
+        throw new Error(`Source object is ${formatBytes(size)} which exceeds R2 single-PUT cap (${formatBytes(R2_MULTIPART_THRESHOLD)}). For now: download via sftp-write { sourceRemote, target: local } first, then upload to R2 with sourcePath.`);
+      }
+      await r2PutObject(dst.bucket, dst.key, stream, size);
+      return { bytes: size, elapsedMs: Date.now() - startedAt, mode: "ssh\u2192r2-stream" };
+    } finally {
+      cleanup();
+    }
+  }
+  if (src.kind === "ssh" && dst.kind === "ssh") {
+    const safeSrc = sanitizePath(src.path);
+    const safeDst = sanitizePath(dst.path);
+    assertWritablePath(safeDst);
+    const srcConn = await connectSshClient(src.opts, src.proxy, 6e4);
+    let dstConn;
+    try {
+      dstConn = await connectSshClient(dst.opts, dst.proxy, 6e4);
+      const bytes = await new Promise((resolve, reject) => {
+        srcConn.client.sftp((err, srcSftp) => {
+          if (err) return reject(err);
+          dstConn.client.sftp((err2, dstSftp) => {
+            if (err2) return reject(err2);
+            srcSftp.stat(safeSrc, (statErr, stats) => {
+              if (statErr) return reject(statErr);
+              const size = stats.size || 0;
+              const rs = srcSftp.createReadStream(safeSrc);
+              const ws = dstSftp.createWriteStream(safeDst);
+              ws.on("close", () => resolve(size));
+              ws.on("error", reject);
+              rs.on("error", reject);
+              rs.pipe(ws);
+            });
+          });
+        });
+      });
+      return { bytes, elapsedMs: Date.now() - startedAt, mode: "ssh\u2192ssh-stream" };
+    } finally {
+      srcConn.cleanup();
+      dstConn?.cleanup();
+    }
+  }
+  throw new Error("Unsupported copy combination");
+}
 var BLOCKED_COMMANDS = [
   "rm -rf /",
   "rm -fr /",
@@ -2848,33 +3428,41 @@ async function mijnhostFetch(path, options = {}) {
 var TOOLS = [
   {
     name: "list-servers",
-    description: "List all SSH servers you have access to. Returns id, name, hostname, tags, and os_type per server. Pass `includeStats: true` to also probe each server in parallel for container count, disk-free, and uptime (skips unreachable hosts gracefully).",
+    description: 'List all SSH servers you have access to. Returns id, name, hostname, tags, and os_type per server. Pass `includeStats: true` to also probe each server in parallel for container count, disk-free, and uptime (skips unreachable hosts gracefully). Cached for 60s \u2014 pass `noCache: true` to force a refresh. Adds an "auto-context" footer with one-line tags inferred from server name/tags so the LLM knows which host runs Trigger / Supabase / proxy / etc. (disable with `context: false`).',
     inputSchema: {
       type: "object",
       properties: {
         includeStats: { type: "boolean", description: "When true, probe each server (in parallel, with timeout) for container count, disk-free, and uptime." },
         statsParallelism: { type: "number", description: "Max parallel probes when includeStats is true (default 8, cap 20)." },
-        statsTimeoutMs: { type: "number", description: "Per-server probe timeout in ms when includeStats is true (default 6000, range 1000-30000)." }
+        statsTimeoutMs: { type: "number", description: "Per-server probe timeout in ms when includeStats is true (default 6000, range 1000-30000)." },
+        context: { type: "boolean", description: "Include auto-context footer with name/tag-based hints (default true). Pass false to suppress." },
+        noCache: { type: "boolean", description: "Bypass the 60s in-memory cache." }
       }
     }
   },
   {
     name: "ssh-execute",
-    description: 'Execute a command on a remote server via SSH. OS-aware: bash on linux, `powershell -EncodedCommand` (UTF-16LE base64) on windows, so $, #, quotes, spaces inside `args` are never re-interpreted by a shell. Some dangerous commands are blocked. Use `list-servers` first to see each server\'s os_type.\nTwo ways to invoke (use `args` for anything with passwords or special chars):\n- Quick: `command` only, e.g. `command: "df -h"`.\n- Safe: `command` + `args[]`, e.g. `command: "mysql"`, `args: ["-u","root","-p$tr@nge#pwd","-e","SELECT 1"]`.\n`stdin` pipes data into the remote process (queries, scripts, secrets) without putting it on the command line.\n`cwd` sets the working directory (auto `cd` on Linux / `Set-Location` on Windows).\nFan-out: pass `serverIds: [id1, id2, ...]` (instead of `serverId`) to run the same command across multiple servers in parallel. Each server\'s output is grouped under its own `=== name (os, exit N) ===` header.',
+    description: 'Execute one or more commands on a remote server via SSH. OS-aware: bash on linux, `powershell -EncodedCommand` (UTF-16LE base64) on windows, so $, #, quotes, spaces inside `args` are never re-interpreted by a shell. Some dangerous commands are blocked. Use `list-servers` first to see each server\'s os_type.\n\nThree modes (compose them in one call):\n- Single: `command` (+ optional `args[]`). Quick or safe.\n- Pipeline: `pipeline: ["cmd1","cmd2","cmd3"]` runs all commands sequentially in one SSH session and returns segmented per-command output (each with its own exit code). Default continues on error; pass `pipelineStopOnError: true` to abort.\n- Repeat: `repeat: N, intervalSeconds: S, output: "all"|"diff"|"last"`. Diff mode shows only added/removed lines vs. the previous run \u2014 perfect for "watch this metric for 5 min".\n\n`stdin` pipes data into the remote process (queries, scripts, secrets) without putting it on the command line. `cwd` sets the working directory (auto `cd` on Linux / `Set-Location` on Windows).\n\nIdle timeout: defaults to 120s \u2014 if the remote produces no stdout/stderr for that long the call returns with a clear timeout message. Pass `idleTimeoutSeconds: 0` to disable, or e.g. `300` for slow workloads.\n\nFan-out: pass `serverIds: [id1, id2, ...]` (instead of `serverId`) to run across multiple servers in parallel.\n\nAuto-features: outputs >8 KB are auto-truncated with a continuation hint; transient SSH failures (ECONNRESET/ETIMEDOUT/etc) get one automatic retry. Set `format: "ndjson"` to parse common Linux outputs (df / free / ps aux / ss / lsblk) into newline-delimited JSON instead of whitespace-padded text.',
     inputSchema: {
       type: "object",
       properties: {
         serverId: { type: "string", description: "UUID of one SSH server. Mutually exclusive with serverIds." },
         serverIds: { type: "array", items: { type: "string" }, description: "Fan-out: list of server UUIDs to run the command on in parallel. Mutually exclusive with serverId." },
-        command: { type: "string", description: 'Program/command to run (e.g. "mysql", "Get-Service", "df"). Required.' },
+        command: { type: "string", description: 'Program/command to run (e.g. "mysql", "Get-Service", "df"). Required unless `pipeline[]` is set.' },
         args: { type: "array", items: { type: "string" }, description: "Optional argv list. When provided, each entry is safely quoted/encoded for the target OS." },
+        pipeline: { type: "array", items: { type: "string" }, description: "Run multiple shell commands sequentially in ONE SSH session, with per-command exit codes and segmented output. Saves N round-trips for setup\u2192test\u2192cleanup workflows." },
+        pipelineStopOnError: { type: "boolean", description: "When pipeline is set, abort the chain on the first non-zero exit (default false: keep going so all outputs reach the LLM)." },
+        repeat: { type: "number", description: 'Re-run the command/pipeline N times (default 1, max 60). Combine with intervalSeconds + output to "watch" a metric.' },
+        intervalSeconds: { type: "number", description: "When repeat>1, seconds to wait between iterations (default 0, max 600)." },
+        output: { type: "string", enum: ["all", "diff", "last"], description: "When repeat>1: how to render iterations. `all` = full output per run; `diff` = only added/removed lines vs. previous run; `last` = only the final iteration." },
+        format: { type: "string", enum: ["text", "ndjson"], description: "Output format. `ndjson` parses common Linux outputs (df, free, ps aux, ss, lsblk) into newline-delimited JSON." },
         stdin: { type: "string", description: "Optional data piped to the remote process stdin." },
         cwd: { type: "string", description: "Working directory on the remote (cd <cwd> on Linux, Set-Location on Windows)." },
         shell: { type: "string", enum: ["auto", "bash", "powershell"], description: `Override shell selection (default "auto" uses the server's os_type).` },
         parallelism: { type: "number", description: "Max concurrent SSH sessions when using serverIds[] (default 5, max 20)." },
-        timeout: { type: "number", description: "Per-server timeout in milliseconds (default: 60000)" }
-      },
-      required: ["command"]
+        timeout: { type: "number", description: "Wall timeout in milliseconds (default: 60000). Usually idleTimeoutSeconds is what you want instead." },
+        idleTimeoutSeconds: { type: "number", description: 'Abort if no output for N seconds (default 120). Pass 0 to disable. Useful when the wall budget is hard to predict but silence usually means "stuck".' }
+      }
     }
   },
   {
@@ -2913,65 +3501,73 @@ var TOOLS = [
   },
   {
     name: "sftp-write",
-    description: "Write a file to remote storage. Two backends (provide exactly one of `serverId` or `bucket`) and two source modes (provide exactly one of `content` or `sourcePath`):\n\nBackends:\n- `serverId`: SSH server via SFTP. Protected system paths blocked. Optional `mode` sets POSIX permission bits (e.g. 0o755 for executables) and `mtime` sets the modification time.\n- `bucket`: Cloudflare R2 bucket (S3-compatible). Single PUT for files <4.5 GB, automatic multipart upload (100 MB parts) for larger files up to ~5 TB. `mode`/`mtime` are ignored on R2.\n\nSources:\n- `content` (string): inline UTF-8 text. Practical max ~1 MB.\n- `sourcePath` (absolute local path): streams the local file. SSH uses ssh2 fastPut (64 parallel pipelined writes); R2 uses streamed PUT or multipart depending on size. Both handle GB-scale files. Only usable when the MCP runs locally.",
+    description: "Write OR copy a file in remote storage. Two target backends (`serverId` or `bucket`) and three source modes:\n\nSources:\n- `content` (string): inline UTF-8 text (\u22481 MB max).\n- `sourcePath` (absolute local path): streams a local file. SSH uses ssh2 fastPut; R2 uses streamed PUT (or automatic multipart for >4.5 GB). Handles GB-scale.\n- `sourceRemote: { serverId|bucket, path }`: COPY mode \u2014 pulls from one remote and writes to another in a single operation, no local detour. Supports all four directions: ssh\u2194ssh, ssh\u2194r2, r2\u2194ssh, r2\u2194r2 (R2\u2194R2 uses server-side CopyObject = zero data egress).\n\nTargets:\n- `serverId`: SSH server via SFTP. Protected system paths blocked. Optional `mode` (POSIX bits e.g. 0o755) and `mtime` (modification time) \u2014 SSH only.\n- `bucket`: Cloudflare R2 bucket. `mode`/`mtime` are ignored on R2.",
     inputSchema: {
       type: "object",
       properties: {
-        serverId: { type: "string", description: "UUID of the SSH server (mutually exclusive with bucket)" },
-        bucket: { type: "string", description: "Cloudflare R2 bucket name (mutually exclusive with serverId)" },
-        path: { type: "string", description: "Remote file path (SSH) or object key (R2)" },
-        content: { type: "string", description: "Inline UTF-8 file content (mutually exclusive with sourcePath)" },
-        sourcePath: { type: "string", description: "Absolute local file path to upload (mutually exclusive with content). Use for files >1 MB or any binary." },
-        mode: { oneOf: [{ type: "number" }, { type: "string" }], description: 'POSIX file permission bits (SSH only). Number (0o755 / 493) or octal string ("755" / "0o755"). Default 0o644.' },
-        mtime: { oneOf: [{ type: "number" }, { type: "string" }], description: "File modification time (SSH only). ms-since-epoch number or ISO-8601 date string." }
+        serverId: { type: "string", description: "TARGET: UUID of the SSH server (mutually exclusive with bucket)" },
+        bucket: { type: "string", description: "TARGET: Cloudflare R2 bucket name (mutually exclusive with serverId)" },
+        path: { type: "string", description: "TARGET path (SSH file path or R2 object key)" },
+        content: { type: "string", description: "Source: inline UTF-8 file content (mutually exclusive with sourcePath / sourceRemote)" },
+        sourcePath: { type: "string", description: "Source: absolute local file path (mutually exclusive with content / sourceRemote). Use for >1 MB or binary." },
+        sourceRemote: { type: "object", description: "Source: copy from another remote. Shape: { serverId?: string, bucket?: string, path: string }. Picks the streaming strategy (ssh\u2192ssh, r2\u2192ssh, ssh\u2192r2, r2\u2192r2 server-side).", properties: { serverId: { type: "string" }, bucket: { type: "string" }, path: { type: "string" } } },
+        mode: { oneOf: [{ type: "number" }, { type: "string" }], description: 'POSIX file permission bits (SSH target only). Number (0o755 / 493) or octal string ("755" / "0o755"). Default 0o644.' },
+        mtime: { oneOf: [{ type: "number" }, { type: "string" }], description: "File modification time (SSH target only). ms-since-epoch number or ISO-8601 date string." }
       },
       required: ["path"]
     }
   },
   {
     name: "sftp-delete",
-    description: "Delete a file (or directory tree) from remote storage. Two backends (provide exactly one of `serverId` or `bucket`):\n- `serverId`: delete a file or empty directory on an SSH server via SFTP. Protected system paths blocked. With `recursive: true` walks the tree depth-first via SFTP and removes files + empty dirs from the bottom up (works on Windows OpenSSH too \u2014 no shell tricks).\n- `bucket`: delete an object from a Cloudflare R2 bucket. `path` is the object key. With `recursive: true`, treats `path` as a key prefix and batch-deletes every object beneath it (R2 caps at 1000 keys per call; we loop pages automatically).",
+    description: 'Delete a file (or directory tree) from remote storage. Two backends (provide exactly one of `serverId` or `bucket`):\n- `serverId`: delete a file or empty directory on an SSH server via SFTP. Protected system paths blocked. With `recursive: true` walks the tree depth-first via SFTP and removes files + empty dirs from the bottom up (works on Windows OpenSSH too \u2014 no shell tricks).\n- `bucket`: delete an object from a Cloudflare R2 bucket. `path` is the object key. With `recursive: true`, treats `path` as a key prefix and batch-deletes every object beneath it.\n\nSafety nets:\n- `dryRun: true` \u2192 returns "Would delete N items (size)" with a sample preview, no actual deletion.\n- `confirmAbove: N` + `confirmCount: <exact>` \u2192 refuses recursive deletes touching more than N items unless the caller passes `confirmCount` matching the actual count.',
     inputSchema: {
       type: "object",
       properties: {
         serverId: { type: "string", description: "UUID of the SSH server (mutually exclusive with bucket)" },
         bucket: { type: "string", description: "Cloudflare R2 bucket name (mutually exclusive with serverId)" },
         path: { type: "string", description: "File path / object key (or directory / key prefix when recursive)" },
-        recursive: { type: "boolean", description: "Recursively remove a directory tree (SSH) or all objects under a key prefix (R2)." }
+        recursive: { type: "boolean", description: "Recursively remove a directory tree (SSH) or all objects under a key prefix (R2)." },
+        dryRun: { type: "boolean", description: "Preview-only mode: returns what would be deleted (count, total size, sample paths) without touching anything." },
+        confirmAbove: { type: "number", description: "Refuse recursive deletes that touch more than N items unless `confirmCount` matches the actual count." },
+        confirmCount: { type: "number", description: "When confirmAbove gates a delete, pass the exact item count from the dry-run output to confirm intent." }
       },
       required: ["path"]
     }
   },
   {
     name: "docker-list",
-    description: "List Docker containers on a remote server. Sorted by compose project then name, with a HEALTH column (healthy / unhealthy / starting / no-check). Filter by `nameFilter` (string OR array of substring/glob entries \u2014 passes if ANY entry matches), restrict to compose containers with `composeOnly`, or group output per project with `groupByProject`.",
+    description: 'List Docker containers on one or more remote servers. Sorted by compose project then name, with a HEALTH column (healthy / unhealthy / starting / no-check). Filter by `nameFilter` (string OR array of substring/glob entries \u2014 passes if ANY entry matches), restrict to compose containers with `composeOnly`, or group output per project with `groupByProject`.\n\nFan-out: pass `serverIds: [...]` (instead of `serverId`) to query multiple servers in parallel \u2014 perfect for "show all unhealthy containers across the fleet". Per-server sections are clearly headed.\n\nCached for 30s \u2014 pass `noCache: true` to bypass.',
     inputSchema: {
       type: "object",
       properties: {
-        serverId: { type: "string", description: "UUID of the SSH server" },
-        format: { type: "string", enum: ["table", "json"], description: "Output format: human table (default) or NDJSON (one JSON object per line, includes labels)." },
+        serverId: { type: "string", description: "UUID of one SSH server. Mutually exclusive with serverIds." },
+        serverIds: { type: "array", items: { type: "string" }, description: "Fan-out: list of server UUIDs to query in parallel. Mutually exclusive with serverId." },
+        format: { type: "string", enum: ["table", "json"], description: 'Output format: human table (default) or NDJSON. JSON adds a "Server" field per row in fan-out mode.' },
         composeOnly: { type: "boolean", description: "Only show containers that have a docker-compose project label." },
         nameFilter: { oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }], description: "Filter by container name. Single entry or array; each entry is glob (* or ?) or substring. A row passes when ANY entry matches." },
-        groupByProject: { type: "boolean", description: "Group output per compose project with a `=== project (count) ===` header." }
-      },
-      required: ["serverId"]
+        groupByProject: { type: "boolean", description: "Group output per compose project with a `=== project (count) ===` header (single-server mode only)." },
+        parallelism: { type: "number", description: "Max concurrent SSH sessions when using serverIds[] (default 5, max 20)." },
+        noCache: { type: "boolean", description: "Bypass the 30s in-memory cache." }
+      }
     }
   },
   {
     name: "docker-logs",
-    description: 'Get logs from one or more Docker containers. `containerName` accepts a string OR an array \u2014 multi-container output is line-prefixed with `[name]` so you can read related services together (e.g. `["refront-rest-1", "refront-kong-1", "refront-db-1"]`). Supports time-window (`since`), server-side `grep`, line-count (`tail`), and real-time follow (`followSeconds`). Always merges stderr into stdout.',
+    description: 'Get logs from one or more Docker containers, optionally across multiple servers. `containerName` accepts a string OR array \u2014 multi-container output is line-prefixed with `[name]`. Supports time-window (`since`), server-side `grep`, line-count (`tail`), and real-time follow (`followSeconds`). Always merges stderr into stdout. Outputs >8 KB get a continuation hint.\n\nFan-out: pass `serverIds: [...]` to tail the same container(s) across multiple servers in one call (e.g. all kong instances). Per-server output is grouped under headers.\n\nFuzzy hint: if a container name typo is detected, the error includes "Did you mean: ..." suggestions from the docker-list cache.',
     inputSchema: {
       type: "object",
       properties: {
-        serverId: { type: "string", description: "UUID of the SSH server" },
+        serverId: { type: "string", description: "UUID of one SSH server. Mutually exclusive with serverIds." },
+        serverIds: { type: "array", items: { type: "string" }, description: "Fan-out: list of server UUIDs to tail in parallel. Mutually exclusive with serverId." },
         containerName: { oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }], description: "Single container name/ID or an array for multi-container tail. Multi mode prefixes each line with [name]." },
-        tail: { type: "number", description: "Number of recent log lines per container (default 100). Alias: `lines`." },
+        tail: { type: "number", description: "Number of recent log lines per container (default 100, default 0 in follow mode)." },
         lines: { type: "number", description: "Deprecated alias for `tail`. Prefer `tail`." },
         since: { type: "string", description: 'Time window, e.g. "10m", "2h", "24h", or an absolute "2026-05-09T10:00:00".' },
         grep: { type: "string", description: "Case-insensitive regex/literal filter applied server-side (saves tokens for noisy containers)." },
-        followSeconds: { type: "number", description: "When >0, stream new log lines for N seconds via `docker logs -f`, then exit (max 300). Multi-container follow runs all streams in parallel." }
+        followSeconds: { type: "number", description: "When >0, stream new log lines for N seconds via `docker logs -f`, then exit (max 300). Multi-container follow runs all streams in parallel." },
+        parallelism: { type: "number", description: "Max concurrent SSH sessions when using serverIds[] (default 5, max 20)." }
       },
-      required: ["serverId", "containerName"]
+      required: ["containerName"]
     }
   },
   {
@@ -3009,6 +3605,24 @@ var TOOLS = [
       required: ["serverId", "projectPath", "action"]
     }
   },
+  {
+    name: "wait-for",
+    description: 'Poll until a condition holds (or timeout). Replaces 30+ ad-hoc loops the LLM would otherwise build itself. Four condition types:\n- `url`: `target: "https://..."`, `until: 200` (HTTP status, default 200). 10s per probe.\n- `container-health`: `serverId`, `target: "container-name"`, `until: "healthy" | "running" | "exited"` (default "healthy"). Uses `docker inspect`.\n- `file-exists`: `serverId`, `target: "/path/to/file"` \u2014 SSH stat check.\n- `sftp-exists`: same as file-exists but with `bucket: "name"` instead of serverId for R2.\n\nReturns a per-attempt trail so you can see how long it took to converge.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: { type: "string", enum: ["url", "container-health", "file-exists", "sftp-exists"], description: "Condition type to wait on." },
+        target: { type: "string", description: "Target identifier: URL, container name, file path, or R2 key (depends on type)." },
+        until: { description: 'Expected end-state (depends on type): for url an HTTP status (default 200), for container-health a state string (default "healthy"). Omit for file-exists/sftp-exists.' },
+        serverId: { type: "string", description: "SSH server UUID (required for container-health and file-exists)." },
+        bucket: { type: "string", description: "R2 bucket name (used with sftp-exists when checking an R2 object)." },
+        path: { type: "string", description: "Alias for `target` for file-exists/sftp-exists." },
+        intervalSeconds: { type: "number", description: "Poll interval in seconds (default 3, max 60)." },
+        timeout: { type: "number", description: "Total deadline in seconds (default 120, max 1800)." }
+      },
+      required: ["type", "target"]
+    }
+  },
   {
     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.",
@@ -3047,15 +3661,20 @@ var TOOLS = [
   },
   {
     name: "db-query",
-    description: "Execute a SQL query on a site database. Credentials are auto-discovered from site config files. Destructive operations (DROP, TRUNCATE) are blocked.",
+    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\nDestructive operations (DROP, TRUNCATE, etc.) are blocked.',
     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)" },
-        query: { type: "string", description: "SQL query to execute" }
+        query: { type: "string", description: "SQL query to execute" },
+        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.' },
+        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." }
       },
-      required: ["serverId", "sitePath", "query"]
+      required: ["serverId", "query"]
     }
   },
   {
@@ -3201,9 +3820,21 @@ async function handleCallTool(request) {
   }
   const startTime = Date.now();
   const serverId = a.serverId || a.server_id;
-  const result = await executeToolCall(name, a);
+  const serverIds = a.serverIds;
+  const cached = getCachedTool(name, a);
+  let cameFromCache = false;
+  let result;
+  if (cached) {
+    result = cached;
+    cameFromCache = true;
+  } else {
+    result = await executeToolCall(name, a);
+  }
   const durationMs = Date.now() - startTime;
   const isError = result.content?.[0]?.text?.startsWith("Error:");
+  if (!cameFromCache && !isError) {
+    setCachedTool(name, a, result);
+  }
   void writeAuditLog({
     toolName: name,
     arguments: a,
@@ -3212,7 +3843,14 @@ async function handleCallTool(request) {
     errorMessage: isError ? result.content?.[0]?.text : void 0,
     durationMs
   });
-  return result;
+  const serverIdLabel = await resolveServerLabel(serverId, serverIds);
+  return postprocessResult(result, {
+    startedAtMs: startTime,
+    serverIdLabel,
+    toolName: name,
+    args: a,
+    cached: cameFromCache
+  });
 }
 async function executeToolCall(name, a, _serverId) {
   const ctx = authContext;
@@ -3228,6 +3866,7 @@ async function executeToolCall(name, a, _serverId) {
         if (error) throw new Error(error.message);
         const includeStats = a.includeStats === true;
         const servers = data || [];
+        rememberServers(servers.map((s) => ({ id: s.id, name: s.name })));
         let statsByServer = /* @__PURE__ */ new Map();
         if (includeStats && servers.length > 0) {
           const parallelism = Math.max(1, Math.min(20, Number(a.statsParallelism) || 8));
@@ -3278,17 +3917,34 @@ async function executeToolCall(name, a, _serverId) {
           if (!st.reachable) return `${base}  UNREACHABLE (${st.error || "unknown"})`;
           return `${base}  containers:${st.containers}  disk_free:${st.diskFreeHuman}  uptime:${st.uptimeHuman}`;
         });
-        return { content: [{ type: "text", text: lines.length ? lines.join("\n") : "No servers found" }] };
+        const contextHints = a.context !== false ? buildServerContextHints(servers) : [];
+        const out = lines.length ? lines.join("\n") : "No servers found";
+        return { content: [{ type: "text", text: contextHints.length ? `${out}
+
+--- context ---
+${contextHints.join("\n")}` : out }] };
       }
       // ----- SSH -----
       case "ssh-execute": {
-        const command = String(a.command);
-        assertSafeCommand(command);
+        const pipeline = Array.isArray(a.pipeline) ? a.pipeline.map(String).filter(Boolean) : [];
+        const command = pipeline.length > 0 ? "" : String(a.command || "");
+        if (!command && pipeline.length === 0) {
+          return { content: [{ type: "text", text: "Error: pass either `command` or `pipeline[]`" }] };
+        }
+        if (command) assertSafeCommand(command);
+        for (const c of pipeline) assertSafeCommand(c);
         const args2 = Array.isArray(a.args) ? a.args.map(String) : void 0;
         const stdin = typeof a.stdin === "string" ? a.stdin : void 0;
         const shellOverride = typeof a.shell === "string" ? a.shell : "auto";
         const cwd = typeof a.cwd === "string" && a.cwd ? a.cwd : void 0;
         const timeoutMs = a.timeout ? Number(a.timeout) : void 0;
+        const rawIdle = a.idleTimeoutSeconds !== void 0 ? Number(a.idleTimeoutSeconds) : 120;
+        const idleTimeoutMs = Number.isFinite(rawIdle) && rawIdle > 0 ? rawIdle * 1e3 : void 0;
+        const repeat = Math.max(1, Math.min(60, Number(a.repeat) || 1));
+        const intervalSeconds = Math.max(0, Math.min(600, Number(a.intervalSeconds) || 0));
+        const repeatOutput = a.output === "diff" || a.output === "last" ? a.output : "all";
+        const format = a.format === "ndjson" ? "ndjson" : "text";
+        const pipelineStopOnError = a.pipelineStopOnError === true;
         const targetIds = Array.isArray(a.serverIds) && a.serverIds.length > 0 ? a.serverIds.map(String) : a.serverId ? [String(a.serverId)] : [];
         if (targetIds.length === 0) {
           return { content: [{ type: "text", text: "Error: pass either `serverId` or `serverIds[]`" }] };
@@ -3299,44 +3955,88 @@ async function executeToolCall(name, a, _serverId) {
           if (timeoutMs) conn.timeout = timeoutMs;
           const shell = shellOverride === "auto" ? os === "windows" ? "powershell" : "bash" : shellOverride;
           let body;
-          if (args2 && args2.length > 0) {
+          let pipelineMarker = null;
+          if (pipeline.length > 0) {
+            pipelineMarker = `__MCP_BREAK_${randomBytes(8).toString("hex")}__`;
+            body = buildPipelineScript(pipeline, shell, pipelineMarker, pipelineStopOnError);
+          } else if (args2 && args2.length > 0) {
             body = shell === "powershell" ? buildPowerShellEncodedCommand(command, args2) : buildPosixCommand(command, args2);
           } else if (shell === "powershell" && !/^powershell\b/i.test(command.trim())) {
             body = buildPowerShellEncodedCommand(command, []);
           } else {
             body = command;
           }
-          let finalCmd = body;
-          if (cwd) {
-            if (shell === "bash") {
-              finalCmd = `cd ${posixQuote(cwd)} && ${body}`;
-            } else {
-              const ecMatch = body.match(/-EncodedCommand\s+(\S+)$/);
-              if (ecMatch) {
-                const decoded = Buffer.from(ecMatch[1], "base64").toString("utf16le");
-                const wrapped = `Set-Location -LiteralPath '${cwd.replace(/'/g, "''")}'; ${decoded}`;
-                const reencoded = Buffer.from(wrapped, "utf16le").toString("base64");
-                finalCmd = body.replace(/-EncodedCommand\s+\S+$/, `-EncodedCommand ${reencoded}`);
+          const applyCwd = (rawBody) => {
+            if (!cwd) return rawBody;
+            if (shell === "bash") return `cd ${posixQuote(cwd)} && ${rawBody}`;
+            const ecMatch = rawBody.match(/-EncodedCommand\s+(\S+)$/);
+            if (!ecMatch) return rawBody;
+            const decoded = Buffer.from(ecMatch[1], "base64").toString("utf16le");
+            const wrapped = `Set-Location -LiteralPath '${cwd.replace(/'/g, "''")}'; ${decoded}`;
+            const reencoded = Buffer.from(wrapped, "utf16le").toString("base64");
+            return rawBody.replace(/-EncodedCommand\s+\S+$/, `-EncodedCommand ${reencoded}`);
+          };
+          const finalCmd = applyCwd(body);
+          if (repeat > 1) {
+            const iterations = [];
+            for (let i = 0; i < repeat; i++) {
+              const startedAt = Date.now();
+              const r = await sshExec(conn, finalCmd, proxy, {
+                ...stdin !== void 0 ? { stdin } : {},
+                idleTimeoutMs
+              });
+              iterations.push({ index: i, startedAt, durationMs: Date.now() - startedAt, result: r });
+              if (i < repeat - 1 && intervalSeconds > 0) {
+                await new Promise((res) => setTimeout(res, intervalSeconds * 1e3));
               }
             }
+            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;
+            } catch {
+            }
+            return { serverId, serverName: serverName2, os, shell, result: last, iterations };
+          }
+          const result = await sshExec(conn, finalCmd, proxy, {
+            ...stdin !== void 0 ? { stdin } : {},
+            idleTimeoutMs
+          });
+          let pipelineSegments;
+          if (pipelineMarker && pipeline.length > 0) {
+            pipelineSegments = parsePipelineOutput(result.stdout, pipeline, pipelineMarker);
           }
-          const result = await sshExec(conn, finalCmd, proxy, stdin !== void 0 ? { stdin } : void 0);
           let serverName = serverId;
           try {
-            const { data } = await supabase.from("ssh_server").select("name").eq("id", serverId).single();
+            const { data } = await supabase.from("ssh_server").select("name").eq("id", serverId).maybeSingle();
             if (data?.name) serverName = data.name;
           } catch {
           }
-          return { serverId, serverName, os, shell, result };
+          return { serverId, serverName, os, shell, result, pipelineSegments };
+        };
+        const renderOne = (r) => {
+          if (r.iterations && r.iterations.length > 0) {
+            return renderRepeatResult(r.iterations, repeatOutput, format);
+          }
+          if (r.pipelineSegments) {
+            return renderPipelineSegments(r.pipelineSegments, r.result, format);
+          }
+          const output = [`Exit code: ${r.result.exitCode} (os: ${r.os}, shell: ${r.shell})`];
+          let stdoutText = r.result.stdout;
+          if (format === "ndjson" && stdoutText) {
+            const parsed = tryParseNdjsonFromCommand(command, stdoutText);
+            if (parsed) stdoutText = parsed;
+          }
+          if (stdoutText) output.push(`--- stdout ---
+${stdoutText}`);
+          if (r.result.stderr) output.push(`--- stderr ---
+${r.result.stderr}`);
+          return output.join("\n");
         };
         if (targetIds.length === 1) {
-          const { os, shell, result } = await runOne(targetIds[0]);
-          const output = [`Exit code: ${result.exitCode} (os: ${os}, shell: ${shell})`];
-          if (result.stdout) output.push(`--- stdout ---
-${result.stdout}`);
-          if (result.stderr) output.push(`--- stderr ---
-${result.stderr}`);
-          return { content: [{ type: "text", text: output.join("\n") }] };
+          const r = await runOne(targetIds[0]);
+          return { content: [{ type: "text", text: renderOne(r) }] };
         }
         const allResults = [];
         for (let i = 0; i < targetIds.length; i += parallelism) {
@@ -3360,10 +4060,8 @@ ${result.stderr}`);
           if (r.result.exitCode === 0) okCount++;
           else failCount++;
           const header = `=== ${r.serverName} (${r.os}, exit ${r.result.exitCode}) ===`;
-          const parts = [header];
-          if (r.result.stdout) parts.push(r.result.stdout.trimEnd());
-          if (r.result.stderr) parts.push(`[stderr] ${r.result.stderr.trimEnd()}`);
-          sections.push(parts.join("\n"));
+          sections.push(`${header}
+${renderOne(r)}`);
         }
         sections.push(`--- fan-out summary: ${okCount} ok / ${failCount} failed across ${allResults.length} servers (parallelism ${parallelism}) ---`);
         return { content: [{ type: "text", text: sections.join("\n\n") }] };
@@ -3465,6 +4163,46 @@ ${result.stderr}`);
       }
       case "sftp-write": {
         const bucket = typeof a.bucket === "string" && a.bucket ? a.bucket : "";
+        if (a.sourceRemote && typeof a.sourceRemote === "object") {
+          const srcRaw = a.sourceRemote;
+          const srcBucket = typeof srcRaw.bucket === "string" && srcRaw.bucket ? String(srcRaw.bucket) : "";
+          const srcServerId = typeof srcRaw.serverId === "string" && srcRaw.serverId ? String(srcRaw.serverId) : "";
+          const srcPath = String(srcRaw.path || "");
+          if (!srcPath) return { content: [{ type: "text", text: "Error: sourceRemote.path is required" }] };
+          if (!srcBucket && !srcServerId) return { content: [{ type: "text", text: "Error: sourceRemote needs `serverId` or `bucket`" }] };
+          if (srcBucket && srcServerId) return { content: [{ type: "text", text: "Error: sourceRemote can have either `serverId` or `bucket`, not both" }] };
+          const dstPath = String(a.path || "");
+          if (!dstPath) return { content: [{ type: "text", text: "Error: target `path` is required" }] };
+          let srcEp;
+          if (srcBucket) {
+            const k = r2Key(srcPath);
+            if (!k) return { content: [{ type: "text", text: "Error: sourceRemote.path resolves to empty key" }] };
+            srcEp = { kind: "r2", bucket: srcBucket, key: k };
+          } else {
+            const { conn: conn2, proxy: proxy2 } = await getServerConnection(srcServerId);
+            srcEp = { kind: "ssh", opts: conn2, proxy: proxy2, path: srcPath };
+          }
+          let dstEp;
+          if (bucket) {
+            const k = r2Key(dstPath);
+            if (!k) return { content: [{ type: "text", text: "Error: target path resolves to empty key" }] };
+            dstEp = { kind: "r2", bucket, key: k };
+          } else if (a.serverId) {
+            const { conn: conn2, proxy: proxy2 } = await getServerConnection(String(a.serverId));
+            dstEp = { kind: "ssh", opts: conn2, proxy: proxy2, path: dstPath };
+          } else {
+            return { content: [{ type: "text", text: "Error: target needs `serverId` or `bucket`" }] };
+          }
+          try {
+            const { bytes, elapsedMs, mode } = await sftpCopy(srcEp, dstEp);
+            const srcLabel = srcEp.kind === "r2" ? `r2://${srcEp.bucket}/${srcEp.key}` : `ssh:${srcPath}`;
+            const dstLabel = dstEp.kind === "r2" ? `r2://${dstEp.bucket}/${dstEp.key}` : `ssh:${dstPath}`;
+            const mbps = bytes > 0 && elapsedMs > 0 ? bytes / (1024 * 1024) / (elapsedMs / 1e3) : 0;
+            return { content: [{ type: "text", text: `Copied ${formatBytes(bytes)} from ${srcLabel} \u2192 ${dstLabel} via ${mode} in ${(elapsedMs / 1e3).toFixed(2)}s${mbps > 0 ? ` (${mbps.toFixed(1)} MB/s)` : ""}` }] };
+          } catch (e) {
+            return { content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : String(e)}` }] };
+          }
+        }
         let fileMode;
         if (typeof a.mode === "number" && Number.isFinite(a.mode)) fileMode = a.mode & 4095;
         else if (typeof a.mode === "string" && a.mode) {
@@ -3527,14 +4265,51 @@ ${result.stderr}`);
       case "sftp-delete": {
         const bucket = typeof a.bucket === "string" && a.bucket ? a.bucket : "";
         const recursive = a.recursive === true;
+        const dryRun = a.dryRun === true;
+        const confirmAbove = a.confirmAbove !== void 0 ? Math.max(0, Number(a.confirmAbove)) : void 0;
+        const confirmCount = a.confirmCount !== void 0 ? Number(a.confirmCount) : void 0;
+        const guard = (count, sizeBytes, where) => {
+          if (confirmAbove !== void 0 && count > confirmAbove) {
+            if (confirmCount === count) return null;
+            return {
+              content: [{
+                type: "text",
+                text: `Refusing to delete ${count} item(s) (${formatBytes(sizeBytes)}) under ${where}: exceeds confirmAbove=${confirmAbove}. To proceed, re-issue the call with confirmCount: ${count}.`
+              }]
+            };
+          }
+          return null;
+        };
         if (bucket) {
           const key = r2Key(String(a.path));
           if (!key) return { content: [{ type: "text", text: "Error: path is required" }] };
           try {
             if (recursive) {
+              if (dryRun || confirmAbove !== void 0) {
+                const listed = await r2List(bucket, key, { recursive: true, maxResults: 5e4 });
+                const objects = listed.filter((e) => !e.isPrefix);
+                const totalSize = objects.reduce((s, o) => s + (o.size || 0), 0);
+                if (dryRun) {
+                  const sample = objects.slice(0, 5).map((o) => `  - r2://${bucket}/${o.key} (${formatBytes(o.size || 0)})`);
+                  return { content: [{ type: "text", text: `[dry-run] Would delete ${objects.length} object(s) totalling ${formatBytes(totalSize)} under r2://${bucket}/${key}${objects.length > 5 ? `
+${sample.join("\n")}
+  ... and ${objects.length - 5} more` : objects.length ? `
+${sample.join("\n")}` : ""}` }] };
+                }
+                const block = guard(objects.length, totalSize, `r2://${bucket}/${key}`);
+                if (block) return block;
+              }
               const deleted = await r2DeletePrefix(bucket, key);
               return { content: [{ type: "text", text: `Deleted ${deleted} object(s) under r2://${bucket}/${key}` }] };
             }
+            if (dryRun) {
+              try {
+                const head = await getR2Client().send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
+                return { content: [{ type: "text", text: `[dry-run] Would delete r2://${bucket}/${key} (${formatBytes(head.ContentLength || 0)})` }] };
+              } catch {
+                return { content: [{ type: "text", text: `[dry-run] r2://${bucket}/${key} not found (delete would 404)` }] };
+              }
+            }
             await r2DeleteObject(bucket, key);
             return { content: [{ type: "text", text: `Deleted r2://${bucket}/${key}` }] };
           } catch (e) {
@@ -3542,6 +4317,25 @@ ${result.stderr}`);
           }
         }
         const { conn, proxy } = await getServerConnection(String(a.serverId));
+        if (recursive && (dryRun || confirmAbove !== void 0)) {
+          const listed = await sftpReaddir(conn, String(a.path), proxy, {
+            recursive: true,
+            maxResults: 5e4
+          });
+          const files = listed.entries.filter((e) => e.kind === "-");
+          const dirs = listed.entries.filter((e) => e.kind === "d");
+          const totalSize = files.reduce((s, f) => s + (f.size || 0), 0);
+          if (dryRun) {
+            const sample = files.slice(0, 5).map((f) => `  - ${f.path} (${formatBytes(f.size || 0)})`);
+            return { content: [{ type: "text", text: `[dry-run] Would delete ${files.length} file(s) + ${dirs.length} directory(ies) totalling ${formatBytes(totalSize)} under ${a.path}${files.length ? `
+${sample.join("\n")}${files.length > 5 ? `
+  ... and ${files.length - 5} more` : ""}` : ""}` }] };
+          }
+          const block = guard(files.length + dirs.length, totalSize, String(a.path));
+          if (block) return block;
+        } else if (dryRun) {
+          return { content: [{ type: "text", text: `[dry-run] Would delete ${a.path} (single file/dir; pass recursive: true to preview tree contents)` }] };
+        }
         const result = await sftpDelete(conn, String(a.path), proxy, { recursive });
         return { content: [{ type: "text", text: result }] };
       }
@@ -3551,75 +4345,136 @@ ${result.stderr}`);
         const composeOnly = a.composeOnly === true;
         const groupByProject = a.groupByProject === true;
         const nameFiltersRaw = Array.isArray(a.nameFilter) ? a.nameFilter.map((v) => String(v).trim()).filter(Boolean) : typeof a.nameFilter === "string" && a.nameFilter.trim() ? [a.nameFilter.trim()] : [];
+        const targetIds = Array.isArray(a.serverIds) && a.serverIds.length > 0 ? a.serverIds.map(String) : a.serverId ? [String(a.serverId)] : [];
+        if (targetIds.length === 0) {
+          return { content: [{ type: "text", text: "Error: pass either `serverId` or `serverIds[]`" }] };
+        }
+        const parallelism = Math.max(1, Math.min(20, Number(a.parallelism) || 5));
         const filterArg = composeOnly ? ` --filter "label=com.docker.compose.project"` : "";
         const cmd = `docker ps -a${filterArg} --format '{{json .}}'`;
-        const { conn, proxy } = await getServerConnection(String(a.serverId));
-        const result = await sshExec(conn, cmd, proxy);
-        if (result.exitCode !== 0) {
-          return { content: [{ type: "text", text: `Error: ${result.stderr || result.stdout}` }] };
-        }
-        const containers = [];
-        for (const line of result.stdout.split("\n")) {
-          const trimmed = line.trim();
-          if (!trimmed) continue;
+        const probeOne = async (serverId) => {
+          let serverName = serverId.slice(0, 8);
           try {
-            containers.push(JSON.parse(trimmed));
-          } catch {
+            const { conn, proxy } = await getServerConnection(serverId);
+            const r = await sshExec(conn, cmd, proxy);
+            const cached = KNOWN_SERVER_NAMES.get(serverId);
+            if (cached) serverName = cached.name;
+            if (r.exitCode !== 0) {
+              return { serverId, serverName, rows: [], error: (r.stderr || r.stdout || "exit " + r.exitCode).trim().slice(0, 200) };
+            }
+            const rows = [];
+            for (const line of r.stdout.split("\n")) {
+              const t = line.trim();
+              if (!t) continue;
+              try {
+                rows.push(JSON.parse(t));
+              } catch {
+              }
+            }
+            for (const c of rows) {
+              const m = (c.Labels || "").match(/com\.docker\.compose\.project=([^,]+)/);
+              c.Project = m ? m[1] : "";
+              const status = c.Status || "";
+              if (/\(unhealthy\)/i.test(status)) c.Health = "unhealthy";
+              else if (/\(health: starting\)|\(starting\)/i.test(status)) c.Health = "starting";
+              else if (/\(healthy\)/i.test(status)) c.Health = "healthy";
+              else if (/^Up\b/i.test(status)) c.Health = "no-check";
+              else c.Health = "";
+            }
+            rememberContainers(serverId, rows.map((r2) => r2.Names || "").filter(Boolean));
+            return { serverId, serverName, rows };
+          } catch (err) {
+            return { serverId, serverName, rows: [], error: err instanceof Error ? err.message.slice(0, 200) : String(err).slice(0, 200) };
           }
+        };
+        const perServer = [];
+        for (let i = 0; i < targetIds.length; i += parallelism) {
+          const batch = targetIds.slice(i, i + parallelism);
+          const chunk = await Promise.all(batch.map(probeOne));
+          perServer.push(...chunk);
         }
-        for (const c of containers) {
-          const m = (c.Labels || "").match(/com\.docker\.compose\.project=([^,]+)/);
-          c.Project = m ? m[1] : "";
-          const status = c.Status || "";
-          if (/\(unhealthy\)/i.test(status)) c.Health = "unhealthy";
-          else if (/\(health: starting\)|\(starting\)/i.test(status)) c.Health = "starting";
-          else if (/\(healthy\)/i.test(status)) c.Health = "healthy";
-          else if (/^Up\b/i.test(status)) c.Health = "no-check";
-          else c.Health = "";
-        }
-        let filtered = containers;
-        if (nameFiltersRaw.length > 0) {
+        const applyFilter = (rows) => {
+          if (nameFiltersRaw.length === 0) return rows;
           const matchers = nameFiltersRaw.map((raw) => {
             if (raw.includes("*") || raw.includes("?")) return { kind: "glob", re: globToRegExp(raw) };
             return { kind: "sub", lower: raw.toLowerCase() };
           });
-          filtered = containers.filter((c) => {
+          return rows.filter((c) => {
             const name2 = c.Names || "";
             const lower = name2.toLowerCase();
             return matchers.some((m) => m.kind === "glob" ? m.re.test(name2) : lower.includes(m.lower));
           });
-        }
-        filtered.sort((x, y) => {
+        };
+        const sortRows = (rows) => rows.sort((x, y) => {
           const px = x.Project || "~";
           const py = y.Project || "~";
           const p = px.localeCompare(py);
           return p !== 0 ? p : (x.Names || "").localeCompare(y.Names || "");
         });
+        const fmtRow = (r) => `${(r.Names || "").padEnd(36)}  ${(r.Image || "").padEnd(40)}  ${(r.Status || "").padEnd(24)}  ${(r.Health || "").padEnd(10)}  ${(r.Ports || "").padEnd(40)}`;
+        if (targetIds.length === 1) {
+          const only = perServer[0];
+          if (only.error) return { content: [{ type: "text", text: `Error: ${only.error}` }] };
+          const filtered = sortRows(applyFilter(only.rows));
+          if (format === "json") {
+            const text2 = filtered.map((c) => JSON.stringify(c)).join("\n") || "(no containers)";
+            return { content: [{ type: "text", text: text2 }] };
+          }
+          if (groupByProject) {
+            const groups = /* @__PURE__ */ new Map();
+            for (const c of filtered) {
+              const key = c.Project || "(no compose project)";
+              const list = groups.get(key);
+              if (list) list.push(c);
+              else groups.set(key, [c]);
+            }
+            const out = [];
+            for (const [project, rows] of groups) {
+              out.push(`=== ${project} (${rows.length}) ===`);
+              for (const r of rows) out.push("  " + fmtRow(r));
+              out.push("");
+            }
+            return { content: [{ type: "text", text: out.join("\n").trimEnd() || "(no containers)" }] };
+          }
+          const header = `${"NAMES".padEnd(36)}  ${"IMAGE".padEnd(40)}  ${"STATUS".padEnd(24)}  ${"HEALTH".padEnd(10)}  ${"PORTS".padEnd(40)}  PROJECT`;
+          const body = filtered.map((r) => `${fmtRow(r)}  ${r.Project || ""}`);
+          const text = filtered.length === 0 ? "(no containers match)" : [header, ...body].join("\n");
+          return { content: [{ type: "text", text }] };
+        }
         if (format === "json") {
-          const text2 = filtered.map((c) => JSON.stringify(c)).join("\n") || "(no containers)";
-          return { content: [{ type: "text", text: text2 }] };
+          const lines = [];
+          for (const ps of perServer) {
+            if (ps.error) {
+              lines.push(JSON.stringify({ Server: ps.serverName, Error: ps.error }));
+              continue;
+            }
+            const filtered = sortRows(applyFilter(ps.rows));
+            for (const c of filtered) lines.push(JSON.stringify({ Server: ps.serverName, ...c }));
+          }
+          return { content: [{ type: "text", text: lines.join("\n") || "(no containers)" }] };
         }
-        const fmtRow = (r) => `${(r.Names || "").padEnd(36)}  ${(r.Image || "").padEnd(40)}  ${(r.Status || "").padEnd(24)}  ${(r.Health || "").padEnd(10)}  ${(r.Ports || "").padEnd(40)}`;
-        if (groupByProject) {
-          const groups = /* @__PURE__ */ new Map();
-          for (const c of filtered) {
-            const key = c.Project || "(no compose project)";
-            const list = groups.get(key);
-            if (list) list.push(c);
-            else groups.set(key, [c]);
+        const sections = [];
+        let totalRows = 0;
+        let serversWithRows = 0;
+        for (const ps of perServer) {
+          if (ps.error) {
+            sections.push(`=== ${ps.serverName} === !! ${ps.error}`);
+            continue;
           }
-          const out = [];
-          for (const [project, rows] of groups) {
-            out.push(`=== ${project} (${rows.length}) ===`);
-            for (const r of rows) out.push("  " + fmtRow(r));
-            out.push("");
+          const filtered = sortRows(applyFilter(ps.rows));
+          if (filtered.length === 0) {
+            sections.push(`=== ${ps.serverName} === (no containers match)`);
+            continue;
           }
-          return { content: [{ type: "text", text: out.join("\n").trimEnd() || "(no containers)" }] };
+          serversWithRows++;
+          totalRows += filtered.length;
+          sections.push(`=== ${ps.serverName} (${filtered.length} container(s)) ===`);
+          const header = `${"NAMES".padEnd(36)}  ${"IMAGE".padEnd(40)}  ${"STATUS".padEnd(24)}  ${"HEALTH".padEnd(10)}  ${"PORTS".padEnd(40)}  PROJECT`;
+          sections.push(header);
+          for (const r of filtered) sections.push(`${fmtRow(r)}  ${r.Project || ""}`);
         }
-        const header = `${"NAMES".padEnd(36)}  ${"IMAGE".padEnd(40)}  ${"STATUS".padEnd(24)}  ${"HEALTH".padEnd(10)}  ${"PORTS".padEnd(40)}  PROJECT`;
-        const body = filtered.map((r) => `${fmtRow(r)}  ${r.Project || ""}`);
-        const text = filtered.length === 0 ? "(no containers match)" : [header, ...body].join("\n");
-        return { content: [{ type: "text", text }] };
+        sections.push(`--- fan-out summary: ${totalRows} container(s) across ${serversWithRows}/${perServer.length} server(s) ---`);
+        return { content: [{ type: "text", text: sections.join("\n") }] };
       }
       case "docker-logs": {
         const rawNames = Array.isArray(a.containerName) ? a.containerName.map(String) : [String(a.containerName)];
@@ -3637,37 +4492,71 @@ ${result.stderr}`);
         }
         const sinceArg = sinceRaw ? ` --since ${posixQuote(sinceRaw)}` : "";
         const grepSuffix = grepRaw ? ` | grep -i -E ${posixQuote(grepRaw)} --line-buffered` : "";
-        const { conn, proxy } = await getServerConnection(String(a.serverId));
+        const targetIds = Array.isArray(a.serverIds) && a.serverIds.length > 0 ? a.serverIds.map(String) : a.serverId ? [String(a.serverId)] : [];
+        if (targetIds.length === 0) {
+          return { content: [{ type: "text", text: "Error: pass either `serverId` or `serverIds[]`" }] };
+        }
+        const parallelism = Math.max(1, Math.min(20, Number(a.parallelism) || 5));
         const wallSeconds = followSeconds > 0 ? followSeconds : 30;
-        conn.timeout = (wallSeconds + 10) * 1e3;
         const followFlag = followSeconds > 0 ? " -f" : "";
-        if (containers.length === 1) {
-          const c = containers[0];
-          const inner = `docker logs${followFlag} --tail ${tailArg}${sinceArg} ${c} 2>&1${grepSuffix}`;
-          const cmd2 = `timeout --signal=INT ${wallSeconds} sh -c ${posixQuote(inner)}`;
-          const result2 = await sshExec(conn, cmd2, proxy);
-          const acceptable2 = result2.exitCode === 0 || result2.exitCode === 124 || result2.exitCode === 130 || result2.exitCode === 143 || !!grepRaw && result2.exitCode === 1;
-          if (!acceptable2 && !result2.stdout) {
-            return { content: [{ type: "text", text: `Error (exit ${result2.exitCode}): ${result2.stderr || "(no output)"}` }] };
+        const buildCmd = () => {
+          if (containers.length === 1) {
+            const c = containers[0];
+            const inner = `docker logs${followFlag} --tail ${tailArg}${sinceArg} ${c} 2>&1${grepSuffix}`;
+            return `timeout --signal=INT ${wallSeconds} sh -c ${posixQuote(inner)}`;
           }
-          const note2 = result2.exitCode === 124 ? `
+          const subShells = containers.map((c) => {
+            const inner = `docker logs${followFlag} --tail ${tailArg}${sinceArg} ${c} 2>&1${grepSuffix}`;
+            return `(${inner} | sed -u -e ${posixQuote(`s/^/[${c}] /`)})`;
+          });
+          const innerCmd = subShells.join(" & ") + " & wait";
+          return `timeout --signal=INT ${wallSeconds} sh -c ${posixQuote(innerCmd)}`;
+        };
+        const cmd = buildCmd();
+        const probeOne = async (serverId) => {
+          const { conn, proxy } = await getServerConnection(serverId);
+          conn.timeout = (wallSeconds + 10) * 1e3;
+          const result = await sshExec(conn, cmd, proxy);
+          const cached = KNOWN_SERVER_NAMES.get(serverId);
+          return { serverId, serverName: cached?.name || serverId.slice(0, 8), result };
+        };
+        const acceptableCode = (code) => code === 0 || code === 124 || code === 130 || code === 143 || !!grepRaw && code === 1;
+        if (targetIds.length === 1) {
+          const r = await probeOne(targetIds[0]);
+          const result = r.result;
+          if (!acceptableCode(result.exitCode) && !result.stdout) {
+            const known = getKnownContainers(targetIds[0]);
+            if (known && containers.length === 1) {
+              const hits = suggestSimilar(containers[0], known);
+              const hint = hits.length ? ` Did you mean: ${hits.join(", ")}?` : "";
+              return { content: [{ type: "text", text: `Error (exit ${result.exitCode}): ${result.stderr || "(no output)"}${hint}` }] };
+            }
+            return { content: [{ type: "text", text: `Error (exit ${result.exitCode}): ${result.stderr || "(no output)"}` }] };
+          }
+          const note = result.exitCode === 124 ? `
 (note: command exceeded ${wallSeconds}s wall budget; partial output)` : "";
-          return { content: [{ type: "text", text: (result2.stdout || "(no log lines matched)") + note2 }] };
+          return { content: [{ type: "text", text: (result.stdout || "(no log lines matched)") + note }] };
         }
-        const subShells = containers.map((c) => {
-          const inner = `docker logs${followFlag} --tail ${tailArg}${sinceArg} ${c} 2>&1${grepSuffix}`;
-          return `(${inner} | sed -u -e ${posixQuote(`s/^/[${c}] /`)})`;
-        });
-        const innerCmd = subShells.join(" & ") + " & wait";
-        const cmd = `timeout --signal=INT ${wallSeconds} sh -c ${posixQuote(innerCmd)}`;
-        const result = await sshExec(conn, cmd, proxy);
-        const acceptable = result.exitCode === 0 || result.exitCode === 124 || result.exitCode === 130 || result.exitCode === 143 || !!grepRaw && result.exitCode === 1;
-        if (!acceptable && !result.stdout) {
-          return { content: [{ type: "text", text: `Error (exit ${result.exitCode}): ${result.stderr || "(no output)"}` }] };
+        const perServer = [];
+        for (let i = 0; i < targetIds.length; i += parallelism) {
+          const batch = targetIds.slice(i, i + parallelism);
+          const chunk = await Promise.all(batch.map(probeOne));
+          perServer.push(...chunk);
         }
-        const note = result.exitCode === 124 ? `
-(note: one or more containers exceeded ${wallSeconds}s wall budget; partial output)` : "";
-        return { content: [{ type: "text", text: (result.stdout || "(no log lines matched)") + note }] };
+        const sections = [];
+        let okCount = 0;
+        for (const ps of perServer) {
+          if (acceptableCode(ps.result.exitCode) || ps.result.stdout) {
+            okCount++;
+            const note = ps.result.exitCode === 124 ? `  (timed out after ${wallSeconds}s; partial)` : "";
+            sections.push(`=== ${ps.serverName}${note} ===`);
+            sections.push(ps.result.stdout || "(no log lines matched)");
+          } else {
+            sections.push(`=== ${ps.serverName} === !! exit ${ps.result.exitCode}: ${ps.result.stderr.trim().slice(0, 200) || "(no output)"}`);
+          }
+        }
+        sections.push(`--- fan-out summary: ${okCount}/${perServer.length} server(s) returned logs ---`);
+        return { content: [{ type: "text", text: sections.join("\n") }] };
       }
       case "docker-exec": {
         const container = String(a.container).replace(/[^a-zA-Z0-9._-]/g, "");
@@ -3692,8 +4581,20 @@ ${result.stderr}`);
         const output = [`Exit code: ${result.exitCode}`];
         if (result.stdout) output.push(`--- stdout ---
 ${result.stdout}`);
-        if (result.stderr) output.push(`--- stderr ---
-${result.stderr}`);
+        if (result.stderr) {
+          let stderrOut = result.stderr;
+          const noSuch = /No such container:\s*(\S+)/i.exec(result.stderr);
+          if (noSuch) {
+            const known = getKnownContainers(String(a.serverId));
+            if (known && known.length) {
+              const hits = suggestSimilar(noSuch[1], known);
+              if (hits.length) stderrOut += `
+(hint) Did you mean: ${hits.join(", ")}?`;
+            }
+          }
+          output.push(`--- stderr ---
+${stderrOut}`);
+        }
         return { content: [{ type: "text", text: output.join("\n") }] };
       }
       case "docker-compose": {
@@ -3745,6 +4646,94 @@ ${result.stderr}`);
 ${result.stderr}`);
         return { content: [{ type: "text", text: output.join("\n") }] };
       }
+      // ----- wait-for: poll until a condition holds (one tool, four types) -----
+      case "wait-for": {
+        const type = String(a.type || "");
+        if (!["url", "container-health", "file-exists", "sftp-exists"].includes(type)) {
+          return { content: [{ type: "text", text: "Error: type must be one of: url, container-health, file-exists, sftp-exists" }] };
+        }
+        const timeoutSeconds = Math.max(1, Math.min(1800, Number(a.timeout) || 120));
+        const intervalSeconds = Math.max(1, Math.min(60, Number(a.intervalSeconds) || 3));
+        const deadline = Date.now() + timeoutSeconds * 1e3;
+        const trail = [];
+        const check = async () => {
+          if (type === "url") {
+            const target = String(a.target || "");
+            if (!target) return { ok: false, observed: "no target url" };
+            const expectStatus = a.until !== void 0 ? Number(a.until) : 200;
+            try {
+              const ctrl = new AbortController();
+              const t = setTimeout(() => ctrl.abort(), 1e4);
+              const res = await fetch(target, { signal: ctrl.signal, redirect: "manual" });
+              clearTimeout(t);
+              const ok2 = res.status === expectStatus || expectStatus === 200 && res.status >= 200 && res.status < 300;
+              return { ok: ok2, observed: `HTTP ${res.status}` };
+            } catch (e) {
+              return { ok: false, observed: e instanceof Error ? e.message : String(e) };
+            }
+          }
+          if (type === "container-health") {
+            const containerName = String(a.target || "").replace(/[^a-zA-Z0-9._-]/g, "");
+            const until = String(a.until || "healthy");
+            if (!containerName) return { ok: false, observed: "no container name" };
+            if (!a.serverId) return { ok: false, observed: "serverId is required for container-health" };
+            const { conn: conn2, proxy: proxy2 } = await getServerConnection(String(a.serverId));
+            const cmd2 = `docker inspect --format '{{json .State}}' ${containerName} 2>&1`;
+            const r2 = await sshExec(conn2, cmd2, proxy2);
+            if (r2.exitCode !== 0) return { ok: false, observed: r2.stderr.trim().slice(0, 80) || "inspect failed" };
+            try {
+              const state = JSON.parse(r2.stdout.trim());
+              const healthStatus = state.Health?.Status;
+              if (until === "healthy") {
+                return { ok: healthStatus === "healthy", observed: `Status=${state.Status} Health=${healthStatus || "no-check"}` };
+              }
+              return { ok: state.Status === until, observed: `Status=${state.Status}` };
+            } catch (e) {
+              return { ok: false, observed: "parse error: " + (e instanceof Error ? e.message : String(e)) };
+            }
+          }
+          const bucket = typeof a.bucket === "string" && a.bucket ? a.bucket : "";
+          const path = String(a.target || a.path || "");
+          if (!path) return { ok: false, observed: "no path" };
+          if (bucket) {
+            try {
+              await getR2Client().send(new HeadObjectCommand({ Bucket: bucket, Key: r2Key(path) }));
+              return { ok: true, observed: `r2://${bucket}/${path} exists` };
+            } catch {
+              return { ok: false, observed: `r2://${bucket}/${path} not found` };
+            }
+          }
+          if (!a.serverId) return { ok: false, observed: "serverId or bucket is required for file-exists" };
+          const { conn, proxy } = await getServerConnection(String(a.serverId));
+          const safe = sanitizePath(path);
+          const cmd = `test -e ${posixQuote(safe)} && echo OK || echo MISSING`;
+          const r = await sshExec(conn, cmd, proxy);
+          const ok = r.stdout.trim() === "OK";
+          return { ok, observed: ok ? `${safe} exists` : `${safe} missing` };
+        };
+        let attempts = 0;
+        let lastObserved = "";
+        while (Date.now() < deadline) {
+          attempts++;
+          const r = await check();
+          lastObserved = r.observed;
+          trail.push(`[${attempts}] ${(/* @__PURE__ */ new Date()).toISOString().slice(11, 19)}  ${r.ok ? "OK" : ".."}  ${r.observed}`);
+          if (r.ok) {
+            return { content: [{ type: "text", text: `Condition met after ${attempts} attempt(s) in ${((Date.now() - (deadline - timeoutSeconds * 1e3)) / 1e3).toFixed(1)}s.
+Last observation: ${r.observed}
+
+--- trail ---
+${trail.join("\n")}` }] };
+          }
+          if (Date.now() + intervalSeconds * 1e3 >= deadline) break;
+          await new Promise((res) => setTimeout(res, intervalSeconds * 1e3));
+        }
+        return { content: [{ type: "text", text: `Timed out after ${timeoutSeconds}s without seeing condition (${attempts} probe(s)).
+Last observation: ${lastObserved}
+
+--- trail ---
+${trail.join("\n")}` }] };
+      }
       // ----- Database -----
       case "db-discover": {
         const { conn, proxy } = await getServerConnection(String(a.serverId));
@@ -3776,10 +4765,55 @@ ${result.stderr}`);
       }
       case "db-query": {
         const query = String(a.query).trim();
+        if (!query) return { content: [{ type: "text", text: "Error: query is required" }] };
         assertSafeSql(query);
+        const containerName = typeof a.containerName === "string" && a.containerName ? a.containerName.replace(/[^a-zA-Z0-9._-]/g, "") : "";
+        const explicitEngine = a.engine === "mysql" || a.engine === "postgres" || a.engine === "mssql" ? a.engine : null;
+        const engine = explicitEngine || (containerName ? "postgres" : "mysql");
+        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);
+          return { content: [{ type: "text", text: output2 || "Query executed successfully (no output)" }] };
+        }
+        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")` }] };
+        }
+        const dbName = typeof a.dbName === "string" && a.dbName ? a.dbName.replace(/[^a-zA-Z0-9_-]/g, "") : "";
+        const dbUser = typeof a.dbUser === "string" && a.dbUser ? a.dbUser.replace(/[^a-zA-Z0-9_-]/g, "") : "";
         const { conn, proxy } = await getServerConnection(String(a.serverId));
-        const output = await execSiteMysql(conn, String(a.sitePath), query, proxy);
-        return { content: [{ type: "text", text: output || "Query executed successfully (no output)" }] };
+        let cmd;
+        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`;
+          stdinPayload = query.endsWith(";") ? query : `${query};`;
+        } else if (engine === "mssql") {
+          const user = dbUser || "sa";
+          const dbPass = typeof a.dbPass === "string" ? a.dbPass : "";
+          if (!dbPass) return { content: [{ type: "text", text: "Error: mssql requires dbPass (sqlcmd has no equivalent of pg trust auth)" }] };
+          const dbArg = dbName ? `-d ${dbName} ` : "";
+          cmd = `docker exec -i -e MSSQL_SA_PASSWORD=${posixQuote(dbPass)} ${containerName} /opt/mssql-tools18/bin/sqlcmd -S localhost -U ${user} -P "$MSSQL_SA_PASSWORD" -C ${dbArg}-h -1`;
+          stdinPayload = query.endsWith(";") ? `${query}
+GO
+` : `${query};
+GO
+`;
+        } else {
+          const user = dbUser || "root";
+          const db = 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}`;
+          stdinPayload = query.endsWith(";") ? query : `${query};`;
+        }
+        const result = await sshExec(conn, cmd, proxy, { stdin: stdinPayload });
+        const output = result.stdout.trim() || result.stderr.trim() || "(no output)";
+        if (result.exitCode !== 0 && !result.stdout) {
+          return { content: [{ type: "text", text: `Error (exit ${result.exitCode}, ${engine}): ${output}` }] };
+        }
+        return { content: [{ type: "text", text: output }] };
       }
       // ----- Env Config -----
       case "env-list": {