@supacloud/admin 0.2.0 → 0.3.1

package/README.md

@@ -8,9 +8,20 @@ Typical environment variables:
 
 - `SUPACLOUD_HOST`
 - `SUPACLOUD_SSH_KEY` or `SUPACLOUD_SSH_PASS`
+- `SUPACLOUD_SSH_HOST_FINGERPRINT` — required for SSH actions, in OpenSSH `SHA256:<base64>` form
 - `SUPACLOUD_API_URL`
 - `SUPACLOUD_API_TOKEN`
 
+SSH host keys are fail-closed: setting `SUPACLOUD_HOST` and credentials is not
+enough to enable SSH actions. Obtain the fingerprint through a trusted channel,
+compare it out of band, then set it explicitly. For example, the discovery
+command below is useful only after independently authenticating its result:
+
+```bash
+ssh-keyscan -p 22 server.example.com | ssh-keygen -lf -
+export SUPACLOUD_SSH_HOST_FINGERPRINT='SHA256:...'
+```
+
 Examples:
 
 ```bash

package/dist/index.js

@@ -4759,7 +4759,7 @@ var require_utils = __commonJS((exports, module) => {
 
 // node_modules/ssh2/lib/protocol/crypto/build/Release/sshcrypto.node
 var require_sshcrypto = __commonJS((exports, module) => {
-  module.exports = __require("./sshcrypto-8h5xcwbw.node");
+  module.exports = __require("./sshcrypto-8m50vnmb.node");
 });
 
 // node_modules/ssh2/lib/protocol/crypto/poly1305.js
@@ -33123,6 +33123,10 @@ function date4(params) {
 
 // node_modules/zod/v4/classic/external.js
 config(en_default());
+// src/index.ts
+import { resolve as resolve2 } from "node:path";
+import { pathToFileURL } from "node:url";
+
 // src/shared/cli.ts
 async function runCli(cliTools, args, options = {}) {
   const commandName = options.commandName || "supacloud-admin";
@@ -33382,6 +33386,7 @@ function resolveSupaCloudContext(env = process.env, cwd = process.cwd()) {
     sshPort: parseInt(env.SUPACLOUD_SSH_PORT ?? "22", 10),
     sshKey: env.SUPACLOUD_SSH_KEY ?? resolve(homedir(), ".ssh", "id_rsa"),
     sshPass: env.SUPACLOUD_SSH_PASS ?? "",
+    sshHostFingerprint: env.SUPACLOUD_SSH_HOST_FINGERPRINT ?? "",
     apiUrl,
     apiToken: env.SUPACLOUD_API_TOKEN ?? inferredToken.value,
     projectRef,
@@ -33525,6 +33530,74 @@ class HttpTransport {
 
 // src/shared/transports/ssh.ts
 var import_ssh2 = __toESM(require_lib3(), 1);
+import { timingSafeEqual } from "node:crypto";
+import { readFileSync as readFileSync2 } from "node:fs";
+var DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
+var MAX_CONFIGURABLE_OUTPUT_BYTES = 16 * 1024 * 1024;
+function normalizeSshHostFingerprint(value) {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^SHA256:([A-Za-z0-9+/]{43}=?)$/);
+  if (!match) {
+    throw new Error("SUPACLOUD_SSH_HOST_FINGERPRINT must use OpenSSH SHA256:<base64> format");
+  }
+  const decoded = Buffer.from(match[1], "base64");
+  if (decoded.length !== 32) {
+    throw new Error("SUPACLOUD_SSH_HOST_FINGERPRINT must contain a 32-byte SHA256 digest");
+  }
+  return `SHA256:${match[1].replace(/=+$/, "")}`;
+}
+function createHostVerifier(fingerprint) {
+  const expected = Buffer.from(normalizeSshHostFingerprint(fingerprint).slice("SHA256:".length), "base64");
+  return (actualHash) => {
+    if (!/^[a-f0-9]{64}$/i.test(actualHash))
+      return false;
+    const actual = Buffer.from(actualHash, "hex");
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+  };
+}
+function normalizeMaxOutputBytes(value) {
+  const resolved = value ?? DEFAULT_MAX_OUTPUT_BYTES;
+  if (!Number.isSafeInteger(resolved) || resolved < 1 || resolved > MAX_CONFIGURABLE_OUTPUT_BYTES) {
+    throw new Error(`maxOutputBytes must be an integer between 1 and ${MAX_CONFIGURABLE_OUTPUT_BYTES}`);
+  }
+  return resolved;
+}
+
+class BoundedOutputCollector {
+  limit;
+  storage;
+  bytes = 0;
+  truncated = false;
+  constructor(limit) {
+    this.limit = limit;
+    this.storage = Buffer.allocUnsafe(limit);
+  }
+  append(data) {
+    if (this.truncated)
+      return;
+    const buffer = Buffer.isBuffer(data) ? data : Buffer.from(data);
+    const remaining = this.limit - this.bytes;
+    const copied = Math.min(buffer.length, Math.max(0, remaining));
+    if (copied > 0)
+      buffer.copy(this.storage, this.bytes, 0, copied);
+    this.bytes += copied;
+    this.truncated = buffer.length > copied;
+  }
+  finalize() {
+    let output = this.storage.subarray(0, this.bytes).toString("utf8");
+    if (this.truncated) {
+      const lastNewline = output.lastIndexOf(`
+`);
+      output = lastNewline >= 0 ? output.slice(0, lastNewline + 1) : "";
+    }
+    const redacted = redactSshOutput(output);
+    if (!this.truncated)
+      return redacted;
+    return `${redacted}${redacted && !redacted.endsWith(`
+`) ? `
+` : ""}[TRUNCATED: output exceeded ${this.limit}-byte limit]`;
+  }
+}
 var BLOCKED_COMMANDS = [
   "rm -rf /",
   "mkfs",
@@ -33542,20 +33615,29 @@ var BLOCKED_COMMANDS = [
   "crontab -r",
   "chmod -R 777 /"
 ];
+function redactSshCommand(command) {
+  return command.replace(/(\b[A-Z0-9_]*(?:PASSWORD|PASS|SECRET|TOKEN|KEY|CREDENTIAL)[A-Z0-9_]*=)(?:"[^"]*"|'[^']*'|[^\s;]+)/gi, "$1[REDACTED]").replace(/(Authorization\s*[:=]\s*)(['"]?)Bearer\s+[^'"\s;]+\2/gi, "$1$2Bearer [REDACTED]$2").replace(/(\b--(?:password|token|secret|api-key)\s+)(\S+)/gi, "$1[REDACTED]").replace(/(postgres(?:ql)?:\/\/[^:\s/]+:)[^@\s]+@/gi, "$1[REDACTED]@");
+}
+function redactSshOutput(output) {
+  const redactedLines = output.replace(/^(\s*(?:export\s+)?[A-Z0-9_]*(?:PASSWORD|PASS|SECRET|TOKEN|KEY|CREDENTIAL|DB_URI|DATABASE_URL|DSN)[A-Z0-9_]*\s*=\s*).*$/gim, "$1[REDACTED]");
+  const redactedStructuredFields = redactedLines.replace(/((?:["']?(?:password|pass|secret|token|key|credential|db_uri|database_url|dsn)["']?)\s*:\s*)(?:"[^"]*"|'[^']*'|[^,}\]\r\n]+)/gi, "$1[REDACTED]");
+  return redactSshCommand(redactedStructuredFields);
+}
 function isCommandBlocked(command) {
   const normalized = command.trim().toLowerCase();
   return BLOCKED_COMMANDS.some((blocked) => normalized.includes(blocked));
 }
 var auditLog = [];
 function auditCommand(command, host, blocked) {
-  const entry = { timestamp: new Date().toISOString(), command, host, blocked };
+  const safeCommand = redactSshCommand(command);
+  const entry = { timestamp: new Date().toISOString(), command: safeCommand, host, blocked };
   auditLog.push(entry);
   if (auditLog.length > 1000)
     auditLog.shift();
   if (blocked) {
-    console.error(`[SSH-AUDIT] BLOCKED command on ${host}: ${command}`);
+    console.error(`[SSH-AUDIT] BLOCKED command on ${host}: ${safeCommand}`);
   } else {
-    console.log(`[SSH-AUDIT] Executing on ${host}: ${command.substring(0, 200)}`);
+    console.log(`[SSH-AUDIT] Executing on ${host}: ${safeCommand.substring(0, 200)}`);
   }
 }
 class SshConnectionPool {
@@ -33563,11 +33645,13 @@ class SshConnectionPool {
   maxSize = 3;
   config;
   creating = 0;
-  constructor(config2) {
+  clientFactory;
+  constructor(config2, clientFactory) {
     this.config = config2;
+    this.clientFactory = clientFactory;
   }
   async createConnection() {
-    const conn = new import_ssh2.Client;
+    const conn = this.clientFactory();
     return new Promise((resolve2, reject) => {
       const timeout = setTimeout(() => {
         conn.end();
@@ -33583,8 +33667,10 @@ class SshConnectionPool {
         host: this.config.host,
         port: this.config.port,
         username: this.config.username,
-        ...this.config.privateKeyPath ? { privateKey: __require("fs").readFileSync(this.config.privateKeyPath) } : {},
+        ...this.config.privateKeyPath ? { privateKey: readFileSync2(this.config.privateKeyPath) } : {},
         ...this.config.password ? { password: this.config.password } : {},
+        hostHash: "sha256",
+        hostVerifier: createHostVerifier(this.config.hostFingerprint),
         readyTimeout: 15000,
         keepaliveInterval: 30000
       });
@@ -33627,17 +33713,22 @@ class SshConnectionPool {
 class SshTransport {
   config;
   pool;
-  constructor(config2) {
-    this.config = config2;
-    this.pool = new SshConnectionPool(config2);
+  constructor(config2, options = {}) {
+    this.config = {
+      ...config2,
+      hostFingerprint: normalizeSshHostFingerprint(config2.hostFingerprint || ""),
+      maxOutputBytes: normalizeMaxOutputBytes(config2.maxOutputBytes)
+    };
+    this.pool = new SshConnectionPool(this.config, options.clientFactory ?? (() => new import_ssh2.Client));
   }
   async exec(command, timeoutMs = 300000) {
     if (isCommandBlocked(command)) {
       auditCommand(command, this.config.host, true);
+      const safeCommand = redactSshCommand(command);
       return {
         success: false,
         stdout: "",
-        stderr: `Command blocked by security policy: "${command.substring(0, 100)}". ` + `Destructive or system-altering commands are not allowed via supacloud-admin.`,
+        stderr: `Command blocked by security policy: "${safeCommand.substring(0, 100)}". ` + `Destructive or system-altering commands are not allowed via supacloud-admin.`,
         code: 126
       };
     }
@@ -33645,8 +33736,9 @@ class SshTransport {
     const conn = await this.pool.acquire();
     try {
       return await new Promise((resolve2, reject) => {
-        let stdout = "";
-        let stderr = "";
+        const outputLimit = this.config.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+        const stdout = new BoundedOutputCollector(outputLimit);
+        const stderr = new BoundedOutputCollector(outputLimit);
         const timer = setTimeout(() => {
           conn.end();
           reject(new Error(`SSH command timed out after ${timeoutMs}ms`));
@@ -33658,11 +33750,18 @@ class SshTransport {
           }
           stream.on("close", (code) => {
             clearTimeout(timer);
-            resolve2({ success: code === 0, stdout, stderr, code });
+            resolve2({
+              success: code === 0,
+              stdout: stdout.finalize(),
+              stderr: stderr.finalize(),
+              code,
+              stdoutTruncated: stdout.truncated,
+              stderrTruncated: stderr.truncated
+            });
           }).on("data", (data) => {
-            stdout += data.toString();
+            stdout.append(data);
           }).stderr.on("data", (data) => {
-            stderr += data.toString();
+            stderr.append(data);
           });
         });
       });
@@ -33688,6 +33787,29 @@ class SshTransport {
       this.pool.release(conn);
     }
   }
+  async uploadText(remotePath, content, mode = 384) {
+    auditCommand(`upload ${remotePath} (${Buffer.byteLength(content)} bytes; content redacted)`, this.config.host, false);
+    const conn = await this.pool.acquire();
+    try {
+      await new Promise((resolve2, reject) => {
+        conn.sftp((err, sftp) => {
+          if (err)
+            return reject(err);
+          sftp.writeFile(remotePath, content, { mode }, (writeError) => {
+            if (writeError)
+              return reject(writeError);
+            sftp.chmod(remotePath, mode, (chmodError) => {
+              if (chmodError)
+                return reject(chmodError);
+              resolve2();
+            });
+          });
+        });
+      });
+    } finally {
+      this.pool.release(conn);
+    }
+  }
   async ping() {
     const result = await this.exec("echo pong", 1e4).catch(() => null);
     return result?.stdout.trim() === "pong";
@@ -33698,32 +33820,40 @@ class SshTransport {
 }
 
 // src/shared/tools/ssh-tools.ts
+import { randomUUID } from "node:crypto";
 var SAFE_CONTAINER_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/;
 var SAFE_PROJECT_REF = /^[a-z0-9-]{1,20}$/;
 var SAFE_RELEASE_TAG = /^[a-zA-Z0-9._-]{1,80}$/;
 var SAFE_TIMEOUT_SECONDS = 300;
-var ALLOWED_EXEC_PREFIXES = [
-  "systemctl ",
-  "journalctl ",
-  "docker ps",
-  "docker logs ",
-  "podman ps",
-  "podman logs ",
-  "ps ",
-  "ss ",
-  "df ",
-  "free ",
-  "uname ",
-  "cat /etc/os-release",
-  "tail ",
-  "ls ",
-  "du ",
-  "pg_isready",
-  "curl ",
-  "grep ",
-  "find ",
-  "hostname"
-];
+var SAFE_HOSTNAME = /^(?=.{1,253}$)(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)(?:\.(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?))*$/;
+var SAFE_SYSTEMD_UNIT = /^[a-zA-Z0-9][a-zA-Z0-9_.@:-]{0,127}$/;
+var SAFE_DB_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_-]{0,62}$/;
+function hostnameSchema(fieldName) {
+  return exports_external.string().trim().min(1).max(253).refine((value) => SAFE_HOSTNAME.test(value), { message: `Invalid ${fieldName}` }).transform((value) => value.toLowerCase());
+}
+function secretSchema(fieldName) {
+  return exports_external.string().min(12, `${fieldName} must contain at least 12 characters`).max(256, `${fieldName} must contain at most 256 characters`).refine((value) => value === value.trim() && !/[\u0000-\u001f\u007f]/.test(value), {
+    message: `Invalid ${fieldName}`
+  });
+}
+function quoteEnvValue(value) {
+  return `'${value.split("'").join("'\\''")}'`;
+}
+var REMOTE_ENV_REDACTION_AWK = `awk -F= 'BEGIN { IGNORECASE=1 } /^[A-Za-z_][A-Za-z0-9_]*=/ { key=$1; if (key ~ /(PASSWORD|PASS|SECRET|TOKEN|KEY|CREDENTIAL|DB_URI|DATABASE_URL|DSN)/) print key "=[REDACTED]"; else print; next } { print }'`;
+function redactTenantConfig(value) {
+  const redactedLines = value.split(/\r?\n/).map((line) => {
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match)
+      return line;
+    const key = match[1];
+    if (!/(?:PASSWORD|PASS|SECRET|TOKEN|KEY|CREDENTIAL|DB_URI|DATABASE_URL|DSN)/i.test(key)) {
+      return line;
+    }
+    return `${key}=[REDACTED]`;
+  }).join(`
+`);
+  return redactedLines.replace(/\b([A-Za-z_][A-Za-z0-9_]*(?:PASSWORD|PASS|SECRET|TOKEN|KEY|CREDENTIAL|DB_URI|DATABASE_URL|DSN)[A-Za-z0-9_]*)=(?:"[^"]*"|'[^']*'|\S+)/gi, "$1=[REDACTED]").replace(/\b(postgres(?:ql)?:\/\/[^:\s/@]+:)[^@\s]+@/gi, "$1[REDACTED]@");
+}
 function assertSafeProjectRef(value, fieldName) {
   if (!SAFE_PROJECT_REF.test(value)) {
     throw new Error(`Invalid ${fieldName}`);
@@ -33744,21 +33874,21 @@ function assertSafeReleaseTag(value) {
 }
 function assertSafeGithubProxy(value) {
   const trimmed = value.trim();
-  if (/[\s\n\r;&|`$<>]/.test(trimmed)) {
+  if (/[\s\n\r;&|`$<>{}\[\]()*!?\\'\"]/.test(trimmed)) {
     throw new Error("Invalid github_proxy");
   }
   if (trimmed.toLowerCase() === "direct" || trimmed.toLowerCase() === "none") {
     return trimmed;
   }
   const parsed = new URL(trimmed);
-  if (!["http:", "https:"].includes(parsed.protocol)) {
-    throw new Error("Invalid github_proxy protocol");
+  if (parsed.protocol !== "https:") {
+    throw new Error("Invalid github_proxy protocol: HTTPS is required");
+  }
+  if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+    throw new Error("Invalid github_proxy: credentials, query strings, and fragments are not allowed");
   }
   return parsed.toString();
 }
-function deriveStudioDomain(publicDomain) {
-  return `studio.${publicDomain.trim().replace(/^(?:api|studio)\./i, "")}`;
-}
 function getExecTimeoutMs(timeoutSeconds) {
   const seconds = timeoutSeconds || 60;
   if (!Number.isFinite(seconds) || seconds <= 0 || seconds > SAFE_TIMEOUT_SECONDS) {
@@ -33771,13 +33901,113 @@ function assertSafeExecCommand(command) {
   if (!trimmed) {
     throw new Error("'command' required");
   }
-  if (/[\n\r;&|`$<>]/.test(trimmed)) {
-    throw new Error("Unsafe shell metacharacters are not allowed in exec command");
+  const reject = () => {
+    throw new Error("Command is outside the allowed read-only diagnostic grammar");
+  };
+  if (!/^[\x20-\x7e]+$/.test(trimmed) || /[\n\r;&|`$<>\\'\"()[\]{}*?!~#]/.test(trimmed))
+    reject();
+  const tokens = trimmed.split(/\s+/);
+  const commandName = tokens[0];
+  if (commandName === "systemctl") {
+    const action = tokens[1];
+    if (["list-units", "list-unit-files"].includes(action)) {
+      if (tokens.length === 2 || tokens.length === 3 && tokens[2] === "--no-pager")
+        return trimmed;
+      reject();
+    }
+    if (["status", "is-active", "is-enabled"].includes(action) && SAFE_SYSTEMD_UNIT.test(tokens[2] || "")) {
+      if (tokens.length === 3 || tokens.length === 4 && tokens[3] === "--no-pager")
+        return trimmed;
+    }
+    reject();
+  }
+  if (commandName === "journalctl") {
+    let unit = "";
+    let tailCount = "";
+    let noPager = false;
+    for (let index = 1;index < tokens.length; index += 1) {
+      const token = tokens[index];
+      if (token === "-u" && !unit) {
+        unit = tokens[++index] || "";
+        if (!SAFE_SYSTEMD_UNIT.test(unit))
+          reject();
+      } else if (token === "-n" && !tailCount) {
+        tailCount = tokens[++index] || "";
+        const count = Number(tailCount);
+        if (!/^\d+$/.test(tailCount) || count < 1 || count > 1000)
+          reject();
+      } else if (token === "--no-pager" && !noPager) {
+        noPager = true;
+      } else {
+        reject();
+      }
+    }
+    if (unit && tailCount && noPager)
+      return trimmed;
+    reject();
+  }
+  if (commandName === "docker" || commandName === "podman") {
+    const action = tokens[1];
+    if (action === "ps") {
+      const flags = tokens.slice(2);
+      if (flags.every((flag, index) => ["-a", "--no-trunc"].includes(flag) && flags.indexOf(flag) === index)) {
+        return trimmed;
+      }
+      reject();
+    }
+    if (action === "logs") {
+      let index = 2;
+      if (tokens[index] !== "--tail")
+        reject();
+      const countToken = tokens[index + 1] || "";
+      const count = Number(countToken);
+      if (!/^\d+$/.test(countToken) || count < 1 || count > 1000)
+        reject();
+      index += 2;
+      if (index === tokens.length - 1 && SAFE_CONTAINER_NAME.test(tokens[index] || ""))
+        return trimmed;
+      reject();
+    }
+    reject();
   }
-  if (!ALLOWED_EXEC_PREFIXES.some((prefix) => trimmed === prefix.trimEnd() || trimmed.startsWith(prefix))) {
-    throw new Error("Command is outside the allowed diagnostic command set");
+  if (commandName === "ps" && trimmed === "ps -eo pid,user,comm")
+    return trimmed;
+  if (commandName === "ss" && ["ss -s", "ss -tlnp", "ss -lntp"].includes(trimmed))
+    return trimmed;
+  if (commandName === "df" && (trimmed === "df -h" || /^df -h (?:\/|\/var|\/tmp)$/.test(trimmed)))
+    return trimmed;
+  if (commandName === "free" && ["free", "free -h", "free -m"].includes(trimmed))
+    return trimmed;
+  if (commandName === "uname" && ["uname", "uname -a", "uname -r", "uname -m"].includes(trimmed))
+    return trimmed;
+  if (trimmed === "cat /etc/os-release")
+    return trimmed;
+  if (commandName === "hostname" && ["hostname", "hostname -f"].includes(trimmed))
+    return trimmed;
+  if (commandName === "pg_isready") {
+    const seen = new Set;
+    for (let index = 1;index < tokens.length; index += 2) {
+      const option = tokens[index];
+      const optionValue = tokens[index + 1];
+      if (!optionValue || seen.has(option))
+        reject();
+      seen.add(option);
+      if (option === "-h" && !["localhost", "127.0.0.1", "::1"].includes(optionValue))
+        reject();
+      else if (option === "-p") {
+        const port = Number(optionValue);
+        if (!/^\d+$/.test(optionValue) || port < 1 || port > 65535)
+          reject();
+      } else if (["-U", "-d"].includes(option)) {
+        if (!SAFE_DB_IDENTIFIER.test(optionValue))
+          reject();
+      } else if (option !== "-h") {
+        reject();
+      }
+    }
+    return trimmed;
   }
-  return trimmed;
+  return reject();
 }
 function registerSshTools(server, ssh) {
   server.tool("ssh", `Server management via SSH. Available before & after SupaCloud installation.
@@ -33799,14 +34029,14 @@ Actions: ping, setup, install, upgrade, diagnose, exec, troubleshoot, container_
     ]).describe("Action to perform"),
     command: exports_external.string().optional().describe("[exec] Restricted shell command to execute"),
     timeout_seconds: exports_external.number().optional().describe("[exec] Timeout in seconds (default: 60)"),
-    public_domain: exports_external.string().optional().describe("[install] API domain, e.g. api.example.com"),
-    studio_domain: exports_external.string().optional().describe("[install] Studio domain"),
-    postgres_password: exports_external.string().optional().describe("[install] DB password (auto-generated if empty)"),
-    dashboard_password: exports_external.string().optional().describe("[install] Console password"),
+    public_domain: hostnameSchema("public_domain").optional().describe("[install] API domain, e.g. api.example.com"),
+    studio_domain: hostnameSchema("studio_domain").optional().describe("[install] Studio domain"),
+    postgres_password: secretSchema("postgres_password").optional().describe("[install] DB password (auto-generated if empty)"),
+    dashboard_password: secretSchema("dashboard_password").optional().describe("[install] Console password"),
     edge_runtime: exports_external.enum(["bun"]).optional().describe("[install] Runtime (default: bun)"),
-    storage_type: exports_external.enum(["juicefs", "garage", "rustfs", "minio", "external"]).optional().describe("[install] Storage backend"),
+    storage_type: exports_external.enum(["juicefs", "minio"]).optional().describe("[install] Storage backend configurable through Admin"),
     version: exports_external.string().optional().describe("[upgrade] Specific version"),
-    github_proxy: exports_external.string().optional().describe("[upgrade] GitHub proxy prefix, e.g. https://ghproxy.net/ or direct"),
+    github_proxy: exports_external.string().optional().describe("[install/upgrade] Explicit GitHub proxy prefix, or direct/none"),
     focus: exports_external.enum(["all", "containers", "database", "network", "disk", "logs"]).optional().describe("[troubleshoot] Focus area"),
     container: exports_external.string().optional().describe("[container_logs] Container name"),
     lines: exports_external.number().optional().describe("[container_logs] Number of log lines (default: 100)"),
@@ -33827,15 +34057,11 @@ Actions: ping, setup, install, upgrade, diagnose, exec, troubleshoot, container_
       }
       case "setup": {
         const baseTools = await ssh.exec("if ! command -v git &>/dev/null; then " + "  if command -v dnf &>/dev/null; then dnf install -y git; " + "  elif command -v yum &>/dev/null; then yum install -y git; " + "  elif command -v apt-get &>/dev/null; then apt-get update && apt-get install -y git; fi; " + "fi; " + "if command -v dnf &>/dev/null; then dnf install -y compat-openssl11 libatomic 2>/dev/null; " + "elif command -v yum &>/dev/null; then yum install -y compat-openssl11 libatomic 2>/dev/null; fi; " + "ldconfig 2>/dev/null; git --version; openssl version");
-        const sshSetup = await ssh.exec("mkdir -p ~/.ssh && chmod 700 ~/.ssh && " + "if [ ! -f ~/.ssh/id_ed25519 ]; then ssh-keygen -t ed25519 -N '' -f ~/.ssh/id_ed25519; fi && " + "cat ~/.ssh/id_ed25519.pub >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys && " + "sed -i 's/^#\\?PermitRootLogin.*/PermitRootLogin yes/' /etc/ssh/sshd_config && " + "sed -i 's/^#\\?PubkeyAuthentication.*/PubkeyAuthentication yes/' /etc/ssh/sshd_config && " + "grep -q '^PermitRootLogin' /etc/ssh/sshd_config || echo 'PermitRootLogin yes' >> /etc/ssh/sshd_config && " + "systemctl restart sshd || service ssh restart");
-        await ssh.exec("sleep 2");
-        await ssh.exec("IP=$(hostname -I | cut -d' ' -f1) && ssh-keyscan -H localhost 127.0.0.1 $IP >> ~/.ssh/known_hosts 2>/dev/null && chmod 600 ~/.ssh/known_hosts");
-        const verify = await ssh.exec("ssh -o StrictHostKeyChecking=no root@localhost 'echo SSH_SELF_OK'");
-        const ok = verify.stdout.includes("SSH_SELF_OK");
+        const verify = await ssh.exec("echo SSH_SESSION_OK");
+        const ok = verify.success && verify.stdout.includes("SSH_SESSION_OK");
         text = [
-          ok ? "✅ SSH configured" : "❌ SSH verification failed",
+          ok ? "✅ SSH session verified" : "❌ SSH session verification failed",
           `Tools: ${baseTools.stdout.trim()}`,
-          `SSH: exit ${sshSetup.code}`,
           `Verify: ${verify.stdout.trim() || verify.stderr.trim()}`
         ].join(`
 `);
@@ -33844,40 +34070,93 @@ Actions: ping, setup, install, upgrade, diagnose, exec, troubleshoot, container_
       case "install": {
         if (!args.public_domain)
           throw new Error("'public_domain' required");
-        const DIR = "/opt/supacloud", LOG = "/tmp/supacloud-install.log";
+        const installId = randomUUID();
+        const DIR = "/opt/supacloud";
+        const LOG = `/var/log/supacloud/install-${installId}.log`;
+        const STATUS = `/var/log/supacloud/install-${installId}.status`;
+        const CONFIG = "/etc/supabase/install.env";
+        const INPUT = `/etc/supabase/.install-input-${installId}.env`;
+        const BOOTSTRAP = `/opt/.supacloud-bootstrap-${installId}`;
         const REPO = "https://github.com/zuohuadong/supacloud.git";
+        const configuredProxy = args.github_proxy ? assertSafeGithubProxy(args.github_proxy) : "direct";
+        const proxyDisabled = ["direct", "none"].includes(configuredProxy.toLowerCase());
+        const proxyPrefix = proxyDisabled ? "" : configuredProxy.endsWith("/") ? configuredProxy : `${configuredProxy}/`;
+        const bootstrapClone = `git clone --depth 1 --branch main ${quoteEnvValue(REPO)} ${quoteEnvValue(BOOTSTRAP)}`;
+        const bootstrapDeps = await ssh.exec(`set -e; ` + `if ! command -v git >/dev/null 2>&1 || ! command -v curl >/dev/null 2>&1; then ` + `if command -v apt-get >/dev/null 2>&1; then ` + `apt-get update; DEBIAN_FRONTEND=noninteractive apt-get install -y git curl ca-certificates; ` + `elif command -v dnf >/dev/null 2>&1; then ` + `dnf install -y git curl ca-certificates; ` + `elif command -v yum >/dev/null 2>&1; then ` + `yum install -y git curl ca-certificates; ` + `else echo 'No supported package manager can install git and curl' >&2; exit 127; fi; ` + `fi; ` + `command -v git >/dev/null 2>&1; command -v curl >/dev/null 2>&1; ` + `echo BOOTSTRAP_DEPS_OK`, 180000);
+        if (!bootstrapDeps.success || !bootstrapDeps.stdout.includes("BOOTSTRAP_DEPS_OK")) {
+          text = `❌ Bootstrap dependency preparation failed
+${bootstrapDeps.stderr.slice(-500)}`;
+          break;
+        }
         const osCheck = await ssh.exec("cat /etc/os-release | grep -E 'NAME|VERSION_ID' | head -4");
-        const clone2 = await ssh.exec(`if [ -d "${DIR}/.git" ]; then git -C ${DIR} pull --ff-only; else git clone https://ghproxy.net/${REPO} ${DIR} 2>/dev/null || git clone ${REPO} ${DIR}; fi; echo CLONE_OK`, 120000);
-        if (!clone2.stdout.includes("CLONE_OK")) {
-          text = `❌ Clone failed
+        const clone2 = await ssh.exec(`set -e; umask 077; rm -rf ${quoteEnvValue(BOOTSTRAP)}; ` + `${bootstrapClone}; ` + `git -C ${quoteEnvValue(BOOTSTRAP)} remote set-url origin ${quoteEnvValue(REPO)}; ` + `test "$(git -C ${quoteEnvValue(BOOTSTRAP)} remote get-url origin)" = ${quoteEnvValue(REPO)}; ` + `test "$(git -C ${quoteEnvValue(BOOTSTRAP)} symbolic-ref --short HEAD)" = main; ` + `test -z "$(git -C ${quoteEnvValue(BOOTSTRAP)} status --porcelain --untracked-files=no)"; ` + `git -C ${quoteEnvValue(BOOTSTRAP)} ls-files --error-unmatch setup.sh scripts/lib/install_config.sh scripts/lib/release_assets.sh >/dev/null; ` + `test -f ${quoteEnvValue(`${BOOTSTRAP}/setup.sh`)}; echo BOOTSTRAP_OK`, 120000);
+        if (!clone2.stdout.includes("BOOTSTRAP_OK")) {
+          await ssh.exec(`rm -rf ${quoteEnvValue(BOOTSTRAP)}`);
+          text = `❌ Trusted bootstrap clone failed
 ${clone2.stderr.slice(-500)}`;
           break;
         }
+        const prepareProtectedPaths = await ssh.exec(`umask 077; install -d -m 700 /etc/supabase /var/log/supacloud; ` + `: > ${quoteEnvValue(LOG)}; : > ${quoteEnvValue(STATUS)}; ` + `chmod 600 ${quoteEnvValue(LOG)} ${quoteEnvValue(STATUS)}`);
+        if (!prepareProtectedPaths.success) {
+          await ssh.exec(`rm -rf ${quoteEnvValue(BOOTSTRAP)}`);
+          text = `❌ Unable to prepare protected install input and log paths
+${prepareProtectedPaths.stderr.slice(-500)}`;
+          break;
+        }
         const envLines = [
-          `SUPABASE_PUBLIC_DOMAIN=${args.public_domain}`,
-          `SUPABASE_STUDIO_DOMAIN=${args.studio_domain ?? deriveStudioDomain(args.public_domain)}`,
-          `EDGE_RUNTIME=${args.edge_runtime || "bun"}`,
-          `S3_STORAGE_TYPE=${args.storage_type || "juicefs"}`,
-          args.postgres_password ? `POSTGRES_PASSWORD=${args.postgres_password}` : "",
-          args.dashboard_password ? `DASHBOARD_PASSWORD=${args.dashboard_password}` : ""
+          `SUPABASE_PUBLIC_DOMAIN=${quoteEnvValue(args.public_domain)}`,
+          args.studio_domain ? `SUPABASE_STUDIO_DOMAIN=${quoteEnvValue(args.studio_domain)}` : "",
+          args.edge_runtime ? `EDGE_RUNTIME=${quoteEnvValue(args.edge_runtime)}` : "",
+          args.storage_type ? `S3_STORAGE_TYPE=${quoteEnvValue(args.storage_type)}` : "",
+          args.postgres_password ? `POSTGRES_PASSWORD=${quoteEnvValue(args.postgres_password)}` : "",
+          args.dashboard_password ? `DASHBOARD_PASSWORD=${quoteEnvValue(args.dashboard_password)}` : ""
         ].filter(Boolean).join(`
 `);
-        await ssh.exec(`cat > ${DIR}/config.env << 'ENVEOF'
-${envLines}
-ENVEOF`);
-        const result = await ssh.exec(`chmod +x ${DIR}/install.sh && nohup bash ${DIR}/install.sh > ${LOG} 2>&1 & && INSTALL_PID=$! && sleep 3 && kill -0 $INSTALL_PID 2>/dev/null && echo "INSTALL_STARTED pid=$INSTALL_PID" || echo 'INSTALL_FAILED'`, 30000);
-        text = result.stdout.includes("INSTALL_STARTED") ? `✅ Installation started
+        try {
+          await ssh.uploadText(INPUT, `${envLines}
+`, 384);
+        } catch (error51) {
+          await ssh.exec(`rm -f ${quoteEnvValue(INPUT)}; rm -rf ${quoteEnvValue(BOOTSTRAP)}`);
+          throw error51;
+        }
+        const setupEnv = [
+          `SUPACLOUD_INSTALL_DIR=${quoteEnvValue(DIR)}`,
+          "SUPACLOUD_SETUP_ARTIFACT_MODE=release",
+          "SUPACLOUD_FORCE_VERIFIED_RELEASE_ASSETS=true",
+          `SUPACLOUD_SETUP_INPUT_FILE=${quoteEnvValue(INPUT)}`,
+          `SUPACLOUD_INSTALL_CONFIG_FILE=${quoteEnvValue(CONFIG)}`,
+          proxyPrefix ? `SUPACLOUD_GITHUB_PROXY=${quoteEnvValue(configuredProxy)}` : ""
+        ].filter(Boolean).join(" ");
+        const statusNext = `${STATUS}.next`;
+        const backgroundScript = [
+          "set +e",
+          `trap "rm -f ${quoteEnvValue(INPUT)}; rm -rf ${quoteEnvValue(BOOTSTRAP)}" EXIT`,
+          `printf 'RUNNING\\n' > ${quoteEnvValue(statusNext)}`,
+          `chmod 600 ${quoteEnvValue(statusNext)}`,
+          `mv -f ${quoteEnvValue(statusNext)} ${quoteEnvValue(STATUS)}`,
+          `env ${setupEnv} bash ${quoteEnvValue(`${BOOTSTRAP}/setup.sh`)}`,
+          "INSTALL_CODE=$?",
+          `if [ "$INSTALL_CODE" -eq 0 ]; then printf 'SUCCEEDED\\n' > ${quoteEnvValue(statusNext)}; ` + `else printf 'FAILED:%s\\n' "$INSTALL_CODE" > ${quoteEnvValue(statusNext)}; fi`,
+          `chmod 600 ${quoteEnvValue(statusNext)}`,
+          `mv -f ${quoteEnvValue(statusNext)} ${quoteEnvValue(STATUS)}`,
+          'exit "$INSTALL_CODE"'
+        ].join("; ");
+        const result = await ssh.exec(`umask 077; nohup bash -c ${quoteEnvValue(backgroundScript)} > ${quoteEnvValue(LOG)} 2>&1 </dev/null & ` + `INSTALL_PID=$!; sleep 5; ` + `INSTALL_STATE=$(sed -n '1p' ${quoteEnvValue(STATUS)} 2>/dev/null || true); ` + `case "$INSTALL_STATE" in ` + `RUNNING) if kill -0 "$INSTALL_PID" 2>/dev/null; then echo "INSTALL_STARTED pid=$INSTALL_PID"; ` + `else wait "$INSTALL_PID" 2>/dev/null; INSTALL_CODE=$?; ` + `echo "INSTALL_FAILED code=$INSTALL_CODE state=$INSTALL_STATE"; exit 1; fi ;; ` + `SUCCEEDED) echo "INSTALL_COMPLETED pid=$INSTALL_PID" ;; ` + `FAILED:*) INSTALL_CODE=$(printf '%s' "$INSTALL_STATE" | cut -d: -f2); ` + `echo "INSTALL_FAILED code=$INSTALL_CODE"; exit 1 ;; ` + `*) echo "INSTALL_FAILED code=unknown state=$INSTALL_STATE"; exit 1 ;; esac`, 30000);
+        const installAccepted = result.stdout.includes("INSTALL_STARTED") || result.stdout.includes("INSTALL_COMPLETED");
+        text = installAccepted ? `✅ Installation started
 OS: ${osCheck.stdout.trim()}
 ${result.stdout.trim()}
 Log: ${LOG}
+Status: ${STATUS}
 ⏱ ~15-30 min` : `❌ Start failed
+${result.stdout.slice(-500)}
 ${result.stderr.slice(-500)}`;
         break;
       }
       case "upgrade": {
         const envParts = [
           args.version ? `SUPACLOUD_UPGRADE_TAG=${assertSafeReleaseTag(args.version)}` : "",
-          args.github_proxy ? `SUPACLOUD_GITHUB_PROXY=${assertSafeGithubProxy(args.github_proxy)}` : ""
+          args.github_proxy ? `SUPACLOUD_GITHUB_PROXY=${quoteEnvValue(assertSafeGithubProxy(args.github_proxy))}` : ""
         ].filter(Boolean);
         const envPrefix = envParts.length > 0 ? `${envParts.join(" ")} ` : "";
         const cmd = "if [ ! -x /usr/local/bin/supacloud ]; then " + "echo 'SupaCloud binary not found at /usr/local/bin/supacloud; run ssh install first.' >&2; exit 127; " + `fi; ${envPrefix}/usr/local/bin/supacloud upgrade --yes`;
@@ -33894,7 +34173,7 @@ ${r.stderr.slice(-500)}`;
           "echo '=== Disk ===' && df -h /",
           "echo '=== Docker ===' && (docker ps --format 'table {{.Names}}\t{{.Status}}' 2>/dev/null || echo 'Not found')",
           "echo '=== PostgreSQL ===' && (pg_isready 2>/dev/null && echo 'Running' || echo 'Not detected')",
-          "echo '=== Management API ===' && (curl -sf http://localhost:9090/v1/projects > /dev/null && echo 'Running' || echo 'Not running')"
+          "echo '=== Management API ===' && (curl -sf http://localhost:9090/health > /dev/null && echo 'Running' || echo 'Not running')"
         ];
         const r = await ssh.exec(cmds.join(" && "));
         text = r.stdout || r.stderr;
@@ -33929,7 +34208,7 @@ ${r.stderr.slice(-500)}`;
         if (f === "all" || f === "network")
           checks3.push("echo '══════ Ports ══════'", "ss -tlnp | grep -E ':(80|443|5432|8000|9090|3000) ' 2>/dev/null || echo 'N/A'");
         if (f === "all" || f === "logs")
-          checks3.push("echo '══════ Install Log ══════'", "(tail -50 /var/log/supacloud-install.log 2>/dev/null || tail -50 /tmp/supacloud-install.log 2>/dev/null || echo 'Not found')");
+          checks3.push("echo '══════ Install Log ══════'", `(latest_log=$(find /var/log/supacloud -maxdepth 1 -type f -name 'install-*.log' -printf '%T@ %p\\n' 2>/dev/null | sort -nr | head -1 | cut -d' ' -f2-); [ -n "$latest_log" ] && tail -50 "$latest_log" || echo 'Not found')`);
         if (f === "all" || f === "disk")
           checks3.push("echo '══════ Large Dirs ══════'", "du -sh /var/lib/postgresql /var/lib/docker 2>/dev/null | sort -rh | head -10");
         const r = await ssh.exec(checks3.join(`
@@ -33981,26 +34260,40 @@ ${r.stdout}`;
         if (!args.project_ref)
           throw new Error("'project_ref' required");
         const projectRef = assertSafeProjectRef(args.project_ref, "project_ref");
-        const r = await ssh.exec(`cat /etc/supabase/tenants/${projectRef}.env 2>/dev/null || echo 'Not found'`, 1e4);
-        text = `\uD83D\uDCC4 ${projectRef} tenant config:
-
-${r.stdout || r.stderr}`;
+        const r = await ssh.exec([
+          "set -eu",
+          "found=0",
+          `for file in /etc/supabase/tenants/${projectRef}.env /etc/supabase/tenants/${projectRef}_gotrue.env; do`,
+          '  [ -f "$file" ] || continue',
+          "  found=1",
+          `  printf '
+# %s
+' "$(basename "$file")"`,
+          `  ${REMOTE_ENV_REDACTION_AWK} "$file"`,
+          "done",
+          `[ "$found" -eq 1 ] || { echo 'Tenant config not found' >&2; exit 1; }`
+        ].join(`
+`), 1e4);
+        const output = redactTenantConfig(r.stdout || r.stderr);
+        text = r.success ? `\uD83D\uDCC4 ${projectRef} tenant config (sensitive values redacted):
+${output}` : `❌ Unable to inspect ${projectRef}:
+${output}`;
         break;
       }
       case "tenant_diagnose": {
         const checks3 = [
           "echo '══════ Multi-tenant Diagnostic ══════'",
-          "ps aux | grep -E 'postgrest|gotrue' | grep -v grep || echo 'No processes'",
+          "ps -eo pid=,user=,comm= | grep -E 'postgrest|gotrue' | grep -v grep || echo 'No processes'",
           "systemctl list-units 'supacloud-pgrst@*' 'supacloud-gotrue@*' --no-pager 2>/dev/null || echo 'N/A'",
           "ls -l /etc/supabase/tenants/*.env 2>/dev/null || echo 'No config'"
         ];
         if (args.project_ref) {
           const projectRef = assertSafeProjectRef(args.project_ref, "project_ref");
-          checks3.push(`systemctl status supacloud-pgrst@${projectRef} --no-pager 2>/dev/null || echo 'Not found'`, `cat /etc/supabase/tenants/${projectRef}.env 2>/dev/null | grep -v PASSWORD | grep -v SECRET || echo 'N/A'`);
+          checks3.push(`systemctl status supacloud-pgrst@${projectRef} --no-pager 2>/dev/null || echo 'Not found'`, `for file in /etc/supabase/tenants/${projectRef}.env /etc/supabase/tenants/${projectRef}_gotrue.env; do [ -f "$file" ] && ${REMOTE_ENV_REDACTION_AWK} "$file"; done`);
         }
         const r = await ssh.exec(checks3.join(`
 `), 30000);
-        text = r.stdout || r.stderr;
+        text = redactTenantConfig(r.stdout || r.stderr);
         break;
       }
       case "tenant_migrate": {
@@ -34008,21 +34301,31 @@ ${r.stdout || r.stderr}`;
           throw new Error("'source_ref' and 'target_ref' required");
         const sourceRef = assertSafeProjectRef(args.source_ref, "source_ref");
         const targetRef = assertSafeProjectRef(args.target_ref, "target_ref");
+        if (sourceRef === targetRef)
+          throw new Error("source_ref and target_ref must be different");
         const s = args.schemas || "public,auth,storage";
         if (!/^[a-z_,\s]+$/.test(s))
           throw new Error("Invalid schemas");
-        const schemaArgs = s.split(",").map((x) => x.trim()).filter(Boolean).map((x) => `-n ${x}`).join(" ");
+        const schemas3 = s.split(",").map((x) => x.trim()).filter(Boolean);
+        if (schemas3.length === 0)
+          throw new Error("At least one schema is required");
+        const schemaArgs = schemas3.map((schema) => `-n ${schema}`).join(" ");
         const df = args.data_only ? "--data-only" : "";
         const cmd = [
+          "set -euo pipefail",
+          "umask 077",
+          'tmp_dir="$(mktemp -d /tmp/supacloud-migrate.XXXXXX)"',
+          'dump_file="$tmp_dir/tenant.dump"',
+          `trap 'rm -rf "$tmp_dir"' EXIT HUP INT TERM`,
           `echo 'Migrating: supa_${sourceRef} → supa_${targetRef}'`,
-          `pg_dump -h localhost -U postgres -d supa_${sourceRef} ${schemaArgs} ${df} -Fc -f /tmp/migrate.dump 2>&1`,
-          `pg_restore -h localhost -U postgres -d supa_${targetRef} --no-owner --no-acl /tmp/migrate.dump 2>&1 || true`,
-          `rm -f /tmp/migrate.dump && echo '✅ Done'`
+          `pg_dump -h localhost -U postgres -d supa_${sourceRef} ${schemaArgs} ${df} -Fc -f "$dump_file"`,
+          `pg_restore -h localhost -U postgres -d supa_${targetRef} --no-owner --no-acl --exit-on-error "$dump_file"`,
+          "echo 'Migration complete'"
         ].join(`
 `);
         const r = await ssh.exec(cmd, 600000);
         text = r.success ? `✅ Migration done
-${r.stdout}` : `❌ Errors
+${r.stdout}` : `❌ Migration failed (exit ${r.code})
 ${r.stdout}
 ${r.stderr.slice(-1000)}`;
         break;
@@ -34736,6 +35039,7 @@ EXPECTED CONTEXT
   Platform commands typically rely on:
     SUPACLOUD_HOST
     SUPACLOUD_SSH_KEY / SUPACLOUD_SSH_PASS
+    SUPACLOUD_SSH_HOST_FINGERPRINT=SHA256:...
     SUPACLOUD_API_URL
     SUPACLOUD_API_TOKEN
 
@@ -34756,8 +35060,7 @@ EXAMPLES
   supacloud-admin gateway rebuild --ref abc123 --clean
 `);
 }
-function createAdminTools() {
-  const context = resolveSupaCloudContext();
+function createAdminTools(context = resolveSupaCloudContext()) {
   const tools = {
     status: {
       schema: {},
@@ -34771,6 +35074,7 @@ function createAdminTools() {
               apiUrl: context.apiUrl || null,
               hasApiToken: Boolean(context.apiToken),
               hasSshKey: Boolean(context.sshKey),
+              hasSshHostFingerprint: Boolean(context.sshHostFingerprint),
               source: context.source
             }, null, 2)
           }
@@ -34807,7 +35111,7 @@ function createAdminTools() {
         content: [
           {
             type: "text",
-            text: "⚠️ SSH commands require SUPACLOUD_HOST plus SSH credentials."
+            text: "⚠️ SSH commands require SUPACLOUD_HOST, SSH credentials, and SUPACLOUD_SSH_HOST_FINGERPRINT."
           }
         ]
       })
@@ -34825,15 +35129,44 @@ function createAdminTools() {
     };
   };
   registerAdminHelp();
-  if (context.host) {
-    const ssh = new SshTransport({
-      host: context.host,
-      port: context.sshPort,
-      username: context.sshUser,
-      privateKeyPath: context.sshKey || undefined,
-      password: context.sshPass || undefined
-    });
-    Object.assign(tools, captureTools((server) => registerSshTools(server, ssh)));
+  if (context.host && context.sshHostFingerprint) {
+    try {
+      const ssh = new SshTransport({
+        host: context.host,
+        port: context.sshPort,
+        username: context.sshUser,
+        privateKeyPath: context.sshKey || undefined,
+        password: context.sshPass || undefined,
+        hostFingerprint: context.sshHostFingerprint
+      });
+      Object.assign(tools, captureTools((server) => registerSshTools(server, ssh)));
+    } catch (error51) {
+      const message = error51 instanceof Error ? error51.message : String(error51);
+      tools.ssh = {
+        schema: { action: sshActionSchema },
+        callback: async () => ({
+          content: [{
+            type: "text",
+            text: `⚠️ SSH host fingerprint is invalid; SSH actions remain disabled. ${message}`
+          }]
+        })
+      };
+    }
+  } else if (context.host) {
+    tools.ssh = {
+      schema: { action: sshActionSchema },
+      callback: async () => ({
+        content: [{
+          type: "text",
+          text: [
+            "⚠️ SSH actions are disabled because host-key verification is not configured.",
+            "Set SUPACLOUD_SSH_HOST_FINGERPRINT to the server's OpenSSH SHA256 fingerprint.",
+            `Verify it out-of-band first, for example: ssh-keyscan -p ${context.sshPort} ${context.host} | ssh-keygen -lf -`
+          ].join(`
+`)
+        }]
+      })
+    };
   }
   if (context.apiUrl && context.apiToken) {
     const http = new HttpTransport({
@@ -34858,7 +35191,7 @@ function createAdminTools() {
               "⚠️ No admin context configured.",
               "",
               "Provide one or both of:",
-              "  SUPACLOUD_HOST + SSH credentials",
+              "  SUPACLOUD_HOST + SSH credentials + SUPACLOUD_SSH_HOST_FINGERPRINT",
               "  SUPACLOUD_API_URL + SUPACLOUD_API_TOKEN",
               "",
               "This CLI is intended for server installation, diagnostics, and",
@@ -34894,7 +35227,15 @@ async function main() {
   }
   await runCli(cliTools, args, { commandName: "supacloud-admin" });
 }
-main().catch((error51) => {
-  console.error("supacloud-admin failed:", error51);
-  process.exit(1);
-});
+function isDirectRun() {
+  return Boolean(process.argv[1]) && import.meta.url === pathToFileURL(resolve2(process.argv[1])).href;
+}
+if (isDirectRun()) {
+  main().catch((error51) => {
+    console.error("supacloud-admin failed:", error51);
+    process.exit(1);
+  });
+}
+export {
+  createAdminTools
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/admin",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Platform administration CLI for SupaCloud operators",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,6 +36,6 @@
   "devDependencies": {
     "@types/bun": "^1.3.14",
     "@types/ssh2": "^1.15.5",
-    "typescript": "^6.0.3"
+    "typescript": "^7.0.2"
   }
 }