@stacksjs/buddy 0.70.88 → 0.70.90

package/dist/commands/dns.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function dns(buddy: CLI): void;

package/dist/commands/dns.js

@@ -0,0 +1,102 @@
+import process from "node:process";
+import { log, onUnknownSubcommand } from "@stacksjs/cli";
+import { config } from "@stacksjs/config";
+import { renderDnsConfig, resolveLiveRecords, syncDnsConfig } from "@stacksjs/dns";
+import { ExitCode } from "@stacksjs/types";
+export function dns(buddy) {
+  const descriptions = {
+    dns: "Lists the DNS records for a domain",
+    query: "Host name or IP address to query",
+    type: "Type of the DNS record being queried (A, MX, NS\u2026)",
+    nameserver: "Address of the nameserver to send packets to",
+    class: "Network class of the DNS record being queried (IN, CH, HS)",
+    udp: "Use the DNS protocol over UDP",
+    tcp: "Use the DNS protocol over TCP",
+    tls: "Use the DNS-over-TLS protocol",
+    https: "Use the DNS-over-HTTPS protocol",
+    short: "Short mode: display nothing but the first result",
+    json: "Display the output as JSON",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("dns [domain]", descriptions.dns).option("-q, --query <query>", descriptions.query).option("-t, --type <type>", descriptions.type, { default: "A" }).option("-n, --nameserver <nameserver>", descriptions.nameserver).option("--class <class>", descriptions.class).option("-U, --udp", descriptions.udp).option("-T, --tcp", descriptions.tcp).option("-S, --tls", descriptions.tls).option("-H, --https", descriptions.https).option("-1, --short", descriptions.short, { default: !1 }).option("-J, --json", descriptions.json, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (domain, options) => {
+    log.debug("Running `buddy dns [domain]` ...", options);
+    const targetDomain = domain || config.app.url;
+    let DnsClient, formatOutput;
+    try {
+      const dnsx = await import("@stacksjs/dnsx");
+      DnsClient = dnsx.DnsClient;
+      formatOutput = dnsx.formatOutput;
+    } catch (err) {
+      log.error("`buddy dns` needs the @stacksjs/dnsx runtime, but only the type declarations are currently published. Install a build with the JS runtime (or wait for the next dnsx release) and re-run.");
+      log.debug(`[dns] import failure: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(ExitCode.FatalError);
+    }
+    try {
+      const client = new DnsClient({
+        domains: [targetDomain],
+        type: options.type,
+        nameserver: options.nameserver,
+        class: options.class,
+        udp: options.udp,
+        tcp: options.tcp,
+        tls: options.tls,
+        https: options.https,
+        short: options.short,
+        json: options.json,
+        verbose: options.verbose
+      }), startTime = performance.now(), responses = await client.query(), duration = performance.now() - startTime, output = formatOutput(responses, {
+        json: options.json ?? !1,
+        short: options.short ?? !1,
+        showDuration: duration,
+        colors: { enabled: !0 },
+        rawSeconds: !1
+      });
+      console.log(output);
+    } catch (error) {
+      log.error(`DNS query failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(ExitCode.FatalError);
+    }
+    process.exit(ExitCode.Success);
+  });
+  const bareDomain = (input) => (input || config.app.url || "").replace(/^[a-z]+:\/\//i, "").replace(/[/:].*$/, "");
+  buddy.command("dns:pull [domain]", "Print a domain's live DNS records as a config/dns.ts block").option("--verbose", descriptions.verbose, { default: !1 }).action(async (domain, options) => {
+    const target = bareDomain(domain);
+    log.debug(`Running \`buddy dns:pull ${target}\` ...`, options);
+    const records = await resolveLiveRecords(target);
+    if (!records.length) {
+      log.error(`No DNS records resolved for ${target}.`);
+      process.exit(ExitCode.FatalError);
+    }
+    console.log(renderDnsConfig(target, records));
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("dns:diff [domain]", "Show which config/dns.ts records are missing from the live zone").option("--verbose", descriptions.verbose, { default: !1 }).action(async (domain, options) => {
+    const target = bareDomain(domain);
+    log.debug(`Running \`buddy dns:diff ${target}\` ...`, options);
+    const { plan, provider } = await syncDnsConfig(target, config.dns, { dryRun: !0 });
+    for (const item of plan.items) {
+      const detail = item.record.type === "TXT" || item.record.type === "MX" ? ` ${item.record.content}` : ` \u2192 ${item.record.content}`;
+      console.log(`  ${item.action === "create" ? "+ create" : "  keep  "} ${item.record.type.padEnd(5)} ${item.record.name}${detail}`);
+    }
+    console.log(`
+${plan.create.length} to create, ${plan.keep.length} already present (${provider ? `registrar: ${provider}` : "public DNS"})`);
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("dns:sync [domain]", "Additively sync config/dns.ts to the registrar (creates missing records; never deletes or overwrites)").option("--dry-run", "Show the plan without writing any records", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (domain, options) => {
+    const target = bareDomain(domain);
+    log.debug(`Running \`buddy dns:sync ${target}\` ...`, options);
+    const result = await syncDnsConfig(target, config.dns, { dryRun: options.dryRun });
+    if (!result.provider && !options.dryRun) {
+      log.warn(`No DNS provider credentials found (e.g. PORKBUN_API_KEY / PORKBUN_SECRET_KEY) \u2014 nothing was synced. ${result.plan.create.length} record(s) would be created.`);
+      process.exit(ExitCode.Success);
+    }
+    for (const record of result.plan.create)
+      console.log(`  ${result.applied ? "created" : "would create"} ${record.type.padEnd(5)} ${record.name} \u2192 ${record.content}`);
+    const verb = result.applied ? "created" : "to create", count = result.applied ? result.created : result.plan.create.length;
+    console.log(`
+dns:sync ${target}: ${count} ${verb}, ${result.kept} kept${result.failed ? `, ${result.failed} failed` : ""}${result.provider ? ` (${result.provider})` : ""}`);
+    process.exit(result.failed > 0 ? ExitCode.FatalError : ExitCode.Success);
+  });
+  onUnknownSubcommand(buddy, "dns");
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function doctor(buddy: CLI): void;

package/dist/commands/doctor.js

@@ -0,0 +1,285 @@
+import process from "node:process";
+import { bold, dim, green, intro, log, onUnknownSubcommand, red, yellow } from "@stacksjs/cli";
+import { feature } from "@stacksjs/config";
+import { storage } from "@stacksjs/storage";
+import { FEATURE_NAMES, featurePathsPresent } from "./features";
+async function probe(checks, name, fn, timeoutMs = 2000) {
+  const start = Date.now();
+  try {
+    const ac = new AbortController, timer = setTimeout(() => ac.abort(), timeoutMs), message = await Promise.race([
+      fn(),
+      new Promise((_, rej) => ac.signal.addEventListener("abort", () => rej(Error(`timed out (>${Math.round(timeoutMs / 1000)}s)`))))
+    ]);
+    clearTimeout(timer);
+    checks.push({ name, status: "pass", message: `${message} (${Date.now() - start}ms)` });
+  } catch (err) {
+    checks.push({
+      name,
+      status: "fail",
+      message: err instanceof Error ? err.message : String(err)
+    });
+  }
+}
+export function doctor(buddy) {
+  buddy.command("doctor", "Run health checks on your Stacks installation").option("--no-fail", "Print results but always exit 0 (CI ramp-up)").action(async (options) => {
+    log.debug("Running `buddy doctor` ...");
+    await intro("buddy doctor");
+    const checks = [], bunVersion = process.versions.bun;
+    if (bunVersion)
+      if (Number.parseInt(bunVersion.split(".")[0] || "0", 10) >= 1)
+        checks.push({
+          name: "Bun Runtime",
+          status: "pass",
+          message: `v${bunVersion}`
+        });
+      else
+        checks.push({
+          name: "Bun Runtime",
+          status: "warn",
+          message: `v${bunVersion} (v1.0+ recommended)`
+        });
+    else
+      checks.push({
+        name: "Bun Runtime",
+        status: "fail",
+        message: "Not found"
+      });
+    const nodeVersion = process.versions.node;
+    if (nodeVersion)
+      if (Number.parseInt(nodeVersion.split(".")[0] || "0", 10) >= 18)
+        checks.push({
+          name: "Node.js",
+          status: "pass",
+          message: `v${nodeVersion}`
+        });
+      else
+        checks.push({
+          name: "Node.js",
+          status: "warn",
+          message: `v${nodeVersion} (v18+ recommended)`
+        });
+    try {
+      const pkg = await storage.readPackageJson("./package.json");
+      if (pkg.name)
+        checks.push({
+          name: "package.json",
+          status: "pass",
+          message: `Found: ${pkg.name}`
+        });
+    } catch {
+      checks.push({
+        name: "package.json",
+        status: "fail",
+        message: "Not found in current directory"
+      });
+    }
+    try {
+      await storage.readTextFile(".env");
+      checks.push({
+        name: ".env file",
+        status: "pass",
+        message: "Found"
+      });
+    } catch {
+      checks.push({
+        name: ".env file",
+        status: "warn",
+        message: "Not found (optional)"
+      });
+    }
+    const appKey = process.env.APP_KEY;
+    if (appKey && appKey.length > 0)
+      checks.push({
+        name: "APP_KEY",
+        status: appKey.length >= 32 ? "pass" : "warn",
+        message: appKey.length >= 32 ? "Set (\u226532 chars)" : `Set but short (${appKey.length} chars; \u226532 recommended)`
+      });
+    else
+      checks.push({
+        name: "APP_KEY",
+        status: "fail",
+        message: "Not set \u2014 features that depend on it (encrypted columns, signed URLs, env decryption) will refuse to run. Run `buddy key:generate`."
+      });
+    await probe(checks, "Database", async () => {
+      const { db } = await import("@stacksjs/database");
+      await db.unsafe?.("SELECT 1");
+      return "Reachable";
+    });
+    await probe(checks, "Database FKs", async () => {
+      const { auditForeignKeys } = await import("@stacksjs/database"), result = await auditForeignKeys();
+      if (result.declared.length === 0)
+        return "No belongsTo declarations";
+      if (result.missing.length === 0)
+        return `${result.declared.length} declared FKs all present`;
+      const sample = result.missing.slice(0, 5).map((fk) => `${fk.fromTable}.${fk.fromColumn} \u2192 ${fk.toTable}.${fk.toColumn}`).join(", "), more = result.missing.length > 5 ? ` (+${result.missing.length - 5} more)` : "";
+      throw Error(`${result.missing.length}/${result.declared.length} declared FKs missing from live schema: ${sample}${more}. Run \`buddy migrate:fresh\` (will reset data) or \`buddy migrate\` against a clean DB.`);
+    });
+    await probe(checks, "Unique indexes", async () => {
+      const { auditUniqueIndexes } = await import("@stacksjs/database"), result = await auditUniqueIndexes();
+      if (!result.supported)
+        return "Dialect not audited (skipped)";
+      const skipped = result.skippedTables.length > 0 ? `, ${result.skippedTables.length} tables skipped (not migrated)` : "";
+      if (result.missing.length === 0)
+        return `${result.declared.length} declared unique constraints all indexed${skipped}`;
+      const sample = result.missing.slice(0, 5).map((u) => `${u.table}.${u.columns.join("+")}`).join(", "), more = result.missing.length > 5 ? ` (+${result.missing.length - 5} more)` : "", first = result.missing[0];
+      if (!first)
+        throw Error("Unique-index audit reported missing entries without details");
+      const example = `CREATE UNIQUE INDEX IF NOT EXISTS "${first.table}_${first.columns.join("_")}_unique" ON "${first.table}" ("${first.columns.join('", "')}")`;
+      throw Error(`${result.missing.length}/${result.declared.length} declared unique constraints have no UNIQUE index: ${sample}${more}. Run \`buddy migrate\` (re-queues missing unique-index migrations, #1952) \u2014 dedupe duplicate rows first or migrate hard-fails; if no migration file exists run \`buddy generate:migrations\`, or create manually: ${example}`);
+    }, 1e4);
+    await probe(checks, "FK orphans", async () => {
+      const { findFkOrphans } = await import("@stacksjs/database"), result = await findFkOrphans();
+      if (!result.supported)
+        return "Dialect not audited (skipped)";
+      if (result.total === 0)
+        return "No orphan rows (PRAGMA foreign_key_check clean)";
+      const sample = result.orphans.slice(0, 5).map((o) => `${o.table}.${o.column} \u2192 ${o.parent} (${o.count})`).join(", "), more = result.orphans.length > 5 ? ` (+${result.orphans.length - 5} more)` : "", first = result.orphans[0];
+      if (!first)
+        throw Error("Foreign-key audit reported orphan rows without details");
+      throw Error(`${result.total} orphan rows violate FKs: ${sample}${more}. Legacy rows written under foreign_keys=OFF (#1951). Review and clean manually, e.g. DELETE FROM ${first.table} WHERE ${first.column} IS NOT NULL AND ${first.column} NOT IN (SELECT id FROM ${first.parent}) \u2014 doctor never deletes data.`);
+    }, 1e4);
+    await probe(checks, "Cache", async () => {
+      const { cache } = await import("@stacksjs/cache"), k = `__doctor_${Date.now()}`;
+      await cache.set(k, 1, 5);
+      const v = await cache.get(k);
+      await cache.del(k);
+      if (v !== 1)
+        throw Error("round-trip failed");
+      return "Round-trip ok";
+    });
+    await probe(checks, "Queue driver", async () => {
+      const { config } = await import("@stacksjs/config");
+      return `Driver: ${config.queue?.default ?? "sync"}`;
+    });
+    await probe(checks, "Mail driver", async () => {
+      const { config } = await import("@stacksjs/config");
+      return `Driver: ${config.email?.default ?? "log"}`;
+    });
+    const hasAwsCreds = Boolean(process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY), hasAwsRole = Boolean(process.env.AWS_PROFILE) || Boolean(process.env.AWS_ROLE_ARN);
+    if (hasAwsCreds || hasAwsRole)
+      checks.push({
+        name: "AWS credentials",
+        status: "pass",
+        message: hasAwsCreds ? "Static keys in env" : "IAM role configured"
+      });
+    else
+      checks.push({
+        name: "AWS credentials",
+        status: "warn",
+        message: "Not configured (cloud / SES / S3 commands will fail)"
+      });
+    await probe(checks, ".env decryption", async () => {
+      const fs = await import("node:fs");
+      if (!fs.existsSync(".env"))
+        return "No .env (skipped)";
+      const content = fs.readFileSync(".env", "utf8");
+      if (!/(?:^|=)(?:enc|encrypted):/m.test(content))
+        return "No encrypted values";
+      const privateKey = process.env.DOTENV_PRIVATE_KEY;
+      if (!privateKey)
+        throw Error("Encrypted values present but DOTENV_PRIVATE_KEY is unset");
+      const { parse } = await import("@stacksjs/env"), { errors } = parse(content, { privateKey });
+      if (errors.length > 0)
+        throw Error(errors.join("; "));
+      return "All encrypted values decrypt cleanly";
+    });
+    try {
+      const { filesystems } = await import("@stacksjs/config"), driver = filesystems.driver ?? "local";
+      if (driver === "s3") {
+        const bucket = process.env.S3_BUCKET ?? filesystems.s3?.bucket, accessKeyId = process.env.AWS_ACCESS_KEY_ID, secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY, missing = [];
+        if (!bucket)
+          missing.push("S3_BUCKET");
+        if (!accessKeyId)
+          missing.push("AWS_ACCESS_KEY_ID");
+        if (!secretAccessKey)
+          missing.push("AWS_SECRET_ACCESS_KEY");
+        if (missing.length > 0)
+          checks.push({
+            name: "Storage credentials",
+            status: "warn",
+            message: `Default disk is 's3' but missing: ${missing.join(", ")}. Uploads will throw on first use.`
+          });
+        else
+          checks.push({
+            name: "Storage credentials",
+            status: "pass",
+            message: "s3 default disk has bucket + AWS credentials"
+          });
+      } else
+        checks.push({
+          name: "Storage credentials",
+          status: "pass",
+          message: `Default disk is '${driver}' (no remote credentials required)`
+        });
+    } catch (err) {
+      checks.push({
+        name: "Storage credentials",
+        status: "warn",
+        message: `Could not audit storage config: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+    try {
+      const orphans = [];
+      for (const name of FEATURE_NAMES) {
+        if (feature(name))
+          continue;
+        const present = featurePathsPresent(name);
+        if (present.length > 0)
+          orphans.push({ feature: name, count: present.length });
+      }
+      if (orphans.length > 0) {
+        const summary = orphans.map((o) => `${o.feature} (${o.count} path${o.count === 1 ? "" : "s"})`).join(", ");
+        checks.push({
+          name: "Feature scaffolding",
+          status: "warn",
+          message: `Stamped files remain for disabled features: ${summary}. Run \`./buddy <feature>:uninstall\` to remove or \`<feature>:install\` to re-enable.`
+        });
+      } else
+        checks.push({
+          name: "Feature scaffolding",
+          status: "pass",
+          message: "No orphan files for disabled features"
+        });
+    } catch (err) {
+      checks.push({
+        name: "Feature scaffolding",
+        status: "warn",
+        message: `Could not audit feature scaffolding: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+    log.info("");
+    log.info(bold("Health Check Results:"));
+    log.info(dim("\u2500".repeat(60)));
+    log.info("");
+    let hasFailures = !1, hasWarnings = !1;
+    for (const check of checks) {
+      let statusIcon = "", statusColor = (text) => text;
+      if (check.status === "pass") {
+        statusIcon = "\u2713";
+        statusColor = green;
+      } else if (check.status === "warn") {
+        statusIcon = "\u26A0";
+        statusColor = yellow;
+        hasWarnings = !0;
+      } else {
+        statusIcon = "\u2717";
+        statusColor = red;
+        hasFailures = !0;
+      }
+      log.info(`${statusColor(statusIcon)} ${bold(check.name.padEnd(20))} ${dim(check.message)}`);
+    }
+    log.info("");
+    log.info(dim("\u2500".repeat(60)));
+    log.info("");
+    if (hasFailures) {
+      log.error("Some critical checks failed. Please address the issues above.");
+      if (options?.fail !== !1)
+        process.exit(1);
+    } else if (hasWarnings)
+      log.info(yellow("Some checks have warnings. Your system should work but may have issues."));
+    else
+      log.success(green("All checks passed! Your Stacks installation looks healthy."));
+    log.info("");
+  });
+  onUnknownSubcommand(buddy, "doctor");
+}

package/dist/commands/domains.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function domains(buddy: CLI): void;

package/dist/commands/domains.js

@@ -0,0 +1,159 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { bgCyan, bold, intro, italic, log, onUnknownSubcommand, outro, prompts } from "@stacksjs/cli";
+import { config } from "@stacksjs/config";
+import { addDomain } from "@stacksjs/dns";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function domains(buddy) {
+  const descriptions = {
+    purchase: "Purchase a domain",
+    add: "Add a domain to your cloud",
+    remove: "Remove a domain from your cloud",
+    skip: "Skip the confirmation prompt",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  }, c = config.dns.contactInfo;
+  buddy.command("domains:purchase <domain>", descriptions.purchase).option("--years <years>", "Number of years to purchase the domain for", {
+    default: 1
+  }).option("--privacy", "Enable privacy protection", { default: !0 }).option("--auto-renew", "Enable auto-renew", { default: !0 }).option("--first-name <firstName>", "Registrant first name", {
+    default: c?.firstName
+  }).option("--last-name <lastName>", "Registrant last name", {
+    default: c?.lastName
+  }).option("--organization <organization>", "Registrant organization name", {
+    default: c?.organizationName
+  }).option("--address-line1 <address>", "Registrant address line 1", {
+    default: c?.addressLine1
+  }).option("--address-line2 <address>", "Registrant address line 2", {
+    default: c?.addressLine2
+  }).option("--city <city>", "Registrant city", { default: c?.city }).option("--state <state>", "Registrant state", { default: c?.state }).option("--country <country>", "Registrant country code", {
+    default: c?.countryCode
+  }).option("--zip <zip>", "Registrant zip", { default: c?.zip }).option("--phone <phone>", "Registrant phone", { default: c?.phoneNumber }).option("--email <email>", "Registrant email", { default: c?.email }).option("--admin-first-name <firstName>", "Admin first name", {
+    default: c?.admin?.firstName || c?.firstName
+  }).option("--admin-last-name <lastName>", "Admin last name", {
+    default: c?.admin?.lastName || c?.lastName
+  }).option("--admin-organization <organization>", "Admin organization", {
+    default: c?.admin?.organizationName || c?.organizationName
+  }).option("--admin-address-line1 <address>", "Admin address line 1", {
+    default: c?.admin?.addressLine1 || c?.addressLine1
+  }).option("--admin-address-line2 <address>", "Admin address line 2", {
+    default: c?.admin?.addressLine2 || c?.addressLine2
+  }).option("--admin-city <city>", "Admin city", {
+    default: c?.admin?.city || c?.city
+  }).option("--admin-state <state>", "Admin state", {
+    default: c?.admin?.state || c?.state
+  }).option("--admin-country <country>", "Admin country code", {
+    default: c?.admin?.countryCode || c?.countryCode
+  }).option("--admin-zip <zip>", "Admin zip", {
+    default: c?.admin?.zip || c?.zip
+  }).option("--admin-phone <phone>", "Admin phone number", {
+    default: c?.admin?.phoneNumber || c?.phoneNumber
+  }).option("--admin-email <email>", "Admin email", {
+    default: c?.admin?.email || c?.email
+  }).option("--tech-first-name <firstName>", "Tech first name", {
+    default: c?.tech?.firstName || c?.firstName
+  }).option("--tech-last-name <lastName>", "Tech last name", {
+    default: c?.tech?.lastName || c?.lastName
+  }).option("--tech-organization <organization>", "Tech organization name", {
+    default: c?.tech?.organizationName || c?.organizationName
+  }).option("--tech-address-line1 <address>", "Tech address line 1", {
+    default: c?.tech?.addressLine1 || c?.addressLine1
+  }).option("--tech-address-line2 <address>", "Tech address line 2", {
+    default: c?.tech?.addressLine2 || c?.addressLine2
+  }).option("--tech-city <city>", "Tech city", {
+    default: c?.tech?.city || c?.city
+  }).option("--tech-state <state>", "Tech state", {
+    default: c?.tech?.state || c?.state
+  }).option("--tech-country <country>", "Tech country", {
+    default: c?.tech?.countryCode || c?.countryCode
+  }).option("--tech-zip <zip>", "Tech zip", { default: c?.tech?.zip || c?.zip }).option("--tech-phone <phone>", "Tech phone", {
+    default: c?.tech?.phoneNumber || c?.phoneNumber
+  }).option("--tech-email <email>", "Tech email", {
+    default: c?.tech?.email || c?.email
+  }).option("--privacy-admin", "Enable privacy protection for admin", {
+    default: c?.privacyAdmin || c?.privacy || !0
+  }).option("--privacy-tech", "Enable privacy protection for tech", {
+    default: c?.privacyTech || c?.privacy || !0
+  }).option("--privacy-registrant", "Enable privacy protection for registrant", {
+    default: c?.privacyRegistrant || c?.privacy || !0
+  }).option("--contact-type <type>", "Contact type", { default: "person" }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (domain, options) => {
+    log.debug("Running `buddy domains:purchase <domain>` ...", options);
+    options.domain = domain;
+    const startTime = await intro("buddy domains:purchase"), result = await runAction(Action.DomainsPurchase, options);
+    if (result.isErr) {
+      await outro("While running the domains:purchase command, there was an issue", { startTime, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    const { confirm } = await prompts({
+      name: "confirm",
+      type: "confirm",
+      message: `Would you like to set ${domain} as your APP_URL?`
+    });
+    if (!confirm) {
+      await outro(`Alrighty! ${italic(domain)} was added to your account.`, {
+        startTime,
+        useSeconds: !0,
+        type: "success"
+      });
+      log.info(`Please note, you may need to validate your email address. Check your ${italic(options.registrantEmail)} inbox.`);
+      process.exit(ExitCode.Success);
+    }
+    const { writeEnv } = await import("@stacksjs/env");
+    writeEnv("APP_URL", domain);
+    let message = `Great! ${italic(domain)} was added to your account.`;
+    message += `
+
+And your APP_URL has been set to ${italic(domain)}.
+      
+Please note, this change has not been deployed yet.
+      
+The next time you run ${bgCyan(italic(bold(" buddy deploy ")))}, your app will deploy to ${italic(domain)}.
+      
+${italic("You may need to deploy 2-3 times for the changes to take effect. Issue tracked here: https://github.com/stacksjs/stacks/issues/685")}`;
+    await outro(message, { startTime, useSeconds: !0, type: "info" });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("domains:add <domain>", descriptions.add).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy domains:add <domain>` ...", options);
+    const startTime = await intro("buddy domains:add"), result = await addDomain({
+      ...options,
+      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);
+  });
+  buddy.command("domains:remove <domain>", descriptions.remove).option("--yes", descriptions.skip, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy domains:remove <domain>` ...", options);
+    const domain = options.domain || config.app.url, opts = { ...options, domain }, startTime = await intro("buddy domains:remove");
+    if (!opts.yes) {
+      const { confirm } = await prompts({
+        name: "confirm",
+        type: "confirm",
+        message: `Are you sure you want to remove ${domain}?`
+      });
+      if (!confirm) {
+        await outro("Cancelled the domains:remove command", {
+          startTime,
+          useSeconds: !0,
+          type: "info"
+        });
+        process.exit(ExitCode.Success);
+      }
+    }
+    const result = await runAction(Action.DomainsRemove, opts);
+    if (result.isErr) {
+      await outro("While running the domains:remove command, there was an issue", { startTime, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Removed your domain DNS records.", {
+      startTime,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  onUnknownSubcommand(buddy, "domains");
+}

package/dist/commands/email.d.ts

@@ -0,0 +1,2 @@
+import type { CLI } from '@stacksjs/types';
+export declare function email(buddy: CLI): void;