@stacksjs/buddy 0.70.86 → 0.70.88

package/dist/commands/deploy.js

@@ -1,1439 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import process from "node:process";
-import { runAction } from "@stacksjs/actions";
-import { italic, onUnknownSubcommand, outro, prompts, runCommand } from "@stacksjs/cli";
-import { app, dns as dnsConfig, email as emailConfig, cloud as cloudConfig } from "@stacksjs/config";
-import { addDomain, hasUserDomainBeenAddedToCloud, syncDnsConfig } from "@stacksjs/dns";
-import { encryptEnv, env } from "@stacksjs/env";
-import { Action } from "@stacksjs/enums";
-import { path as p } from "@stacksjs/path";
-import { ExitCode } from "@stacksjs/types";
-import { getErrorCode, getErrorMessage } from "@stacksjs/utils";
-import { ensureAppKey, ensureEnvIsSet, ensurePantryDependencies, ensurePantryInstalled } from "./setup";
-const log = {
-  info: (...args) => console.log("\u2139", ...args),
-  success: (...args) => console.log("\u2713", ...args),
-  warn: (...args) => console.log("\u26A0", ...args),
-  error: (...args) => console.error("\u2717", ...args),
-  debug: (...args) => {
-    if (process.argv.includes("--verbose") || process.argv.includes("-v"))
-      console.log("\uD83D\uDD0D", ...args);
-  }
-}, MAIL_PACKAGE_DOMAIN = "github.com/mail-os/mail", MAIL_PACKAGE_SPEC = `${MAIL_PACKAGE_DOMAIN}@0.1.0`, MAIL_TARGET_PLATFORM = "linux-x86_64", MAIL_BINARY_NAMES = ["mail", "mail-x86_64-linux", "mail-x86_64-linux-gnu"];
-function collectMatchingFiles(root, names, maxDepth = 8) {
-  const nameSet = new Set(names), matches = [];
-  if (!existsSync(root))
-    return matches;
-  function walk(dir, depth) {
-    if (depth > maxDepth)
-      return;
-    for (const entry of readdirSync(dir)) {
-      if (entry === ".git" || entry === "node_modules")
-        continue;
-      const fullPath = join(dir, entry), stat = statSync(fullPath);
-      if (stat.isDirectory())
-        walk(fullPath, depth + 1);
-      else if (stat.isFile() && nameSet.has(entry))
-        matches.push(fullPath);
-    }
-  }
-  walk(root, 0);
-  return matches;
-}
-function isElfBinary(filePath) {
-  const header = readFileSync(filePath).slice(0, 4);
-  return header[0] === 127 && header[1] === 69 && header[2] === 76 && header[3] === 70;
-}
-function resolvePantryInstallCommand() {
-  const localPantryCli = join(homedir(), "Code", "Tools", "pantry", "packages", "ts-pantry", "bin", "cli.ts");
-  if (existsSync(localPantryCli))
-    return { command: "bun", args: [localPantryCli] };
-  const projectPantry = p.projectPath("pantry/.bin/pantry");
-  if (existsSync(projectPantry))
-    return { command: projectPantry, args: [] };
-  const globalPantry = join(homedir(), ".local", "share", "pantry", "global", "bin", "pantry");
-  if (existsSync(globalPantry))
-    return { command: globalPantry, args: [] };
-  return { command: "pantry", args: [] };
-}
-async function installMailBinaryWithPantry() {
-  const { execFileSync } = await import("node:child_process"), pantry = resolvePantryInstallCommand();
-  execFileSync(pantry.command, [
-    ...pantry.args,
-    "install",
-    MAIL_PACKAGE_SPEC,
-    "--install-dir",
-    p.projectPath("pantry"),
-    "--platform",
-    MAIL_TARGET_PLATFORM,
-    "--quiet"
-  ], {
-    cwd: p.projectPath(),
-    stdio: process.argv.includes("--verbose") || process.argv.includes("-v") ? "inherit" : "pipe",
-    env: process.env
-  });
-}
-async function findPantryMailBinary() {
-  const directCandidates = [
-    ...MAIL_BINARY_NAMES.map((name) => p.projectPath(`pantry/.bin/${name}`)),
-    ...MAIL_BINARY_NAMES.map((name) => join(homedir(), ".local", "share", "pantry", "global", "bin", name))
-  ];
-  for (const candidate of directCandidates)
-    if (existsSync(candidate) && isElfBinary(candidate))
-      return candidate;
-  for (const root of [p.projectPath("pantry"), join(homedir(), ".local", "share", "pantry")])
-    for (const candidate of collectMatchingFiles(root, MAIL_BINARY_NAMES))
-      if (isElfBinary(candidate))
-        return candidate;
-  return null;
-}
-async function ensureDeployPrerequisites(verbose = !1) {
-  const cwd = p.projectPath();
-  await ensurePantryInstalled();
-  await ensurePantryDependencies(cwd);
-  await ensureEnvIsSet({ cwd, verbose });
-  await ensureAppKey(cwd);
-}
-function loadAwsCredentialsFromFile() {
-  const credentialsPath = join(homedir(), ".aws", "credentials"), configPath = join(homedir(), ".aws", "config");
-  if (!existsSync(credentialsPath))
-    return {};
-  try {
-    const lines = readFileSync(credentialsPath, "utf-8").split(`
-`), profiles = ["default", "stacks"];
-    let currentProfile = "", credentials = {};
-    const profileCredentials = {};
-    for (const line of lines) {
-      const trimmed = line.trim(), profileMatch = trimmed.match(/^\[(.+)\]$/);
-      if (profileMatch?.[1]) {
-        currentProfile = profileMatch[1];
-        profileCredentials[currentProfile] = {};
-        continue;
-      }
-      const keyValue = trimmed.match(/^(\w+)\s*=\s*(.+)$/);
-      if (keyValue && currentProfile) {
-        const [, key, value] = keyValue, target = profileCredentials[currentProfile];
-        if (!target || value === void 0)
-          continue;
-        if (key === "aws_access_key_id")
-          target.accessKeyId = value;
-        else if (key === "aws_secret_access_key")
-          target.secretAccessKey = value;
-      }
-    }
-    for (const profile of profiles)
-      if (profileCredentials[profile]?.accessKeyId && profileCredentials[profile]?.secretAccessKey) {
-        credentials = profileCredentials[profile];
-        log.debug(`Using AWS credentials from ~/.aws/credentials [${profile}] profile`);
-        break;
-      }
-    if (!credentials.accessKeyId) {
-      for (const [profile, creds] of Object.entries(profileCredentials))
-        if (creds.accessKeyId && creds.secretAccessKey) {
-          credentials = creds;
-          log.debug(`Using AWS credentials from ~/.aws/credentials [${profile}] profile`);
-          break;
-        }
-    }
-    let region;
-    if (existsSync(configPath)) {
-      const regionMatch = readFileSync(configPath, "utf-8").match(/region\s*=\s*(.+)/);
-      if (regionMatch?.[1])
-        region = regionMatch[1].trim();
-    }
-    return { ...credentials, region };
-  } catch (error) {
-    log.debug("Failed to read AWS credentials file:", error);
-    return {};
-  }
-}
-async function setupEmailDnsRecords(emailDomain, region, logger, options) {
-  logger.info("Setting up email DNS records...");
-  try {
-    const { SESClient } = await import("@stacksjs/ts-cloud"), { Route53Client } = await import("@stacksjs/ts-cloud"), ses = new SESClient(region), route53 = new Route53Client(region);
-    logger.info(`Getting DKIM tokens for ${emailDomain}...`);
-    const tokens = (await ses.getEmailIdentity(emailDomain)).DkimAttributes?.Tokens || [];
-    if (tokens.length === 0) {
-      logger.warn("No DKIM tokens found - domain may not be set up in SES yet");
-      return;
-    }
-    logger.info(`Found ${tokens.length} DKIM tokens`);
-    const zone = (await route53.listHostedZones()).HostedZones?.find((z) => z.Name === `${emailDomain}.`);
-    if (!zone) {
-      logger.warn(`Hosted zone not found for ${emailDomain} - DNS records must be added manually`);
-      logger.info("DKIM records needed:");
-      for (const token of tokens)
-        logger.info(`  CNAME: ${token}._domainkey.${emailDomain} -> ${token}.dkim.amazonses.com`);
-      logger.info(`  MX: ${emailDomain} -> 10 inbound-smtp.${region}.amazonaws.com`);
-      return;
-    }
-    const hostedZoneId = zone.Id?.replace("/hostedzone/", "");
-    logger.info(`Found hosted zone: ${hostedZoneId}`);
-    for (const token of tokens) {
-      const recordName = `${token}._domainkey.${emailDomain}`, recordValue = `${token}.dkim.amazonses.com`;
-      try {
-        await route53.changeResourceRecordSets({
-          HostedZoneId: hostedZoneId,
-          ChangeBatch: {
-            Changes: [{
-              Action: "UPSERT",
-              ResourceRecordSet: {
-                Name: recordName,
-                Type: "CNAME",
-                TTL: 300,
-                ResourceRecords: [{ Value: recordValue }]
-              }
-            }]
-          }
-        });
-        logger.success(`Added DKIM record: ${token}._domainkey`);
-      } catch (e) {
-        logger.warn(`Failed to add DKIM record: ${getErrorMessage(e)}`);
-      }
-    }
-    const mailSubdomain = options?.mailSubdomain || "mail", mxTarget = options?.mode === "server" ? `10 ${mailSubdomain}.${emailDomain}` : `10 inbound-smtp.${region}.amazonaws.com`;
-    try {
-      await route53.changeResourceRecordSets({
-        HostedZoneId: hostedZoneId,
-        ChangeBatch: {
-          Changes: [{
-            Action: "UPSERT",
-            ResourceRecordSet: {
-              Name: emailDomain,
-              Type: "MX",
-              TTL: 300,
-              ResourceRecords: [{ Value: mxTarget }]
-            }
-          }]
-        }
-      });
-      logger.success(`Added MX record: ${mxTarget}`);
-    } catch (e) {
-      logger.warn(`Failed to add MX record: ${getErrorMessage(e)}`);
-    }
-    try {
-      await route53.changeResourceRecordSets({
-        HostedZoneId: hostedZoneId,
-        ChangeBatch: {
-          Changes: [{
-            Action: "UPSERT",
-            ResourceRecordSet: {
-              Name: emailDomain,
-              Type: "TXT",
-              TTL: 300,
-              ResourceRecords: [{ Value: '"v=spf1 include:amazonses.com ~all"' }]
-            }
-          }]
-        }
-      });
-      logger.success("Added SPF record");
-    } catch (e) {
-      logger.warn(`Failed to add SPF record: ${getErrorMessage(e)}`);
-    }
-    try {
-      await route53.changeResourceRecordSets({
-        HostedZoneId: hostedZoneId,
-        ChangeBatch: {
-          Changes: [{
-            Action: "UPSERT",
-            ResourceRecordSet: {
-              Name: `_dmarc.${emailDomain}`,
-              Type: "TXT",
-              TTL: 300,
-              ResourceRecords: [{ Value: `"v=DMARC1;p=quarantine;pct=25;rua=mailto:dmarcreports@${emailDomain}"` }]
-            }
-          }]
-        }
-      });
-      logger.success("Added DMARC record");
-    } catch (e) {
-      logger.warn(`Failed to add DMARC record: ${getErrorMessage(e)}`);
-    }
-    try {
-      const ruleSetName = `${process.env.APP_NAME?.toLowerCase().replace(/[^a-z0-9]/g, "-") || "stacks"}-email-rules`;
-      await ses.setActiveReceiptRuleSet(ruleSetName);
-      logger.success(`Activated email receipt rule set: ${ruleSetName}`);
-    } catch (e) {
-      logger.warn(`Failed to activate receipt rule set: ${getErrorMessage(e)}`);
-    }
-    logger.success("Email DNS records configured!");
-    logger.info("Note: DKIM verification may take 5-15 minutes to complete");
-  } catch (error) {
-    logger.warn(`Failed to set up email DNS records: ${getErrorMessage(error)}`);
-    logger.info("You can manually set up DNS records using: buddy email:verify");
-  }
-}
-async function createDefaultMailUser(appName, emailDomain, region, logger) {
-  try {
-    const { DynamoDBClient } = await import("@stacksjs/ts-cloud"), crypto = await import("crypto"), dynamodb = new DynamoDBClient(region), tableName = `${appName}-mail-users`, mailboxes = emailConfig?.mailboxes || [];
-    if (mailboxes.length === 0) {
-      const defaultEmail = `admin@${emailDomain}`, defaultPassword = crypto.randomBytes(16).toString("hex"), passwordHash = crypto.createHash("sha256").update(defaultPassword).digest("hex");
-      try {
-        await dynamodb.putItem({
-          TableName: tableName,
-          Item: {
-            email: { S: defaultEmail },
-            passwordHash: { S: passwordHash },
-            createdAt: { S: new Date().toISOString() },
-            displayName: { S: "Admin" }
-          }
-        });
-        logger.success(`Created default mail user: ${defaultEmail}`);
-        logger.info(`Password: ${defaultPassword}`);
-        logger.info("Save this password - it will not be shown again!");
-      } catch (e) {
-        const msg = getErrorMessage(e);
-        if (msg.includes("ConditionalCheckFailedException") || msg.includes("already exists"))
-          logger.debug("Default mail user already exists");
-        else
-          throw e;
-      }
-    } else
-      for (const mailbox of mailboxes) {
-        const mb = mailbox, email = typeof mailbox === "string" ? `${mailbox}@${emailDomain}` : `${mb.name || mb.address?.split("@")[0]}@${emailDomain}`, password = typeof mailbox === "object" && mb.password ? mb.password : crypto.randomBytes(16).toString("hex"), passwordHash = crypto.createHash("sha256").update(password).digest("hex");
-        try {
-          await dynamodb.putItem({
-            TableName: tableName,
-            Item: {
-              email: { S: email },
-              passwordHash: { S: passwordHash },
-              createdAt: { S: new Date().toISOString() },
-              displayName: { S: typeof mailbox === "object" ? mb.displayName || mb.name || email : mailbox }
-            }
-          });
-          logger.success(`Created mail user: ${email}`);
-          if (typeof mailbox !== "object" || !mb.password)
-            logger.info(`  Password: ${password}`);
-        } catch (e) {
-          const msg = getErrorMessage(e);
-          if (msg.includes("ConditionalCheckFailedException"))
-            logger.debug(`Mail user ${email} already exists`);
-          else
-            logger.warn(`Failed to create mail user ${email}: ${msg}`);
-        }
-      }
-  } catch (error) {
-    logger.warn(`Failed to create mail users: ${getErrorMessage(error)}`);
-  }
-}
-async function uploadMailServerToS3(bucketName, region, mode) {
-  try {
-    const { S3Client: S3 } = await import("@stacksjs/ts-cloud"), s3Client = new S3(region);
-    if (mode === "serverless") {
-      const serverTsPath = p.frameworkPath("core/mail-server/server.ts");
-      if (existsSync(serverTsPath)) {
-        const serverCode = readFileSync(serverTsPath, "utf-8");
-        await s3Client.putObject({
-          bucket: bucketName,
-          key: "mail-server/server.ts",
-          body: serverCode,
-          contentType: "text/typescript"
-        });
-        log.success("Uploaded serverless mail server code to S3");
-      }
-      const pkgPath = p.frameworkPath("core/mail-server/package.json");
-      if (existsSync(pkgPath)) {
-        const pkgJson = readFileSync(pkgPath, "utf-8");
-        await s3Client.putObject({
-          bucket: bucketName,
-          key: "mail-server/package.json",
-          body: pkgJson,
-          contentType: "application/json"
-        });
-      }
-      return;
-    }
-    let binaryUploaded = !1;
-    try {
-      await installMailBinaryWithPantry();
-      const linuxBinaryPath = await findPantryMailBinary();
-      if (linuxBinaryPath && existsSync(linuxBinaryPath) && isElfBinary(linuxBinaryPath)) {
-        log.info(`Uploading Pantry mail binary: ${linuxBinaryPath}`);
-        const binaryContent = readFileSync(linuxBinaryPath);
-        await s3Client.putObject({
-          bucket: bucketName,
-          key: "mail-server/smtp-server",
-          body: binaryContent,
-          contentType: "application/octet-stream"
-        });
-        log.success("Uploaded Linux x86_64 mail server binary to S3");
-        binaryUploaded = !0;
-      }
-    } catch (error) {
-      log.debug(`Pantry mail install failed: ${getErrorMessage(error)}`);
-    }
-    if (!binaryUploaded)
-      log.warn(`No Pantry-provided ${MAIL_TARGET_PLATFORM} mail binary found. Release ${MAIL_PACKAGE_DOMAIN}, then run the Pantry binary sync for that package.`);
-  } catch (uploadErr) {
-    log.debug(`Could not upload mail server to S3 (bucket may not exist yet): ${uploadErr.message}`);
-  }
-}
-async function loadTsCloudConfig(envName) {
-  try {
-    const base = p.projectPath("config/cloud.ts");
-    return (await import(envName ? `${base}?env=${envName}` : base)).tsCloud;
-  } catch (err) {
-    log.debug("Could not load config/cloud.ts tsCloud export:", err);
-    return;
-  }
-}
-function resolveProvider(tsCloudConfig) {
-  return tsCloudConfig?.cloud?.provider || process.env.CLOUD_PROVIDER || "aws";
-}
-function readWaitSecs(name, defaultSecs) {
-  const secs = process.env[name] ? Number.parseInt(process.env[name], 10) : Number.NaN;
-  return Number.isFinite(secs) && secs > 0 ? secs : defaultSecs;
-}
-function fmtDuration(secs) {
-  const m = Math.floor(secs / 60), s = secs % 60;
-  return m ? s ? `${m}m${s}s` : `${m}m` : `${s}s`;
-}
-async function pollUntil(opts) {
-  log.info(`${opts.label} (up to ${fmtDuration(opts.timeoutSecs)})...`);
-  const started = Date.now(), deadline = started + opts.timeoutSecs * 1000;
-  let lastHeartbeat = 0;
-  for (;; )
-    try {
-      opts.check();
-      return;
-    } catch {
-      const elapsedSecs = Math.floor((Date.now() - started) / 1000);
-      if (Date.now() > deadline)
-        throw Error(opts.timeoutMessage(elapsedSecs));
-      if (elapsedSecs - lastHeartbeat >= 30) {
-        log.info(`  \u2026 still waiting (${elapsedSecs}s elapsed)`);
-        lastHeartbeat = elapsedSecs;
-      }
-      await new Promise((r) => setTimeout(r, opts.intervalMs ?? 5000));
-    }
-}
-async function waitForRemoteReady(ip, verbose) {
-  const { execSync } = await import("node:child_process"), sshArgs = [
-    "-o",
-    "StrictHostKeyChecking=no",
-    "-o",
-    "UserKnownHostsFile=/dev/null",
-    "-o",
-    "BatchMode=yes",
-    "-o",
-    "ConnectTimeout=10",
-    `root@${ip}`
-  ], run = (remote) => execSync(`ssh ${sshArgs.map((a) => `'${a}'`).join(" ")} '${remote.replace(/'/g, "'\\''")}'`, {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", verbose ? "inherit" : "pipe"]
-  }), sshWaitSecs = readWaitSecs("TS_CLOUD_SSH_WAIT_SECS", 480);
-  await pollUntil({
-    label: "Waiting for SSH to come up",
-    timeoutSecs: sshWaitSecs,
-    check: () => {
-      run("true");
-    },
-    timeoutMessage: (elapsed) => `SSH did not become reachable on ${ip} within ${fmtDuration(sshWaitSecs)} (waited ${elapsed}s). ` + "The box may still be booting \u2014 raise TS_CLOUD_SSH_WAIT_SECS and retry."
-  });
-  log.success("SSH is up");
-  log.info("Waiting for cloud-init (installing bun + caddy)...");
-  try {
-    run("cloud-init status --wait || true");
-  } catch (err) {
-    log.debug("cloud-init status --wait returned non-zero (continuing):", err);
-  }
-  const bootWaitSecs = readWaitSecs("TS_CLOUD_BOOT_WAIT_SECS", 720);
-  await pollUntil({
-    label: "Waiting for the bun runtime",
-    timeoutSecs: bootWaitSecs,
-    check: () => {
-      run("test -x /usr/local/bin/bun");
-    },
-    timeoutMessage: (elapsed) => `bun runtime did not appear at /usr/local/bin/bun within ${fmtDuration(bootWaitSecs)} (waited ${elapsed}s). ` + "cloud-init may have failed \u2014 SSH in and check /var/log/cloud-init-output.log; " + "raise TS_CLOUD_BOOT_WAIT_SECS for slow regions."
-  });
-  log.success("Server is ready (bun installed)");
-}
-export async function resolveDeployEnvValues(environment) {
-  const fileName = environment === "production" ? ".env.production" : environment === "staging" ? ".env.staging" : existsSync(p.projectPath(".env.development")) ? ".env.development" : ".env", filePath = p.projectPath(fileName);
-  if (!existsSync(filePath))
-    return {};
-  try {
-    const { getEnv } = await import("@stacksjs/env"), result = getEnv(void 0, { file: fileName, format: "json" });
-    if (!result.success || !result.output) {
-      log.debug(`[deploy] Could not read ${fileName} for site env merging: ${result.error ?? "unknown error"}`);
-      return {};
-    }
-    const parsed = JSON.parse(result.output), values = {};
-    for (const [key, value] of Object.entries(parsed)) {
-      if (/^DOTENV_(PUBLIC|PRIVATE)_KEY/.test(key))
-        continue;
-      values[key] = String(value);
-    }
-    return values;
-  } catch (error) {
-    log.debug(`[deploy] Failed to resolve ${fileName} for site env merging:`, error);
-    return {};
-  }
-}
-export function mergeSiteDeployEnv(sites, resolvedDeployEnv) {
-  return Object.fromEntries(Object.entries(sites).map(([siteName, site]) => {
-    if (!site)
-      return [siteName, site];
-    const base = { ...resolvedDeployEnv };
-    if (site.port !== void 0)
-      delete base.PORT;
-    return [siteName, { ...site, env: { ...base, ...site.env || {} } }];
-  }));
-}
-function prefixHostForEnv(host, prefix) {
-  if (host.startsWith(`${prefix}.`) || host.startsWith(`www.${prefix}.`))
-    return host;
-  if (host.startsWith("www."))
-    return `www.${prefix}.${host.slice(4)}`;
-  return `${prefix}.${host}`;
-}
-export function applyEnvironmentToSites(sites, environment, config) {
-  const prefix = config?.environments?.[environment]?.domainPrefix;
-  if (!prefix || environment === "production")
-    return sites;
-  const allHosts = [];
-  for (const site of Object.values(sites)) {
-    const d = site?.domain;
-    if (typeof d === "string")
-      allHosts.push(d);
-    else if (Array.isArray(d)) {
-      for (const x of d)
-        if (typeof x === "string")
-          allHosts.push(x);
-    }
-  }
-  allHosts.sort((a, b) => b.length - a.length);
-  const rewrite = (val) => {
-    let r = val;
-    for (const h of allHosts) {
-      const esc = h.replace(/[.]/g, "\\.");
-      r = r.replace(new RegExp(`//${esc}(?=[/:?#]|$)`, "g"), `//${prefixHostForEnv(h, prefix)}`);
-    }
-    return r;
-  }, out = {};
-  for (const [name, site] of Object.entries(sites)) {
-    if (!site) {
-      out[name] = site;
-      continue;
-    }
-    const s = { ...site };
-    if (typeof s.domain === "string")
-      s.domain = prefixHostForEnv(s.domain, prefix);
-    else if (Array.isArray(s.domain))
-      s.domain = s.domain.map((d) => typeof d === "string" ? prefixHostForEnv(d, prefix) : d);
-    if (typeof s.redirect === "string")
-      s.redirect = rewrite(s.redirect);
-    if (s.env && typeof s.env === "object") {
-      const e = { ...s.env };
-      for (const k of Object.keys(e))
-        if (typeof e[k] === "string")
-          e[k] = rewrite(e[k]);
-      s.env = e;
-    }
-    out[name] = s;
-  }
-  return out;
-}
-async function deployToHetzner(tsCloudConfig, deployEnv, options) {
-  const verbose = options.verbose === !0, environment = deployEnv === "prod" ? "production" : deployEnv;
-  if (!(tsCloudConfig.hetzner?.apiToken || process.env.HCLOUD_TOKEN || process.env.HETZNER_API_TOKEN)) {
-    log.error("No Hetzner API token found. Set HCLOUD_TOKEN in your .env (or hetzner.apiToken in config/cloud.ts).");
-    process.exit(ExitCode.FatalError);
-  }
-  const sshPubKey = join(homedir(), ".ssh", "id_ed25519.pub");
-  if (!existsSync(sshPubKey)) {
-    log.error(`SSH public key not found at ${sshPubKey}.`);
-    log.info("ts-cloud deploys to Hetzner over SSH and registers this key on the server.");
-    log.info("Generate one with:  ssh-keygen -t ed25519");
-    process.exit(ExitCode.FatalError);
-  }
-  const { createCloudDriver, deployAllComputeSites, resolveSiteKind } = await import("@stacksjs/ts-cloud");
-  try {
-    await runHetznerDeploy({ tsCloudConfig, environment, verbose, docker: options.docker === !0, createCloudDriver, deployAllComputeSites, resolveSiteKind, onlySite: options.site || void 0 });
-  } catch (err) {
-    log.error("Hetzner deploy failed:");
-    console.error(err instanceof Error ? err.stack || err.message : err);
-    process.exit(ExitCode.FatalError);
-  }
-}
-export function scrubLoopbackSitePortsForFirewall(tsCloudConfig) {
-  const sites = tsCloudConfig?.sites;
-  if (!sites)
-    return tsCloudConfig;
-  const loopbackHosts = new Set(["127.0.0.1", "::1", "localhost"]), scrubbed = {};
-  for (const [siteName, site] of Object.entries(sites)) {
-    const host = String(site?.env?.HOST ?? "").toLowerCase();
-    if (site && typeof site.port === "number" && !site.domain && loopbackHosts.has(host)) {
-      const rest = { ...site };
-      delete rest.port;
-      scrubbed[siteName] = rest;
-    } else
-      scrubbed[siteName] = site;
-  }
-  return { ...tsCloudConfig, sites: scrubbed };
-}
-function githubDeploymentsEnabled() {
-  return process.env.GITHUB_ACTIONS !== "true" && process.env.TS_CLOUD_GITHUB_DEPLOYMENTS !== "0";
-}
-async function ghCliAvailable() {
-  try {
-    const { execSync } = await import("node:child_process");
-    execSync("gh --version", { stdio: "ignore" });
-    return !0;
-  } catch {
-    return !1;
-  }
-}
-async function resolveSiteGithubSource(root) {
-  try {
-    const { execSync } = await import("node:child_process"), run = (cmd) => execSync(cmd, { cwd: root, stdio: ["ignore", "pipe", "ignore"] }).toString().trim(), match = run("git config --get remote.origin.url").match(/github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/);
-    if (!match?.[1])
-      return null;
-    return { repo: match[1], ref: run("git rev-parse HEAD") };
-  } catch {
-    return null;
-  }
-}
-async function setGithubDeploymentStatus(record, state) {
-  try {
-    const { execSync } = await import("node:child_process"), body = JSON.stringify({
-      state,
-      environment: record.environment,
-      ...record.environmentUrl ? { environment_url: record.environmentUrl } : {},
-      description: state === "success" ? "Deployed" : state === "failure" ? "Deploy failed" : "Deploying"
-    });
-    execSync(`gh api -X POST repos/${record.repo}/deployments/${record.id}/statuses --input -`, { input: body, stdio: ["pipe", "ignore", "ignore"] });
-  } catch (err) {
-    log.warn(`GitHub deployment status (${state}) skipped for ${record.repo}: ${getErrorMessage(err)}`);
-  }
-}
-async function startGithubDeployment(source, environment, environmentUrl) {
-  try {
-    const { execSync } = await import("node:child_process"), body = JSON.stringify({
-      ref: source.ref,
-      environment,
-      description: `buddy deploy (${environment})`,
-      auto_merge: !1,
-      required_contexts: [],
-      production_environment: environment === "production"
-    }), out = execSync(`gh api -X POST repos/${source.repo}/deployments --input - --jq '.id'`, { input: body, stdio: ["pipe", "pipe", "ignore"] }).toString().trim(), id = Number(out);
-    if (!out || !Number.isInteger(id) || id <= 0)
-      return null;
-    const record = { repo: source.repo, id, environment, environmentUrl };
-    await setGithubDeploymentStatus(record, "in_progress");
-    return record;
-  } catch (err) {
-    log.warn(`GitHub deployment record skipped for ${source.repo}: ${getErrorMessage(err)}`);
-    return null;
-  }
-}
-async function startGithubDeployments(args) {
-  const { sites, onlySite, environment, resolveSiteKind } = args, records = [];
-  if (!githubDeploymentsEnabled() || !await ghCliAvailable())
-    return records;
-  const seen = new Set;
-  for (const [siteName, site] of Object.entries(sites)) {
-    if (!site || onlySite && siteName !== onlySite)
-      continue;
-    const kind = resolveSiteKind(site);
-    if (kind === "bucket" || kind === "redirect")
-      continue;
-    const source = await resolveSiteGithubSource(site.root || ".");
-    if (!source)
-      continue;
-    const key = `${source.repo}@${source.ref}`;
-    if (seen.has(key))
-      continue;
-    seen.add(key);
-    const record = await startGithubDeployment(source, environment, site.domain ? `https://${site.domain}` : void 0);
-    if (record) {
-      records.push(record);
-      log.info(`GitHub deployment ${record.repo}#${record.id} \u2192 ${environment}`);
-    }
-  }
-  return records;
-}
-async function runHetznerDeploy(args) {
-  const { tsCloudConfig, environment, verbose, docker, createCloudDriver, deployAllComputeSites, resolveSiteKind, onlySite } = args, startTime = performance.now();
-  console.log("");
-  console.log("\uD83D\uDE80 Deploy \u2192 Hetzner Cloud");
-  console.log("");
-  log.info(`Project: ${tsCloudConfig.project?.slug}`);
-  log.info(`Environment: ${environment}`);
-  log.info(`Location: ${tsCloudConfig.hetzner?.location || process.env.HCLOUD_LOCATION || "fsn1"}`);
-  log.info(`Size: ${tsCloudConfig.infrastructure?.compute?.size || "small"}`);
-  try {
-    const { ensureManagementDashboard } = await import("@stacksjs/ts-cloud");
-    if (typeof ensureManagementDashboard === "function")
-      ensureManagementDashboard(tsCloudConfig, {
-        cwd: process.cwd(),
-        logger: { info: (m) => log.info(m), warn: (m) => log.warn(m) }
-      });
-  } catch (err) {
-    log.warn(`Management dashboard injection skipped: ${getErrorMessage(err)}`);
-  }
-  const driver = createCloudDriver({ config: tsCloudConfig, provider: "hetzner" });
-  if (!driver.provisionComputeInfrastructure) {
-    log.error("Hetzner driver does not support compute provisioning (update @stacksjs/ts-cloud).");
-    process.exit(ExitCode.FatalError);
-  }
-  const attachTo = tsCloudConfig.cloud?.attachTo;
-  let ip;
-  if (attachTo) {
-    const box = await resolveAttachTargetBox(attachTo, environment);
-    if (!box?.publicIp) {
-      log.error(`Attach target '${attachTo}' has no reachable box for '${environment}'. Is '${attachTo}-${environment}-app' provisioned (by its owner)?`);
-      process.exit(ExitCode.FatalError);
-    }
-    ip = box.publicIp;
-    log.info(`Attaching to '${attachTo}' box '${box.serverName}' (${ip}) \u2014 skipping provisioning`);
-    const compute = (tsCloudConfig.infrastructure ??= {}).compute ??= {};
-    compute.webServer = "rpx";
-    compute.proxy = { onDemandTls: !0, ...compute.proxy ?? {}, engine: "rpx" };
-    const stackName = tsCloudConfig.project?.stackName || `${tsCloudConfig.project?.slug || "app"}-${environment}`, stateDir = join(process.cwd(), ".ts-cloud", "state");
-    mkdirSync(stateDir, { recursive: !0 });
-    writeFileSync(join(stateDir, `${stackName}.json`), `${JSON.stringify({
-      stackName,
-      serverId: box.serverId,
-      serverName: box.serverName,
-      publicIp: ip,
-      sshUser: "root",
-      deployStoragePath: "/var/ts-cloud/staging"
-    }, null, 2)}
-`);
-  } else {
-    log.info("Provisioning Hetzner compute infrastructure...");
-    const outputs = await driver.provisionComputeInfrastructure({ config: scrubLoopbackSitePortsForFirewall(tsCloudConfig), environment });
-    ip = outputs.appPublicIp;
-    log.success("Hetzner compute infrastructure ready");
-    if (outputs.appInstanceId)
-      log.info(`Server ID: ${outputs.appInstanceId}`);
-  }
-  if (ip)
-    log.info(`Server IP: ${ip}`);
-  if (!ip) {
-    log.error("Provisioned server has no public IP \u2014 cannot deploy over SSH.");
-    process.exit(ExitCode.FatalError);
-  }
-  await waitForRemoteReady(ip, verbose);
-  const { execSync } = await import("node:child_process"), { tmpdir } = await import("node:os"), sites = applyEnvironmentToSites(tsCloudConfig.sites || {}, environment, tsCloudConfig), slug = tsCloudConfig.project?.slug || "app";
-  let sha;
-  try {
-    sha = execSync("git rev-parse --short HEAD", { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
-  } catch {
-    sha = Date.now().toString(36);
-  }
-  const tarExcludes = [
-    "node_modules",
-    "pantry",
-    ".git",
-    ".github",
-    ".cache",
-    "bin",
-    "dist",
-    ".stx",
-    "tmp",
-    "temp",
-    ".DS_Store",
-    "*.log",
-    ".env.local",
-    ".env.production.bak"
-  ].flatMap((p) => [`--exclude='${p}'`, `--exclude='*/${p}'`]);
-  if (onlySite && !sites[onlySite]) {
-    log.error(`--site '${onlySite}' is not a configured site. Available: ${Object.keys(sites).join(", ")}`);
-    process.exit(ExitCode.FatalError);
-  }
-  const tarballs = new Map;
-  for (const [siteName, site] of Object.entries(sites)) {
-    if (!site)
-      continue;
-    if (onlySite && siteName !== onlySite)
-      continue;
-    const kind = resolveSiteKind(site);
-    if (kind === "bucket")
-      continue;
-    if (kind === "redirect")
-      continue;
-    if (kind === "server-static" && site.build) {
-      log.info(`Building static site '${siteName}': ${site.build}`);
-      execSync(site.build, { stdio: verbose ? "inherit" : "pipe" });
-    }
-    const root = site.root || ".", tarballPath = join(tmpdir(), `${slug}-${siteName}-${sha}.tar.gz`);
-    log.info(`Packaging ${root} \u2192 ${tarballPath}...`);
-    execSync(`tar czf "${tarballPath}" ${tarExcludes.join(" ")} -C "${root}" .`, { stdio: verbose ? "inherit" : "pipe", env: { ...process.env, COPYFILE_DISABLE: "1" } });
-    const sizeMb = Math.max(1, Math.round(statSync(tarballPath).size / 1048576));
-    log.info(`Release tarball: ~${sizeMb} MB`);
-    tarballs.set(siteName, tarballPath);
-  }
-  if (docker)
-    await buildContainerImageWithPantry({ slug, sites, verbose });
-  const resolvedDeployEnv = await resolveDeployEnvValues(environment), sitesWithResolvedEnv = mergeSiteDeployEnv(sites, resolvedDeployEnv);
-  for (const [envKey, envValue] of Object.entries(resolvedDeployEnv))
-    if (process.env[envKey] === void 0)
-      process.env[envKey] = envValue;
-  const githubDeployments = await startGithubDeployments({ sites, onlySite, environment, resolveSiteKind });
-  log.info(onlySite ? `Shipping site '${onlySite}' to the server...` : "Shipping release to the server...");
-  const deployConfig = onlySite ? { ...tsCloudConfig, sites: { [onlySite]: sitesWithResolvedEnv[onlySite] } } : { ...tsCloudConfig, sites: sitesWithResolvedEnv }, ok = await deployAllComputeSites({
-    config: deployConfig,
-    rpxConfig: { ...tsCloudConfig, sites: sitesWithResolvedEnv },
-    environment,
-    driver,
-    sha,
-    runtime: tsCloudConfig.infrastructure?.compute?.runtime || "bun",
-    tarballForSite: (siteName) => {
-      const path = tarballs.get(siteName);
-      if (!path)
-        throw Error(`Missing tarball for site '${siteName}'`);
-      return path;
-    },
-    logger: {
-      info: (m) => log.info(m),
-      warn: (m) => log.warn(m),
-      error: (m) => log.error(m),
-      step: (m) => log.info(m),
-      success: (m) => log.success(m)
-    }
-  });
-  if (ok)
-    await reconcileHetznerDns(onlySite ? { [onlySite]: sites[onlySite] } : sites, ip, log);
-  if (ok)
-    await reconcileConfigDns(onlySite ? { [onlySite]: sites[onlySite] } : sites, log);
-  if (ok) {
-    const mailRes = await provisionMailTenant(ip, log);
-    if (mailRes)
-      await reconcileMailDns(mailRes, ip, log);
-  }
-  for (const record of githubDeployments)
-    await setGithubDeploymentStatus(record, ok ? "success" : "failure");
-  console.log("");
-  if (ok) {
-    await outro(`Deployed to Hetzner. Your site is live at http://${ip}:3000`, { startTime, useSeconds: !0 });
-    log.info(`Coming-soon page: http://${ip}:3000  (bypass with ?secret=\u2026)`);
-  } else {
-    await outro("Hetzner deploy reported a failure \u2014 see the per-instance output above.", { startTime, useSeconds: !0 });
-    process.exit(ExitCode.FatalError);
-  }
-}
-function resolveMailboxes(mailboxes, domain) {
-  if (!Array.isArray(mailboxes))
-    return [];
-  const out = [];
-  for (const entry of mailboxes) {
-    let raw, explicitPw;
-    if (typeof entry === "string")
-      raw = entry;
-    else if (entry && typeof entry === "object") {
-      raw = entry.email ?? entry.username;
-      explicitPw = entry.password;
-    }
-    if (!raw || typeof raw !== "string")
-      continue;
-    const localPart = (raw.includes("@") ? raw.split("@")[0] ?? "" : raw).trim();
-    if (!localPart)
-      continue;
-    const address = `${localPart}@${domain}`, envPw = explicitPw || process.env[`MAIL_PASSWORD_${localPart.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`];
-    if (!envPw)
-      continue;
-    out.push({ address, localPart: localPart.toUpperCase(), password: envPw, generated: !1 });
-  }
-  return out;
-}
-async function resolveAttachTargetBox(owner, environment) {
-  const token = process.env.HCLOUD_TOKEN;
-  if (!token)
-    return null;
-  const pick = (servers) => servers.find((s) => s?.status !== "off" && s?.public_net?.ipv4?.ip) || servers[0], req = async (qs) => {
-    try {
-      const res = await fetch(`https://api.hetzner.cloud/v1/servers?${qs}`, {
-        headers: { Authorization: `Bearer ${token}` }
-      });
-      if (!res.ok)
-        return [];
-      return (await res.json()).servers || [];
-    } catch {
-      return [];
-    }
-  }, byLabel = await req(`label_selector=${encodeURIComponent(`ts-cloud/project=${owner},ts-cloud/environment=${environment},ts-cloud/role=app`)}`), chosen = pick(byLabel) || pick(await req(`name=${encodeURIComponent(`${owner}-${environment}-app`)}`));
-  if (!chosen)
-    return null;
-  return { serverId: chosen.id, serverName: chosen.name, publicIp: chosen.public_net?.ipv4?.ip };
-}
-export async function provisionMailTenant(ip, logger) {
-  const cfg = emailConfig || {}, domain = cfg.domain || (typeof cfg.from?.address === "string" && cfg.from.address.includes("@") ? cfg.from.address.split("@")[1] : void 0), forwards = cfg.forwards && typeof cfg.forwards === "object" ? cfg.forwards : {}, hasForwards = Object.keys(forwards).length > 0, boxes = domain ? resolveMailboxes(cfg.mailboxes, domain) : [];
-  if (!domain && !hasForwards)
-    return null;
-  const { execSync } = await import("node:child_process"), sshArgs = ["-o", "StrictHostKeyChecking=accept-new", "-o", "BatchMode=yes", "-o", "ConnectTimeout=20", `root@${ip}`], forwardsB64 = hasForwards ? Buffer.from(JSON.stringify(forwards)).toString("base64") : "", readme = "Auto-forwarding rules, re-read on every message (edits take effect immediately, no restart). KEY = the delivered mailbox: the FULL address for per-domain isolated mailboxes (e.g. no-reply@app.com), or a bare local-part for legacy role mailboxes. VALUE = list of destination addresses; targets on a local domain are written straight to that mailbox Maildir, external targets are relayed. Managed by buddy deploy " + "from config/email.ts (merge-based \u2014 hand edits to other keys are preserved).", readmeB64 = Buffer.from(readme).toString("base64"), boxesB64 = boxes.length ? Buffer.from(boxes.map((b) => `${b.address}	${b.password}`).join(`
-`)).toString("base64") : "", script = `set -e
-DOMAIN=${domain ? `'${domain}'` : "''"}
-FWD_B64='${forwardsB64}'
-README_B64='${readmeB64}'
-BOXES_B64='${boxesB64}'
-ENVF=/etc/mail/mail.env
-FJSON=/opt/mail/forwards.json
-DKIMDIR=/opt/mail/dkim
-MS=/opt/mail/mail-server
-ENV_CHANGED=0
-# The 'user:local' CLI is direct-DB and does NOT read /etc/mail/mail.env, so
-# without SMTP_DB_PATH it writes to ./smtp.db (the SSH cwd) \u2014 a phantom DB the
-# running server never reads, and auth silently 535s. Point it at the real DB.
-export SMTP_DB_PATH="$(grep -E '^SMTP_DB_PATH=' "$ENVF" 2>/dev/null | head -1 | cut -d= -f2- || true)"
-[ -z "$SMTP_DB_PATH" ] && export SMTP_DB_PATH=/opt/mail/smtp.db
-echo "MAILHOST:$(grep -E '^SMTP_HOSTNAME=' "$ENVF" 2>/dev/null | head -1 | cut -d= -f2- || true)"
-# 1) Register the local delivery domain (merge into SMTP_LOCAL_DOMAINS).
-if [ -n "$DOMAIN" ] && [ -f "$ENVF" ]; then
-  cur=$(grep -E '^SMTP_LOCAL_DOMAINS=' "$ENVF" | head -1 | cut -d= -f2- || true)
-  case ",$cur," in
-    *",$DOMAIN,"*) : ;;
-    *) if grep -qE '^SMTP_LOCAL_DOMAINS=' "$ENVF"; then
-        sed -i "s|^SMTP_LOCAL_DOMAINS=.*|SMTP_LOCAL_DOMAINS=\${cur:+$cur,}$DOMAIN|" "$ENVF"
-      else
-        echo "SMTP_LOCAL_DOMAINS=$DOMAIN" >> "$ENVF"
-      fi
-      ENV_CHANGED=1 ;;
-  esac
-fi
-# 2) Per-domain DKIM key: generate on first sight, register in DKIM_EXTRA_KEYS.
-if [ -n "$DOMAIN" ] && [ -f "$ENVF" ]; then
-  mkdir -p "$DKIMDIR"
-  KEY="$DKIMDIR/$DOMAIN.private"
-  if [ ! -f "$KEY" ]; then
-    openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out "$KEY" 2>/dev/null
-    chown mail-server:mail-server "$KEY" 2>/dev/null || true
-    chmod 600 "$KEY" 2>/dev/null || true
-  fi
-  ex=$(grep -E '^DKIM_EXTRA_KEYS=' "$ENVF" | head -1 | cut -d= -f2- || true)
-  ENTRY="$DOMAIN:mail:$KEY"
-  case ",$ex," in
-    *"$DOMAIN:mail:"*) : ;;
-    *) if grep -qE '^DKIM_EXTRA_KEYS=' "$ENVF"; then
-        sed -i "s|^DKIM_EXTRA_KEYS=.*|DKIM_EXTRA_KEYS=\${ex:+$ex,}$ENTRY|" "$ENVF"
-      else
-        echo "DKIM_EXTRA_KEYS=$ENTRY" >> "$ENVF"
-      fi
-      ENV_CHANGED=1 ;;
-  esac
-  echo "DKIMPUB:$(openssl rsa -in "$KEY" -pubout -outform DER 2>/dev/null | base64 -w0)"
-fi
-# 3) Create the configured mailboxes as per-domain isolated users (skip existing).
-if [ -n "$BOXES_B64" ] && [ -x "$MS" ]; then
-  echo "$BOXES_B64" | base64 -d | while IFS=$'	' read -r addr pw; do
-    [ -z "$addr" ] && continue
-    # NOTE: 'user:local info' exits 0 even when the user is absent (it only
-    # prints "not found"), so existence is decided from the OUTPUT, not $?.
-    if "$MS" user:local info "$addr" 2>&1 | grep -qi 'not found'; then
-      if "$MS" user:local create "$addr" "$pw" "$addr" >/dev/null 2>&1; then echo "MADE:$addr"; else echo "FAIL:$addr"; fi
-    else
-      echo "EXISTS:$addr"
-    fi
-  done
-fi
-# 4) Merge auto-forward rules into forwards.json (live-reloaded; no restart).
-if [ -n "$FWD_B64" ] && [ -x /usr/local/bin/bun ]; then
-  echo "$FWD_B64" | base64 -d > /tmp/.mailtenant-fwd.json
-  echo "$README_B64" | base64 -d > /tmp/.mailtenant-readme.txt
-  /usr/local/bin/bun --bun -e '
-    const fs=require("fs"); const f="/opt/mail/forwards.json";
-    const cur={}; try{cur=JSON.parse(fs.readFileSync(f,"utf8"))}catch{}
-    const add=JSON.parse(fs.readFileSync("/tmp/.mailtenant-fwd.json","utf8"));
-    const readme=fs.readFileSync("/tmp/.mailtenant-readme.txt","utf8");
-    const merged={...cur}; delete merged._readme;
-    for(const [k,v] of Object.entries(add)) merged[k]=v;
-    const out={_readme:readme,...merged};
-    const s=JSON.stringify(out,null,2)+"\\n";
-    const prev=""; try{prev=fs.readFileSync(f,"utf8")}catch{}
-    if(s!==prev){ fs.writeFileSync(f,s); process.stdout.write("FWDCHANGED"); }
-  ' > /tmp/.mailtenant-res 2>/dev/null || true
-  chown mail-server:mail-server "$FJSON" 2>/dev/null || true
-  chmod 644 "$FJSON" 2>/dev/null || true
-  rm -f /tmp/.mailtenant-fwd.json /tmp/.mailtenant-readme.txt
-fi
-FWD_STATE=nochange; grep -q FWDCHANGED /tmp/.mailtenant-res 2>/dev/null && FWD_STATE=updated; rm -f /tmp/.mailtenant-res
-# 5) Restart only when the startup-read env actually changed (domain or DKIM key).
-if [ "$ENV_CHANGED" = 1 ]; then systemctl restart mail 2>/dev/null || true; echo "MAILTENANT:env-changed+restarted,forwards=$FWD_STATE"; else echo "MAILTENANT:current,forwards=$FWD_STATE"; fi`;
-  try {
-    const out = execSync(`ssh ${sshArgs.map((a) => `'${a}'`).join(" ")} bash -s`, {
-      input: script,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }), line = (out.match(/MAILTENANT:[^\n]*/) || [])[0] || "MAILTENANT:done", mailHost = (out.match(/MAILHOST:([^\n]*)/) || [])[1]?.trim() || `mail.${domain}`, dkimPubB64 = (out.match(/DKIMPUB:([^\n]*)/) || [])[1]?.trim() || void 0, madeAddrs = new Set([...out.matchAll(/MADE:([^\n]+)/g)].flatMap((m) => m[1] ? [m[1].trim()] : [])), created = boxes.filter((b) => madeAddrs.has(b.address)).map((b) => ({ address: b.address, password: b.password }));
-    logger.success(`Mail routing reconciled (${line.replace("MAILTENANT:", "")})`);
-    if (created.length) {
-      logger.info(`Mail: created ${created.length} mailbox(es) \u2014 credentials below (save them; shown once):`);
-      for (const b of created)
-        logger.info(`  ${b.address}  ${b.password}`);
-    }
-    return domain ? { domain, mailHost, dkimPubB64, created } : null;
-  } catch (err) {
-    logger.warn(`Mail routing reconcile skipped: ${getErrorMessage(err)}`);
-    return null;
-  }
-}
-export async function reconcileMailDns(res, ip, logger) {
-  const { domain, dkimPubB64 } = res;
-  let { mailHost } = res;
-  try {
-    const dns = await import("node:dns"), own = `mail.${domain}`;
-    if (own !== mailHost && (await dns.promises.resolve4(own)).includes(ip))
-      mailHost = own;
-  } catch {}
-  const spf = `v=spf1 ip4:${ip} ~all`, cfg = emailConfig || {}, firstBox = resolveMailboxes(cfg.mailboxes, domain)[0]?.address, dmarc = `v=DMARC1; p=quarantine; rua=mailto:${(typeof cfg.from?.address === "string" && cfg.from.address.includes("@") ? cfg.from.address : void 0) || firstBox || `chris@${domain}`}`, dkim = dkimPubB64 ? `v=DKIM1; k=rsa; p=${dkimPubB64}` : void 0, apiKey = process.env.PORKBUN_API_KEY, secretKey = process.env.PORKBUN_SECRET_KEY;
-  if (!apiKey || !secretKey) {
-    logger.warn(`Mail DNS: no Porkbun credentials \u2014 add these records for ${domain} by hand:`);
-    logger.info(`  MX    @                 10 ${mailHost}`);
-    logger.info(`  TXT   @                 ${spf}`);
-    if (dkim)
-      logger.info(`  TXT   mail._domainkey   ${dkim}`);
-    logger.info(`  TXT   _dmarc            ${dmarc}`);
-    return;
-  }
-  const auth = { apikey: apiKey, secretapikey: secretKey }, call = async (path, body) => {
-    return (await fetch(`https://api.porkbun.com/api/json/v3/${path}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ ...auth, ...body })
-    })).json().catch(() => ({}));
-  }, upsert = async (type, name, content, extra = {}) => {
-    const sub = name === "@" ? "" : `/${name}`;
-    await call(`dns/deleteByNameType/${domain}/${type}${sub}`, {});
-    const created = await call(`dns/create/${domain}`, { name: name === "@" ? "" : name, type, content, ttl: "600", ...extra });
-    if (created?.status !== "SUCCESS")
-      throw Error(`${type} ${name}: ${created?.message || "unknown Porkbun error"}`);
-  };
-  try {
-    await upsert("MX", "@", mailHost, { prio: "10" });
-    await upsert("TXT", "@", spf);
-    if (dkim)
-      await upsert("TXT", "mail._domainkey", dkim);
-    await upsert("TXT", "_dmarc", dmarc);
-    logger.success(`Mail DNS published for ${domain} (MX\u2192${mailHost}, SPF, DKIM, DMARC)`);
-  } catch (err) {
-    logger.warn(`Mail DNS reconcile skipped for ${domain}: ${getErrorMessage(err)}`);
-  }
-}
-async function reconcileConfigDns(sites, logger) {
-  if (["a", "aaaa", "cname", "mx", "txt"].reduce((total, key) => total + (Array.isArray(dnsConfig?.[key]) ? dnsConfig[key].length : 0), 0) === 0)
-    return;
-  const domains = new Set;
-  for (const site of Object.values(sites))
-    if (site?.domain && typeof site.domain === "string")
-      domains.add(site.domain.replace(/^www\./, ""));
-  for (const domain of domains)
-    try {
-      const result = await syncDnsConfig(domain, dnsConfig);
-      if (!result.provider)
-        continue;
-      if (result.created || result.failed)
-        logger.info(`DNS (config/dns.ts) ${domain}: ${result.created} created, ${result.kept} kept${result.failed ? `, ${result.failed} failed` : ""}`);
-    } catch (err) {
-      logger.warn(`DNS (config/dns.ts) reconcile for ${domain} failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-async function reconcileHetznerDns(sites, ip, logger) {
-  const domains = new Set;
-  for (const site of Object.values(sites))
-    if (site?.domain && typeof site.domain === "string")
-      domains.add(site.domain.replace(/^www\./, ""));
-  if (domains.size === 0)
-    return;
-  const providerConfigs = [];
-  if (process.env.PORKBUN_API_KEY && process.env.PORKBUN_SECRET_KEY)
-    providerConfigs.push({ provider: "porkbun", apiKey: process.env.PORKBUN_API_KEY, secretKey: process.env.PORKBUN_SECRET_KEY });
-  if (process.env.CLOUDFLARE_API_TOKEN)
-    providerConfigs.push({ provider: "cloudflare", apiToken: process.env.CLOUDFLARE_API_TOKEN });
-  if (process.env.AWS_ACCESS_KEY_ID || process.env.AWS_PROFILE)
-    providerConfigs.push({ provider: "route53" });
-  if (providerConfigs.length === 0) {
-    logger.warn("DNS: no DNS provider credentials found (PORKBUN_API_KEY/\u2026); skipping DNS reconciliation.");
-    for (const d of domains)
-      logger.info(`  Point manually:  A ${d} \u2192 ${ip}   and   A www.${d} \u2192 ${ip}`);
-    return;
-  }
-  const { detectDnsProvider } = await import("@stacksjs/ts-cloud");
-  logger.info("Reconciling DNS records...");
-  const resolveA = async (fqdn) => {
-    try {
-      const { resolve4 } = await import("node:dns/promises");
-      return await resolve4(fqdn);
-    } catch {
-      return [];
-    }
-  };
-  for (const domain of domains)
-    try {
-      const provider = await detectDnsProvider(domain, providerConfigs);
-      if (!provider) {
-        for (const sub of ["", "www"]) {
-          const fqdn = sub ? `${sub}.${domain}` : domain, current = await resolveA(fqdn);
-          if (current.includes(ip))
-            logger.success(`  DNS: ${fqdn} \u2192 ${ip} (externally managed, already correct)`);
-          else if (current.length === 0)
-            logger.warn(`  DNS: ${fqdn} does not resolve and no configured provider manages ${domain} \u2014 create it manually: A ${fqdn} \u2192 ${ip}`);
-          else
-            logger.warn(`  DNS: ${fqdn} resolves to ${current.join(", ")} but this deploy targets ${ip}, and no configured provider manages ${domain} \u2014 update it manually: A ${fqdn} \u2192 ${ip}`);
-        }
-        continue;
-      }
-      for (const sub of ["", "www"]) {
-        const fqdn = sub ? `${sub}.${domain}` : domain, res = await provider.upsertRecord(domain, { name: sub, type: "A", content: ip, ttl: 600 });
-        if (res?.success === !1)
-          logger.warn(`  DNS: ${fqdn} \u2192 ${ip} failed: ${res.error || "unknown error"}`);
-        else
-          logger.success(`  DNS: ${fqdn} \u2192 ${ip} (${provider.name})`);
-      }
-    } catch (err) {
-      logger.warn(`  DNS: ${domain} reconciliation failed: ${err?.message || err}`);
-    }
-}
-async function buildContainerImageWithPantry(args) {
-  const { slug, sites, verbose } = args, { execSync } = await import("node:child_process");
-  let cli;
-  for (const candidate of ["pantry", "ts-pantry"])
-    try {
-      execSync(`command -v ${candidate}`, { stdio: "pipe" });
-      cli = candidate;
-      break;
-    } catch {}
-  if (!cli) {
-    log.warn("pantry CLI not found on PATH \u2014 skipping container image build. Install pantry to enable `--docker`.");
-    return;
-  }
-  const dockerfile = "storage/framework/Dockerfile", canPush = Boolean(process.env.PANTRY_REGISTRY_TOKEN || process.env.PANTRY_TOKEN);
-  for (const [siteName, site] of Object.entries(sites)) {
-    if (!site?.start)
-      continue;
-    const tag = `${slug}-${siteName}:latest`;
-    log.info(`[${siteName}] building image ${tag} with pantry (native, no Docker daemon)...`);
-    const flags = [
-      "build",
-      ".",
-      "-t",
-      tag,
-      "-f",
-      dockerfile,
-      "--run-mode",
-      "skip"
-    ];
-    if (canPush)
-      flags.push("--push");
-    execSync(`${cli} ${flags.map((f) => f.includes(" ") ? `'${f}'` : f).join(" ")}`, {
-      stdio: verbose ? "inherit" : "pipe",
-      maxBuffer: 536870912
-    });
-    log.success(`[${siteName}] image built${canPush ? " + pushed to the pantry registry" : ""}`);
-  }
-}
-export function deploy(buddy) {
-  const descriptions = {
-    deploy: "Deploy your project",
-    project: "Target a specific project",
-    production: "Deploy to production",
-    development: "Deploy to development",
-    staging: "Deploy to staging",
-    yes: "Confirm all prompts by default",
-    domain: "Specify a domain to deploy to",
-    verbose: "Enable verbose output"
-  };
-  buddy.command("deploy [env]", descriptions.deploy).option("--domain", descriptions.domain, { default: void 0 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--prod", descriptions.production, { default: !0 }).option("--dev", descriptions.development, { default: !1 }).option("--yes", descriptions.yes, { default: !1 }).option("--site <name>", "Deploy only this one site to the existing server (multi-tenant surgical add)", { default: void 0 }).option("--staging", descriptions.staging, { default: !1 }).option("--docker", "Also build an OCI image with pantry (native, no Docker daemon) and push it to the pantry registry", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (envArg, options) => {
-    log.debug("Running `buddy deploy` ...", options);
-    await ensureDeployPrerequisites(options.verbose === !0);
-    const deployEnv = envArg || (options.staging ? "staging" : options.dev ? "development" : "production"), deployEnvName = deployEnv === "prod" ? "production" : deployEnv === "dev" ? "development" : deployEnv;
-    process.env.APP_ENV = deployEnvName;
-    {
-      const envFile = deployEnvName === "production" ? ".env.production" : `.env.${deployEnvName}`;
-      if (existsSync(p.projectPath(envFile)))
-        try {
-          const { loadEnv } = await import("@stacksjs/env");
-          loadEnv({ path: envFile, env: deployEnvName, keysFile: ".env.keys", overload: !0, quiet: !0 });
-        } catch (err) {
-          log.warn(`Could not load ${envFile}: ${getErrorMessage(err)}`);
-        }
-    }
-    const tsCloudConfig = await loadTsCloudConfig(deployEnvName);
-    if (tsCloudConfig && resolveProvider(tsCloudConfig) === "hetzner") {
-      await deployToHetzner(tsCloudConfig, deployEnv, options);
-      return;
-    }
-    if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY)
-      delete process.env.AWS_PROFILE;
-    const startTime = performance.now();
-    console.log("");
-    console.log("\uD83D\uDE80 Deploy");
-    console.log("");
-    let productionUrl;
-    if (deployEnv === "production" || deployEnv === "prod") {
-      const prodEnvPath = p.projectPath(".env.production");
-      if (existsSync(prodEnvPath)) {
-        const urlMatch = readFileSync(prodEnvPath, "utf-8").match(/^APP_URL=(.+)$/m);
-        if (urlMatch?.[1]) {
-          productionUrl = urlMatch[1].trim();
-          log.debug("Using APP_URL from .env.production:", productionUrl);
-        }
-      }
-    }
-    const envUrl = env.APP_URL, domain = options.domain || productionUrl || envUrl || app.url;
-    if ((options.prod || deployEnv === "production" || deployEnv === "prod") && !options.yes)
-      await confirmProductionDeployment();
-    if (!domain) {
-      log.info("No domain found in your .env.production or ./config/app.ts");
-      log.info("Please ensure your domain is properly configured.");
-      log.info("For more info, check out the docs or join our Discord.");
-      process.exit(ExitCode.FatalError);
-    }
-    log.info(`Deploying to ${italic(domain)} (${deployEnv})`);
-    await checkIfAwsIsBootstrapped(options);
-    options.domain = await configureDomain(domain, options, startTime);
-    const result = await runAction(Action.Deploy, options);
-    if (result.isErr) {
-      await outro("While running the `buddy deploy`, there was an issue", { startTime, useSeconds: !0 }, result.error);
-      process.exit(ExitCode.FatalError);
-    }
-    await outro("Project deployed.", { startTime, useSeconds: !0 });
-  });
-  onUnknownSubcommand(buddy, "deploy");
-}
-async function confirmProductionDeployment() {
-  if (!process.stdin.isTTY) {
-    log.error("Refusing to deploy to production from a non-interactive shell without confirmation.");
-    log.info("   \u27A1\uFE0F  Re-run with `--yes` to confirm (e.g. in CI): `buddy deploy --prod --yes`");
-    process.exit(ExitCode.InvalidArgument);
-  }
-  if (!await prompts.confirm({
-    message: "Are you sure you want to deploy to production?",
-    initial: !0
-  })) {
-    log.info("Aborting deployment...");
-    process.exit(ExitCode.InvalidArgument);
-  }
-}
-async function configureDomain(domain, options, startTime) {
-  log.debug("Configuring domain...", domain);
-  if (!domain) {
-    log.info("We could not identify a domain to deploy to.");
-    log.warn("Please set your .env or ./config/app.ts properly.");
-    log.info("Alternatively, specify a domain to deploy via the `--domain` flag.");
-    console.log("");
-    log.info("   \u27A1\uFE0F  Example: `buddy deploy --domain example.com`");
-    console.log("");
-    process.exit(ExitCode.FatalError);
-  }
-  if (domain.includes("localhost")) {
-    log.info("You are deploying to a local environment.");
-    log.warn("Please set your .env or ./config/app.ts properly. The domain we are deploying cannot be a `localhost` domain.");
-    log.info("Alternatively, specify a domain to deploy via the `--domain` flag.");
-    console.log("");
-    log.info("   \u27A1\uFE0F  Example: `buddy deploy --domain example.com`");
-    console.log("");
-    process.exit(ExitCode.FatalError);
-  }
-  if (await hasUserDomainBeenAddedToCloud(domain)) {
-    log.info("Domain is properly configured");
-    log.info("Your cloud is deploying...");
-    log.info(`${italic("This may take a while...")}`);
-    return domain;
-  }
-  console.log("");
-  log.info(`  \uD83D\uDC4B  It appears to be your first ${italic(domain)} deployment.`);
-  console.log("");
-  log.info(italic("Let\u2019s ensure it is all connected properly."));
-  log.info(italic("One moment..."));
-  console.log("");
-  const result = await addDomain({
-    ...options,
-    deploy: !0,
-    startTime
-  });
-  if (result.isErr) {
-    await outro("While running the `buddy deploy`, there was an issue", { startTime, useSeconds: !0 }, result.error);
-    process.exit(ExitCode.FatalError);
-  }
-  await outro("Added your domain.", { startTime, useSeconds: !0 });
-  process.exit(ExitCode.Success);
-}
-async function promptAndSaveCredentials() {
-  const accessKeyId = await prompts.text({
-    message: "AWS Access Key ID:",
-    validate: (value) => value.length > 0 ? !0 : "Access Key ID is required"
-  });
-  if (!accessKeyId) {
-    log.info("Deployment cancelled");
-    process.exit(ExitCode.Success);
-  }
-  const secretAccessKey = await prompts.password({
-    message: "AWS Secret Access Key:",
-    validate: (value) => value.length > 0 ? !0 : "Secret Access Key is required"
-  });
-  if (!secretAccessKey) {
-    log.info("Deployment cancelled");
-    process.exit(ExitCode.Success);
-  }
-  const region = await prompts.text({
-    message: "AWS Region:",
-    initial: "us-east-1"
-  });
-  if (!region) {
-    log.info("Deployment cancelled");
-    process.exit(ExitCode.Success);
-  }
-  const { setEnv } = await import("@stacksjs/env");
-  await setEnv("AWS_ACCESS_KEY_ID", accessKeyId, { file: ".env.production", encrypt: !0 });
-  await setEnv("AWS_SECRET_ACCESS_KEY", secretAccessKey, { file: ".env.production", encrypt: !0 });
-  await setEnv("AWS_REGION", region || "us-east-1", { file: ".env.production" });
-  process.env.AWS_ACCESS_KEY_ID = accessKeyId;
-  process.env.AWS_SECRET_ACCESS_KEY = secretAccessKey;
-  process.env.AWS_REGION = region || "us-east-1";
-  log.success("AWS credentials saved securely to .env.production");
-  console.log("");
-}
-function loadAwsCredentialsFromEnv() {
-  const environment = process.env.APP_ENV || process.env.NODE_ENV || "production", envFiles = [
-    p.projectPath(`.env.${environment}`),
-    p.projectPath(".env")
-  ];
-  for (const envPath of envFiles) {
-    if (!existsSync(envPath))
-      continue;
-    try {
-      const lines = readFileSync(envPath, "utf-8").split(`
-`);
-      let accessKeyId, secretAccessKey, region, accountId;
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("#") || !trimmed.includes("="))
-          continue;
-        const [key, ...valueParts] = trimmed.split("="), value = valueParts.join("=").trim();
-        if (key === "AWS_ACCESS_KEY_ID" && value)
-          accessKeyId = value;
-        else if (key === "AWS_SECRET_ACCESS_KEY" && value)
-          secretAccessKey = value;
-        else if (key === "AWS_REGION" && value)
-          region = value;
-        else if (key === "AWS_ACCOUNT_ID" && value)
-          accountId = value;
-      }
-      if (accessKeyId && secretAccessKey) {
-        log.debug(`Found AWS credentials in ${envPath}`);
-        return { accessKeyId, secretAccessKey, region, accountId };
-      }
-    } catch (error) {
-      log.debug(`Failed to read ${envPath} file:`, error);
-    }
-  }
-  return {};
-}
-async function checkIfAwsIsBootstrapped(options) {
-  let handlingAlreadyExists = !1;
-  try {
-    log.info("Ensuring AWS cloud stack exists...");
-    let hasCredentials = process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY;
-    if (!hasCredentials) {
-      const envCredentials = loadAwsCredentialsFromEnv();
-      if (envCredentials.accessKeyId && envCredentials.secretAccessKey) {
-        process.env.AWS_ACCESS_KEY_ID = envCredentials.accessKeyId;
-        process.env.AWS_SECRET_ACCESS_KEY = envCredentials.secretAccessKey;
-        if (envCredentials.region && !process.env.AWS_REGION)
-          process.env.AWS_REGION = envCredentials.region;
-        if (envCredentials.accountId && !process.env.AWS_ACCOUNT_ID)
-          process.env.AWS_ACCOUNT_ID = envCredentials.accountId;
-        hasCredentials = !0;
-        const environment = process.env.APP_ENV || process.env.NODE_ENV || "production";
-        log.success(`Using AWS credentials from .env.${environment}`);
-      }
-    }
-    if (!hasCredentials) {
-      const fileCredentials = loadAwsCredentialsFromFile();
-      if (fileCredentials.accessKeyId && fileCredentials.secretAccessKey) {
-        process.env.AWS_ACCESS_KEY_ID = fileCredentials.accessKeyId;
-        process.env.AWS_SECRET_ACCESS_KEY = fileCredentials.secretAccessKey;
-        if (fileCredentials.region && !process.env.AWS_REGION)
-          process.env.AWS_REGION = fileCredentials.region;
-        hasCredentials = !0;
-        log.success("Using AWS credentials from ~/.aws/credentials");
-      }
-    }
-    if (!hasCredentials) {
-      log.info("AWS credentials not found in .env or ~/.aws/credentials.");
-      log.info("You can either:");
-      log.info("  1. Set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in .env.production");
-      log.info("  2. Add credentials to ~/.aws/credentials");
-      log.info("  3. Configure them interactively below");
-      console.log("");
-      if (options?.yes) {
-        log.info("Skipping credential setup (--yes flag provided)");
-        process.exit(ExitCode.FatalError);
-      }
-      const setupCredentials = await prompts.confirm({
-        message: "Would you like to configure AWS credentials now?",
-        initial: !0
-      });
-      log.debug("setupCredentials response:", setupCredentials, typeof setupCredentials);
-      if (setupCredentials === void 0 || setupCredentials === !1) {
-        if (setupCredentials === void 0) {
-          console.log("");
-          log.info("Deployment cancelled");
-          process.exit(ExitCode.Success);
-        }
-        console.log("");
-        log.info("Skipping cloud infrastructure check");
-        log.info("You can configure AWS credentials later by running: buddy configure:aws");
-        return !0;
-      }
-      await promptAndSaveCredentials();
-    } else
-      log.success("AWS credentials found");
-    const appName = (process.env.APP_NAME || app.name || "stacks").toLowerCase().replace(/[^a-z0-9-]/g, "-"), stackName = `${appName}-cloud`, { AWSCloudFormationClient } = await import("@stacksjs/ts-cloud"), cfnClient = new AWSCloudFormationClient(process.env.AWS_REGION || "us-east-1");
-    let stackExists = !1, needsEmailUpdate = !1;
-    try {
-      const stack = (await cfnClient.describeStacks({ stackName })).Stacks?.[0];
-      if (stack) {
-        stackExists = !0;
-        log.success("Cloud stack exists");
-        const { AWSCloudFormationClient } = await import("@stacksjs/ts-cloud"), resources = await new AWSCloudFormationClient(process.env.AWS_REGION || "us-east-1").listStackResources(stackName), hasEmailBucket = resources.StackResourceSummaries?.some((r) => r.LogicalResourceId === "EmailBucket"), hasOutboundLambda = resources.StackResourceSummaries?.some((r) => r.LogicalResourceId === "OutboundEmailLambda"), hasConversionLambda = resources.StackResourceSummaries?.some((r) => r.LogicalResourceId === "EmailConversionLambda"), hasNotificationTopic = resources.StackResourceSummaries?.some((r) => r.LogicalResourceId === "EmailNotificationTopic"), hasMailApiLambda = resources.StackResourceSummaries?.some((r) => r.LogicalResourceId === "MailApiLambda"), hasMailUsersTable = resources.StackResourceSummaries?.some((r) => r.LogicalResourceId === "MailUsersTable"), hasMailServerInstance = resources.StackResourceSummaries?.some((r) => r.LogicalResourceId === "MailServerInstance"), currentEmailDomain = stack.Outputs?.find((o) => o.OutputKey === "EmailDomain")?.OutputValue, configuredDomain = (emailConfig?.from?.address?.includes("@") ? emailConfig.from.address.split("@")[1] : void 0) || "stacksjs.com";
-        if (!hasEmailBucket && emailConfig?.server?.scan !== void 0) {
-          log.info("Email infrastructure not found in stack, will update...");
-          needsEmailUpdate = !0;
-        } else if (currentEmailDomain && currentEmailDomain !== configuredDomain) {
-          log.info(`Email domain changed: ${currentEmailDomain} -> ${configuredDomain}, will update...`);
-          needsEmailUpdate = !0;
-        } else if (hasEmailBucket && (!hasOutboundLambda || !hasConversionLambda || !hasNotificationTopic)) {
-          log.info("Email infrastructure incomplete, will update...");
-          needsEmailUpdate = !0;
-        } else if (hasEmailBucket && (!hasMailApiLambda || !hasMailUsersTable)) {
-          log.info("Mail API infrastructure missing, will update...");
-          needsEmailUpdate = !0;
-        } else if (hasEmailBucket && !hasMailServerInstance && emailConfig?.server?.enabled) {
-          log.info("Mail server EC2 instance missing, will update...");
-          needsEmailUpdate = !0;
-        }
-        const currentMode = (stack.Outputs || []).find((o) => o.OutputKey === "MailServerMode")?.OutputValue, configuredMode = emailConfig?.server?.mode || "serverless";
-        if (currentMode && currentMode !== configuredMode) {
-          log.info(`Mail server mode changed: ${currentMode} -> ${configuredMode}, will update...`);
-          needsEmailUpdate = !0;
-        }
-        if (hasMailServerInstance && emailConfig?.server?.enabled) {
-          if (process.env.FORCE_MAIL_UPDATE === "true") {
-            log.info("Forcing mail server update...");
-            needsEmailUpdate = !0;
-          }
-        }
-        if (!needsEmailUpdate)
-          return !0;
-      }
-    } catch (error) {
-      const caught = error && typeof error === "object" ? error : { message: String(error) };
-      log.debug(`Stack not found: ${getErrorMessage(error)}`);
-    }
-    if (!stackExists)
-      log.info("Cloud stack not found, will be created by deploy action");
-    return !0;
-  } catch (err) {
-    if (!handlingAlreadyExists) {
-      log.error("Error checking cloud infrastructure");
-      log.error(`Error: ${getErrorMessage(err)}`);
-      if (options?.verbose)
-        console.error(err);
-    }
-    process.exit(ExitCode.FatalError);
-  }
-}