@stacksjs/buddy 0.58.73 → 0.59.2

package/dist/chunk-d2428b387d843985.js

@@ -0,0 +1,2016 @@
+// src/commands/build.ts
+import process from "process";
+import {runAction as runAction2} from "@stacksjs/actions";
+import {intro, log, outro} from "@stacksjs/cli";
+import {ExitCode} from "@stacksjs/types";
+import {Action} from "@stacksjs/enums";
+function build(buddy) {
+  const descriptions = {
+    build: "Build any of your libraries (packages) for production use",
+    components: "Build your component library",
+    vueComponents: "Build your Vue component library",
+    webComponents: "Build your framework agnostic web component library",
+    elements: "An alias to the -w flag",
+    buddy: "Build the Buddy binary",
+    functions: "Build your function library",
+    desktop: "Build the Desktop Application",
+    pages: "Build your frontend",
+    docs: "Build your documentation",
+    framework: "Build Stacks framework",
+    cli: "Automagically build the CLI",
+    server: "Build the Stacks cloud server (Docker image)",
+    select: "What are you trying to build?",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("build [type]", descriptions.build).option("-c, --components", descriptions.components).option("-v, --vue-components", descriptions.vueComponents).option("-w, --web-components", descriptions.webComponents).option("-e, --elements", descriptions.elements).option("-f, --functions", descriptions.functions).option("-p, --views", descriptions.pages).option("-d, --docs", descriptions.docs).option("-b, --buddy", descriptions.buddy, { default: false }).option("-s, --stacks", descriptions.framework, { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--server", descriptions.server, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (server, options) => {
+    log.debug("Running `buddy build` ...", options);
+    switch (server) {
+      case "components":
+        options.components = true;
+        break;
+      case "vue":
+        options.vueComponents = true;
+        break;
+      case "web-components":
+        options.webComponents = true;
+        break;
+      case "functions":
+        options.functions = true;
+        break;
+      case "views":
+        options.views = true;
+        break;
+      case "docs":
+        options.docs = true;
+        break;
+      case "buddy":
+        options.buddy = true;
+        break;
+      case "cli":
+        options.buddy = true;
+        break;
+      case "stacks":
+        options.stacks = true;
+        break;
+      case "server":
+        options.stacks = true;
+        break;
+      default:
+        break;
+    }
+    if (hasNoOptions(options)) {
+      let answers = await log.prompt.require().multiselect(descriptions.select, {
+        options: [
+          { label: "Components", value: "components" },
+          { label: "Web Components", value: "web-components" },
+          { label: "Functions", value: "functions" },
+          { label: "Views", value: "views" },
+          { label: "Documentation", value: "docs" }
+        ]
+      });
+      if (answers !== null)
+        process.exit(ExitCode.InvalidArgument);
+      if (isString(answers))
+        answers = [answers];
+      options = answers.reduce((a, v) => ({ ...a, [v]: true }), {});
+    }
+    await runAction2(Action.BuildStacks, options);
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("build:components", "Automagically build component libraries for production use & npm/CDN distribution").alias("prod:components").option("-c, --components", descriptions.components, { default: true }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log.debug("Running `buddy build:components` ...", options);
+    await runAction2(Action.BuildComponentLibs, options);
+  });
+  buddy.command("build:cli", descriptions.cli).alias("prod:cli").option("-b, --buddy", descriptions.buddy, { default: true }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log.debug("Running `buddy build:cli` ...", options);
+    await runAction2(Action.BuildCli, options);
+  });
+  buddy.command("build:server", descriptions.server).alias("prod:server").alias("build:docker").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log.debug("Running `buddy build:server` ...", options);
+    await runAction2(Action.BuildServer, options);
+  });
+  buddy.command("build:functions", "Automagically build function library for npm/CDN distribution").option("-f, --functions", descriptions.functions, { default: true }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log.debug("Running `buddy `build:functions` ...", options);
+    await runAction2(Action.BuildFunctionLib, options);
+  });
+  buddy.command("build:vue-components", "Automagically build Vue component library for npm/CDN distribution").alias("build:vue").alias("prod:vue-components").alias("prod:vue").option("-v, --vue-components", descriptions.vueComponents, { default: true }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).alias("build:vue").action(async (options) => {
+    log.debug("Running `buddy build:vue-components` ...", options);
+    await runAction2(Action.BuildVueComponentLib, options);
+  });
+  buddy.command("build:web-components", "Automagically build Web Component library for npm/CDN distribution").alias("build:wc").alias("prod:web-components").alias("prod:wc").option("-w, --web-components", descriptions.webComponents, { default: true }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log.debug("Running `buddy build:web-components` ...", options);
+    await runAction2(Action.BuildWebComponentLib, options);
+  });
+  buddy.command("build:docs", "Automagically build your documentation site.").alias("prod:docs").alias("build:documentation").alias("prod:documentation").option("-d, --docs", descriptions.docs, { default: true }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log.debug("Running `buddy build:docs` ...", options);
+    await runAction2(Action.BuildDocs, options);
+  });
+  buddy.command("build:core", "Automagically build the Stacks core.").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log.debug("Running `buddy build:core` ...", options);
+    const startTime = await intro("buddy build:core");
+    const result = await runAction2(Action.BuildCore, options);
+    if (result.isErr()) {
+      log.error("Failed to build the Stacks core.", result.error);
+      process.exit();
+    }
+    await outro("Core packages built successfully", { startTime, useSeconds: true });
+  });
+  buddy.command("build:desktop", descriptions.desktop).alias("prod:desktop").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log.debug("Running `buddy build:desktop` ...", options);
+    const perf = await intro("buddy build:desktop");
+    const result = await runAction2(Action.BuildDesktop, options);
+    if (result.isErr()) {
+      await outro("While running the build:desktop command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process.exit();
+    }
+    console.log("");
+    await outro("Exited", { startTime: perf, useSeconds: true });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("build:stacks", "Build the Stacks framework.").option("-s, --stacks", descriptions.framework, { default: true }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log.debug("Running `buddy build:stacks` ...", options);
+    const startTime = await intro("buddy build:stacks");
+    const result = await runAction2(Action.BuildStacks, options);
+    if (result.isErr()) {
+      log.error("Failed to build Stacks.", result.error);
+      process.exit();
+    }
+    await outro("Stacks built successfully", { startTime, useSeconds: true });
+  });
+  buddy.on("build:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process.exit(1);
+  });
+}
+var hasNoOptions = function(options) {
+  return !options.components && !options.vueComponents && !options.webComponents && !options.elements && !options.functions && !options.views && !options.docs && !options.stacks && !options.buddy;
+};
+
+// src/commands/changelog.ts
+import process2 from "process";
+import {runAction as runAction3} from "@stacksjs/actions";
+import {intro as intro2, log as log2, outro as outro2} from "@stacksjs/cli";
+import {Action as Action2} from "@stacksjs/enums";
+function changelog(buddy) {
+  const descriptions = {
+    changelog: "Create a CHANGELOG.md file",
+    quiet: "Minimal output",
+    dryRun: "Do not write the file, just output the changes",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("changelog", descriptions.changelog).option("-q, --quiet", descriptions.quiet, { default: false }).option("-d, --dry-run", descriptions.dryRun, { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log2.debug("Running `buddy changelog` ...", options);
+    const perf = await intro2("buddy changelog");
+    const result = await runAction3(Action2.Changelog, options);
+    if (result.isErr()) {
+      await outro2("While running the changelog command, there was an issue", { ...options, startTime: perf, useSeconds: true }, result.error);
+      process2.exit();
+    }
+    await outro2("Generated CHANGELOG.md", { ...options, startTime: perf, useSeconds: true, type: "success" });
+  });
+  buddy.on("changelog:*", () => {
+    console.log("Invalid command: %s", buddy.args.join(" "));
+    console.log("See --help for a list of available commands.");
+    process2.exit(1);
+  });
+}
+
+// src/commands/clean.ts
+import process3 from "process";
+import {ExitCode as ExitCode2} from "@stacksjs/types";
+import {runAction as runAction4} from "@stacksjs/actions";
+import {intro as intro3, log as log3, outro as outro3} from "@stacksjs/cli";
+import {Action as Action3} from "@stacksjs/enums";
+function clean(buddy) {
+  const descriptions = {
+    clean: "Removes all node_modules & lock files",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("clean", descriptions.clean).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log3.debug("Running `buddy clean` ...", options);
+    const perf = await intro3("buddy clean");
+    const result = await runAction4(Action3.Clean, options);
+    if (result.isErr()) {
+      await outro3("While running the clean command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process3.exit(ExitCode2.FatalError);
+    }
+    await outro3("Cleaned up", { startTime: perf, useSeconds: true, message: "Cleaned up" });
+    process3.exit(ExitCode2.Success);
+  });
+  buddy.on("clean:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process3.exit(1);
+  });
+}
+
+// src/commands/cloud.ts
+import process4 from "process";
+import {intro as intro4, italic, log as log4, outro as outro4, prompts, runCommand, runCommandSync, underline} from "@stacksjs/cli";
+import {addJumpBox, deleteCdkRemnants, deleteIamUsers, deleteJumpBox, deleteLogGroups, deleteParameterStore, deleteStacksBuckets, deleteStacksFunctions, getJumpBoxInstanceId} from "@stacksjs/cloud";
+import {path as p} from "@stacksjs/path";
+import {ExitCode as ExitCode3} from "@stacksjs/types";
+import {loop} from "@stacksjs/utils";
+function cloud2(buddy) {
+  const descriptions = {
+    cloud: "Interact with the Stacks Cloud",
+    ssh: "SSH into the Stacks Cloud",
+    add: "Add a resource to the Stacks Cloud",
+    remove: "Removes the Stacks Cloud. In case it fails, try again",
+    optimizeCost: "Removes certain resources that may be re-applied at a later time",
+    cleanUp: "Removes all resources that were retained during the cloud deletion",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("cloud", descriptions.cloud).option("--ssh", descriptions.ssh, { default: false }).option("--connect", descriptions.ssh, { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log4.debug("Running `buddy cloud` ...", options);
+    if (options.ssh || options.connect) {
+      const startTime = performance.now();
+      const jumpBoxId = await getJumpBoxInstanceId();
+      const result = await runCommand(`aws ssm start-session --target ${jumpBoxId}`, {
+        ...options,
+        cwd: p.projectPath(),
+        stdin: "pipe"
+      });
+      if (result.isErr()) {
+        await outro4("While running the cloud command, there was an issue", { startTime, useSeconds: true }, result.error);
+        process4.exit(ExitCode3.FatalError);
+      }
+      await outro4("Exited", { startTime, useSeconds: true });
+      process4.exit(ExitCode3.Success);
+    }
+    log4.info("Not implemented yet. Please use the --ssh (or --connect) flag to connect to the Stacks Cloud.");
+    process4.exit(ExitCode3.Success);
+  });
+  buddy.command("cloud:add", descriptions.add).option("--jump-box", "Remove the jump-box", { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log4.debug("Running `buddy cloud:add` ...", options);
+    const startTime = await intro4("buddy cloud:add");
+    if (options.jumpBox) {
+      const { confirm } = await prompts({
+        name: "confirm",
+        type: "confirm",
+        message: "Would you like to add a jump-box to your cloud?"
+      });
+      if (!confirm) {
+        await outro4("Exited", { startTime, useSeconds: true });
+        process4.exit(ExitCode3.Success);
+      }
+      log4.info("The jump-box is getting added to your cloud resources...");
+      log4.info("This takes a few moments, please be patient.");
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      const result = await addJumpBox();
+      if (result.isErr()) {
+        await outro4("While running the cloud:add command, there was an issue", { startTime, useSeconds: true }, result.error);
+        process4.exit(ExitCode3.FatalError);
+      }
+      log4.info(italic("View the jump-box in the AWS console:"));
+      log4.info(underline("https://us-east-1.console.aws.amazon.com/ec2/home?region=us-east-1#Instances:instanceState=running"));
+      log4.info(italic("Once it finished initializing, you may SSH into it:"));
+      log4.info(underline("buddy cloud --ssh"));
+      await outro4("Your jump-box was added.", { startTime, useSeconds: true });
+      process4.exit(ExitCode3.Success);
+    }
+    log4.info("This functionality is not yet implemented.");
+    process4.exit(ExitCode3.Success);
+  });
+  buddy.command("cloud:remove", descriptions.remove).alias("cloud:destroy").alias("cloud:rm").alias("undeploy").option("--jump-box", "Remove the jump-box", { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log4.debug("Running `buddy cloud:remove` ...", options);
+    const startTime = await intro4("buddy cloud:remove");
+    if (options.jumpBox) {
+      const { confirm } = await prompts({
+        name: "confirm",
+        type: "confirm",
+        message: "Would you like to remove your jump-box for now?"
+      });
+      if (!confirm) {
+        await outro4("Exited", { startTime, useSeconds: true });
+        process4.exit(ExitCode3.Success);
+      }
+      const result2 = await deleteJumpBox();
+      if (result2.isErr()) {
+        await outro4("While removing your jump-box, there was an issue", { startTime, useSeconds: true }, result2.error);
+        process4.exit(ExitCode3.FatalError);
+      }
+      await outro4("Your jump-box was removed.", { startTime, useSeconds: true });
+      process4.exit(ExitCode3.Success);
+    }
+    console.log(`   ${italic("\u2139\uFE0F   Removing your cloud resources takes a while to complete.")}`);
+    console.log(`   ${italic("Please note, your backups will not yet be deleted. Though,")}`);
+    console.log(`   ${italic("Backups are scheduled to delete themselves in 30 days.")}`);
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    const result = await runCommand(`bunx cdk destroy`, {
+      ...options,
+      cwd: p.cloudPath(),
+      stdin: "inherit"
+    });
+    if (result.isErr()) {
+      await outro4('While running the cloud:remove ("undeploy") command, there was an issue', { startTime, useSeconds: true }, result.error);
+      process4.exit(ExitCode3.FatalError);
+    }
+    await runCommand("buddy cloud:cleanup", {
+      ...options,
+      cwd: p.projectPath(),
+      stdin: "inherit"
+    });
+    try {
+      log4.info("Finalizing the removal of your cloud resources.");
+      log4.info("This will take a few moments...");
+      loop(7, () => {
+        runCommandSync("buddy cloud:cleanup", {
+          ...options,
+          cwd: p.projectPath(),
+          stdout: "ignore"
+        });
+      });
+      await outro4("Your cloud has been removed", { startTime, useSeconds: true });
+      process4.exit(ExitCode3.Success);
+    } catch (error) {
+      await outro4("While cleaning up the cloud, there was an issue", { startTime, useSeconds: true }, error);
+      process4.exit(ExitCode3.FatalError);
+    }
+  });
+  buddy.command("cloud:optimize-cost", descriptions.optimizeCost).option("--jump-box", "Remove the jump-box", { default: true }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log4.debug("Running `buddy cloud:optimize-cost` ...", options);
+    const startTime = await intro4("buddy cloud:optimize-cost");
+    if (options.jumpBox) {
+      const { confirm } = await prompts({
+        name: "confirm",
+        type: "confirm",
+        message: "Would you like to remove your jump-box to optimize your costs?"
+      });
+      if (!confirm) {
+        await outro4("Exited", { startTime, useSeconds: true });
+        process4.exit(ExitCode3.Success);
+      }
+      await deleteJumpBox();
+      await outro4("Your jump-box was removed & cost optimizations are applied.", { startTime, useSeconds: true });
+      process4.exit(ExitCode3.Success);
+    }
+    await outro4("No cost optimization was applied", { startTime, useSeconds: true });
+    process4.exit(ExitCode3.Success);
+  });
+  buddy.command("cloud:cleanup", descriptions.cleanUp).alias("cloud:clean-up").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log4.debug("Running `buddy cloud:cleanup` ...", options);
+    const startTime = await intro4("buddy cloud:cleanup");
+    log4.info(`Cleaning up your cloud resources will take a while to complete. Please be patient.`);
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+    log4.info("Removing any jump-boxes...");
+    const result = await deleteJumpBox();
+    if (result.isErr()) {
+      if (result.error !== "Jump-box not found") {
+        await outro4("While removing your jump-box, there was an issue", { startTime, useSeconds: true }, result.error);
+        process4.exit(ExitCode3.FatalError);
+      }
+    }
+    log4.info("Removing any retained S3 buckets...");
+    const result2 = await deleteStacksBuckets();
+    if (result2.isErr()) {
+      await outro4("While deleting the retained S3 buckets, there was an issue", { startTime, useSeconds: true }, result2.error);
+      process4.exit(ExitCode3.FatalError);
+    }
+    log4.info("Removing any retained Lambda functions...");
+    const result3 = await deleteStacksFunctions();
+    if (result3.isErr()) {
+      if (result3.error !== "No stacks functions found")
+        await outro4("While deleting the Origin Request Lambda function, there was an issue", { startTime, useSeconds: true }, result3.error);
+      process4.exit(ExitCode3.FatalError);
+    }
+    log4.info(result3.value);
+    log4.info("Removing any remaining Stacks logs...");
+    const result4 = await deleteLogGroups();
+    if (result4.isErr()) {
+      await outro4("While deleting the Stacks log groups, there was an issue", { startTime, useSeconds: true }, result4.error);
+      process4.exit(ExitCode3.FatalError);
+    }
+    log4.info("Removing any stored parameters...");
+    const result7 = await deleteParameterStore();
+    if (result7.isErr()) {
+      await outro4("While deleting the Stacks log groups, there was an issue", { startTime, useSeconds: true }, result7.error);
+      process4.exit(ExitCode3.FatalError);
+    }
+    log4.info("Removing any CDK remnants...");
+    const result6 = await deleteCdkRemnants();
+    if (result6.isErr()) {
+      await outro4("While deleting the Stacks log groups, there was an issue", { startTime, useSeconds: true }, result6.error);
+      process4.exit(ExitCode3.FatalError);
+    }
+    log4.info("Removing any IAM users...");
+    const result8 = await deleteIamUsers();
+    if (result8.isErr()) {
+      await outro4("While deleting the Stacks log groups, there was an issue", { startTime, useSeconds: true }, result8.error);
+      process4.exit(ExitCode3.FatalError);
+    }
+    await outro4("AWS resources have been removed", { startTime, useSeconds: true });
+    process4.exit(ExitCode3.Success);
+  });
+  buddy.on("cloud:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process4.exit(1);
+  });
+}
+
+// src/commands/commit.ts
+import process5 from "process";
+import {runCommit} from "@stacksjs/actions";
+import {log as log5} from "@stacksjs/logging";
+function commit(buddy) {
+  const descriptions = {
+    commit: "Commit your stashed changes",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("commit", descriptions.commit).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log5.debug("Running `buddy commit` ...", options);
+    await runCommit(options);
+  });
+  buddy.on("commit:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process5.exit(1);
+  });
+}
+
+// src/commands/configure.ts
+import process6 from "process";
+import {log as log6, outro as outro5, runCommand as runCommand2} from "@stacksjs/cli";
+import {path as p2} from "@stacksjs/path";
+import {ExitCode as ExitCode4} from "@stacksjs/types";
+function configure(buddy) {
+  const descriptions = {
+    configure: "Configure options",
+    aws: "Configure the AWS connection",
+    project: "Target a specific project",
+    profile: "The AWS profile to use",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("configure", descriptions.configure).option("--aws", descriptions.aws, { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log6.debug("Running `buddy configure` ...", options);
+    if (options?.aws) {
+      await configureAws(options);
+      process6.exit(ExitCode4.Success);
+    }
+    log6.info("Not implemented yet. Please use the --aws flag to configure AWS.");
+    process6.exit(ExitCode4.Success);
+  });
+  buddy.command("configure:aws", descriptions.aws).option("-p, --project", descriptions.project, { default: false }).option("--profile", descriptions.profile, { default: process6.env.AWS_PROFILE }).option("--verbose", descriptions.verbose, { default: false }).option("--access-key-id", "The AWS access key").option("--secret-access-key", "The AWS secret access key").option("--region", "The AWS region").option("--output", "The AWS output format").option("--quiet", "Suppress output").action(async (options) => {
+    log6.debug("Running `buddy configure:aws` ...", options);
+    await configureAws(options);
+    process6.exit(ExitCode4.Success);
+  });
+  buddy.on("configure:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process6.exit(ExitCode4.FatalError);
+  });
+}
+async function configureAws(options) {
+  const startTime = performance.now();
+  const awsAccessKeyId = options?.accessKeyId ?? process6.env.AWS_ACCESS_KEY_ID;
+  const awsSecretAccessKey = options?.secretAccessKey ?? process6.env.AWS_SECRET_ACCESS_KEY;
+  const defaultRegion = "us-east-1";
+  const defaultOutputFormat = options?.output ?? "json";
+  const command = `aws configure --profile ${options?.profile ?? process6.env.AWS_PROFILE}`;
+  const input = `${awsAccessKeyId}\n${awsSecretAccessKey}\n${defaultRegion}\n${defaultOutputFormat}\n`;
+  const result = await runCommand2(command, {
+    ...options,
+    cwd: p2.projectPath(),
+    stdin: "pipe",
+    input
+  });
+  if (result.isErr()) {
+    await outro5("While running the cloud command, there was an issue", { startTime, useSeconds: true }, result.error);
+    process6.exit(ExitCode4.FatalError);
+  }
+  if (options?.quiet)
+    return;
+  await outro5("Exited", { startTime, useSeconds: true });
+}
+
+// src/commands/create.ts
+import process7 from "process";
+import {ExitCode as ExitCode5} from "@stacksjs/types";
+import {bold, cyan, dim, intro as intro5, log as log7, runCommand as runCommand3} from "@stacksjs/cli";
+import {useOnline} from "@stacksjs/utils";
+import {isFolder} from "@stacksjs/storage";
+import {resolve} from "@stacksjs/path";
+import {Action as Action4} from "@stacksjs/enums";
+import {runAction as runAction5} from "@stacksjs/actions";
+function create(buddy) {
+  const descriptions = {
+    command: "Create a new Stacks project",
+    ui: "Are you building a UI?",
+    components: "Are you building UI components?",
+    webComponents: "Automagically built optimized custom elements/web components?",
+    vue: "Automagically built a Vue component library?",
+    views: "How about views?",
+    functions: "Are you developing functions/composables?",
+    api: "Are you building an API?",
+    database: "Do you need a database?",
+    notifications: "Do you need notifications? e.g. email, SMS, push or chat notifications",
+    cache: "Do you need caching?",
+    email: "Do you need email?",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("new <name>", descriptions.command).alias("create <name>").option("-u, --ui", descriptions.ui, { default: true }).option("-c, --components", descriptions.components, { default: true }).option("-w, --web-components", descriptions.webComponents, { default: true }).option("-v, --vue", descriptions.vue, { default: true }).option("-p, --views", descriptions.views, { default: true }).option("-f, --functions", descriptions.functions, { default: true }).option("-a, --api", descriptions.api, { default: true }).option("-d, --database", descriptions.database, { default: true }).option("-ca, --cache", descriptions.cache, { default: false }).option("-e, --email", descriptions.email, { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log7.debug("Running `buddy new <name>` ...", options);
+    const startTime = await intro5("stacks new");
+    const name = options.name;
+    const path5 = resolve(process7.cwd(), name);
+    isFolderCheck(path5);
+    onlineCheck();
+    const result = await download(name, path5, options);
+    if (result.isErr()) {
+      log7.error(result.error);
+      process7.exit(ExitCode5.FatalError);
+    }
+    await ensureEnv(path5, options);
+    await install(path5, options);
+    if (startTime) {
+      const time = performance.now() - startTime;
+      log7.success(dim(`[${time.toFixed(2)}ms] Completed`));
+    }
+    log7.info(bold("Welcome to the Stacks Framework! \u269B\uFE0F"));
+    log7.info("To learn more, visit https://stacksjs.org");
+    process7.exit(ExitCode5.Success);
+  });
+  buddy.on("new:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process7.exit(1);
+  });
+}
+var isFolderCheck = function(path5) {
+  if (isFolder(path5)) {
+    log7.error(`Path ${path5} already exists`);
+    process7.exit(ExitCode5.FatalError);
+  }
+};
+var onlineCheck = function() {
+  const online = useOnline();
+  if (!online) {
+    log7.info("It appears you are disconnected from the internet.");
+    log7.info("The Stacks setup requires a brief internet connection for setup.");
+    log7.info("For instance, it installs your dependencies from.");
+    process7.exit(ExitCode5.FatalError);
+  }
+};
+async function download(name, path5, options) {
+  log7.info("Setting up your stack.");
+  const result = await runCommand3(`bunx giget stacks ${name}`, options);
+  log7.success(`Successfully scaffolded your project at ${cyan(path5)}`);
+  return result;
+}
+async function ensureEnv(path5, options) {
+  log7.info("Ensuring your environment is ready...");
+  await runCommand3("pkgx --update ", { ...options, cwd: path5 });
+  log7.success("Environment is ready");
+}
+async function install(path5, options) {
+  log7.info("Installing & setting up Stacks");
+  let result = await runCommand3("bun install", { ...options, cwd: path5 });
+  if (result?.isErr()) {
+    log7.error(result.error);
+    process7.exit();
+  }
+  result = await runCommand3("cp .env.example .env", { ...options, cwd: path5 });
+  if (result?.isErr()) {
+    log7.error(result.error);
+    process7.exit(ExitCode5.FatalError);
+  }
+  await runAction5(Action4.KeyGenerate, { ...options, cwd: path5 });
+  result = await runCommand3("git init", { ...options, cwd: path5 });
+  if (result.isErr()) {
+    log7.error(result.error);
+    process7.exit(ExitCode5.FatalError);
+  }
+  log7.success("Installed & set-up \uD83D\uDE80");
+}
+
+// src/commands/deploy.ts
+import process8 from "process";
+import {ExitCode as ExitCode6} from "@stacksjs/types";
+import {runAction as runAction6} from "@stacksjs/actions";
+import {intro as intro6, italic as italic2, log as log8, outro as outro6, runCommand as runCommand4} from "@stacksjs/cli";
+import {Action as Action5} from "@stacksjs/enums";
+import {app} from "@stacksjs/config";
+import {addDomain, hasUserDomainBeenAddedToCloud} from "@stacksjs/dns";
+function deploy(buddy) {
+  const descriptions = {
+    deploy: "Re-installs your npm dependencies",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("deploy", descriptions.deploy).option("--domain", "Specify a domain to deploy to", { default: undefined }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log8.debug("Running `buddy deploy` ...", options);
+    const startTime = await intro6("buddy deploy");
+    const domain = options.domain || app.url;
+    if (!domain) {
+      log8.info("No domain found in your .env or ./config/app.ts");
+      log8.info("Please ensure your domain is properly configured.");
+      log8.info("For more info, check out the docs or join our Discord.");
+      process8.exit(ExitCode6.FatalError);
+    }
+    await checkIfAwsIsConfigured();
+    options.domain = await configureDomain(domain, options, startTime);
+    const result = await runAction6(Action5.Deploy, options);
+    if (result.isErr()) {
+      await outro6("While running the `buddy deploy`, there was an issue", { startTime, useSeconds: true }, result.error);
+      process8.exit(ExitCode6.FatalError);
+    }
+    await outro6("Project deployed.", { startTime, useSeconds: true });
+  });
+  buddy.on("deploy:*", () => {
+    log8.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process8.exit(1);
+  });
+}
+async function configureDomain(domain, options, startTime) {
+  if (!domain) {
+    log8.info("We could not identify a domain to deploy to.");
+    log8.info("Please set your .env or ./config/app.ts properly.");
+    console.log("");
+    log8.info("Alternatively, specify a domain to deploy via the `--domain` flag.");
+    console.log("");
+    log8.info("   \u27A1\uFE0F  Example: `buddy deploy --domain example.com`");
+    console.log("");
+    process8.exit(ExitCode6.FatalError);
+  }
+  if (domain.includes("localhost")) {
+    log8.info("You are deploying to a local environment.");
+    log8.info("Please set your .env or ./config/app.ts properly. The domain we are deploying cannot be a `localhost` domain.");
+    console.log("");
+    log8.info("Alternatively, specify a domain to deploy via the `--domain` flag.");
+    console.log("");
+    log8.info("   \u27A1\uFE0F  Example: `buddy deploy --domain example.com`");
+    console.log("");
+    process8.exit(ExitCode6.FatalError);
+  }
+  if (await hasUserDomainBeenAddedToCloud(domain)) {
+    log8.info("Domain is properly configured");
+    log8.info("Your cloud is deploying...");
+    log8.info(`${italic2("This may take a while...")}`);
+    return domain;
+  }
+  console.log("");
+  log8.info(`  \uD83D\uDC4B  It appears to be your first ${italic2(domain)} deployment.`);
+  console.log("");
+  log8.info(italic2("Let\u2019s ensure it is all connected properly."));
+  log8.info(italic2("One moment..."));
+  console.log("");
+  const result = await addDomain({
+    ...options,
+    deploy: true,
+    startTime
+  });
+  if (result.isErr()) {
+    await outro6("While running the `buddy deploy`, there was an issue", { startTime, useSeconds: true }, result.error);
+    process8.exit(ExitCode6.FatalError);
+  }
+  await outro6("Added your domain.", { startTime, useSeconds: true });
+  process8.exit(ExitCode6.Success);
+}
+async function checkIfAwsIsConfigured() {
+  log8.info("Ensuring AWS is configured...");
+  const result = await runCommand4("buddy configure:aws", {
+    silent: true
+  });
+  if (result.isErr()) {
+    log8.error("AWS is not configured properly.");
+    log8.error("Please run `buddy configure:aws` to set up your AWS credentials.");
+    process8.exit(ExitCode6.FatalError);
+  }
+  log8.success("AWS is configured");
+}
+
+// src/commands/dev.ts
+import process9 from "process";
+import {Action as Action6} from "@stacksjs/enums";
+import {
+runAction as runAction7,
+runApiDevServer,
+runComponentsDevServer,
+runDashboardDevServer,
+runDesktopDevServer,
+runDocsDevServer,
+runFrontendDevServer,
+runSystemTrayDevServer
+} from "@stacksjs/actions";
+import {ExitCode as ExitCode7} from "@stacksjs/types";
+import {intro as intro7, log as log9, outro as outro7, runCommand as runCommand5} from "@stacksjs/cli";
+import {libsPath} from "@stacksjs/path";
+function dev(buddy) {
+  const descriptions = {
+    dev: "Starts development server",
+    frontend: "Starts the frontend development server",
+    components: "Start the Components development server",
+    desktop: "Start the Desktop App development server",
+    dashboard: "Start the Dashboard development server",
+    api: "Start the local API development server",
+    email: "Start the Email development server",
+    docs: "Start the Documentation development server",
+    systemTray: "Start the System Tray development server",
+    interactive: "Get asked which development server to start",
+    select: "Which development server are you trying to start?",
+    withLocalhost: "Include the localhost URL in the output",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("dev [server]", descriptions.dev).option("-f, --frontend", descriptions.frontend).option("-a, --api", descriptions.api).option("-e, --email", descriptions.email).option("-c, --components", descriptions.components).option("-d, --dashboard", descriptions.dashboard).option("-t, --desktop", descriptions.desktop).option("-d, --docs", descriptions.docs).option("-t, --system-tray", descriptions.systemTray).option("-i, --interactive", descriptions.interactive, { default: false }).option("-l, --with-localhost", descriptions.withLocalhost, { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (server, options) => {
+    log9.debug("Running `buddy dev [server]` ...", options);
+    const perf = await intro7("buddy dev");
+    switch (server) {
+      case "frontend":
+        await runFrontendDevServer(options);
+        break;
+      case "api":
+        await runApiDevServer(options);
+        break;
+      case "components":
+        await runComponentsDevServer(options);
+        break;
+      case "dashboard":
+        await runDashboardDevServer(options);
+        break;
+      case "desktop":
+        await runDesktopDevServer(options);
+        break;
+      case "system-tray":
+        await runSystemTrayDevServer(options);
+        break;
+      case "docs":
+        await runDocsDevServer(options);
+        break;
+      default:
+    }
+    if (wantsInteractive(options)) {
+      const answer = await log9.prompt.require().select(descriptions.select, {
+        options: [
+          { value: "all", label: "All" },
+          { value: "frontend", label: "Frontend" },
+          { value: "api", label: "Backend" },
+          { value: "dashboard", label: "Dashboard" },
+          { value: "desktop", label: "Desktop" },
+          { value: "email", label: "Email" },
+          { value: "components", label: "Components" },
+          { value: "docs", label: "Documentation" }
+        ]
+      });
+      if (answer === "components") {
+        await runComponentsDevServer(options);
+      } else if (answer === "api") {
+        await runApiDevServer(options);
+      } else if (answer === "dashboard") {
+        await runDashboardDevServer(options);
+      } else if (answer === "docs") {
+        await runDocsDevServer(options);
+      } else {
+        log9.error("Invalid option during interactive mode");
+        process9.exit(ExitCode7.InvalidArgument);
+      }
+    } else {
+      if (options.components)
+        await runComponentsDevServer(options);
+      if (options.docs)
+        await runDocsDevServer(options);
+      else if (options.api)
+        await runApiDevServer(options);
+    }
+    await startDevelopmentServer(options);
+    outro7("Exited", { startTime: perf, useSeconds: true });
+    process9.exit(ExitCode7.Success);
+  });
+  buddy.command("dev:components", descriptions.components).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log9.debug("Running `buddy dev:components` ...", options);
+    const perf = await intro7("buddy dev:components");
+    const result = await runCommand5("bun run dev", {
+      cwd: libsPath("components/vue")
+    });
+    if (options.verbose)
+      log9.info("buddy dev:components result", result);
+    if (result.isErr()) {
+      await outro7("While running the dev:components command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process9.exit();
+    }
+    console.log("");
+    await outro7("Exited", { startTime: perf, useSeconds: true });
+    process9.exit(ExitCode7.Success);
+  });
+  buddy.command("dev:docs", descriptions.docs).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log9.debug("Running `buddy dev:docs` ...", options);
+    const perf = await intro7("buddy dev:docs");
+    const result = await runAction7(Action6.DevDocs, options);
+    if (result.isErr()) {
+      await outro7("While running the dev:docs command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process9.exit();
+    }
+    console.log("");
+    await outro7("Exited", { startTime: perf, useSeconds: true });
+    process9.exit(ExitCode7.Success);
+  });
+  buddy.command("dev:desktop", descriptions.desktop).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log9.debug("Running `buddy dev:desktop` ...", options);
+    const perf = await intro7("buddy dev:desktop");
+    const result = await runAction7(Action6.DevDesktop, options);
+    if (result.isErr()) {
+      await outro7("While running the dev:desktop command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process9.exit();
+    }
+    console.log("");
+    await outro7("Exited", { startTime: perf, useSeconds: true });
+    process9.exit(ExitCode7.Success);
+  });
+  buddy.command("dev:api", descriptions.api).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log9.debug("Running `buddy dev:api` ...", options);
+    await runApiDevServer(options);
+  });
+  buddy.command("dev:frontend", descriptions.frontend).alias("dev:pages").alias("dev:views").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log9.debug("Running `buddy dev:frontend` ...", options);
+    await runFrontendDevServer(options);
+  });
+  buddy.command("dev:dashboard", descriptions.dashboard).alias("dev:admin").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log9.debug("Running `buddy dev:dashboard` ...", options);
+    await runDashboardDevServer(options);
+  });
+  buddy.command("dev:system-tray", descriptions.systemTray).alias("dev:tray").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log9.debug("Running `buddy dev:system-tray` ...", options);
+    await runSystemTrayDevServer(options);
+  });
+  buddy.on("dev:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process9.exit(1);
+  });
+}
+async function startDevelopmentServer(options) {
+  const result = await runAction7(Action6.Dev, options);
+  if (result.isErr()) {
+    log9.error("While running the dev command, there was an issue", result.error);
+    process9.exit(ExitCode7.InvalidArgument);
+  }
+}
+var wantsInteractive = function(options) {
+  return options.interactive;
+};
+
+// src/commands/domains.ts
+import process10 from "process";
+import {runAction as runAction8} from "@stacksjs/actions";
+import {bgCyan, bold as bold2, intro as intro8, italic as italic3, log as log10, outro as outro8, prompts as prompts2} from "@stacksjs/cli";
+import {config as config3} from "@stacksjs/config";
+import {addDomain as addDomain2} from "@stacksjs/dns";
+import {ExitCode as ExitCode8} from "@stacksjs/types";
+import {Action as Action7} from "@stacksjs/enums";
+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"
+  };
+  const c = config3.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: true }).option("--auto-renew", "Enable auto-renew", { default: true }).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 || true }).option("--privacy-tech", "Enable privacy protection for tech", { default: c?.privacyTech || c?.privacy || true }).option("--privacy-registrant", "Enable privacy protection for registrant", { default: c?.privacyRegistrant || c?.privacy || true }).option("--contact-type <type>", "Contact type", { default: "person" }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (domain, options) => {
+    log10.debug("Running `buddy domains:purchase <domain>` ...", options);
+    options.domain = domain;
+    const startTime = await intro8("buddy domains:purchase");
+    const result = await runAction8(Action7.DomainsPurchase, options);
+    if (result.isErr()) {
+      await outro8("While running the domains:purchase command, there was an issue", { startTime, useSeconds: true }, result.error);
+      process10.exit(ExitCode8.FatalError);
+    }
+    const { confirm } = await prompts2({
+      name: "confirm",
+      type: "confirm",
+      message: `Would you like to set ${domain} as your APP_URL?`
+    });
+    if (!confirm) {
+      await outro8(`Alrighty! ${italic3(domain)} was added to your account.`, { startTime, useSeconds: true, type: "success" });
+      log10.info(`Please note, you may need to validate your email address. Check your ${italic3(options.registrantEmail)} inbox.`);
+      process10.exit(ExitCode8.Success);
+    }
+    const { writeEnv } = await import("../../env/src/index.js");
+    writeEnv("APP_URL", domain);
+    let message = `Great! ${italic3(domain)} was added to your account.`;
+    message += `\n\nAnd your APP_URL has been set to ${italic3(domain)}.
+      \nPlease note, this change has not been deployed yet.
+      \nThe next time you run ${bgCyan(italic3(bold2(" buddy deploy ")))}, your app will deploy to ${italic3(domain)}.
+      \n${italic3("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 outro8(message, { startTime, useSeconds: true, type: "info" });
+    process10.exit(ExitCode8.Success);
+  });
+  buddy.command("domains:add <domain>", descriptions.add).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log10.debug("Running `buddy domains:add <domain>` ...", options);
+    const startTime = await intro8("buddy domains:add");
+    const result = await addDomain2({
+      ...options,
+      startTime
+    });
+    if (result.isErr()) {
+      await outro8("While running the `buddy deploy`, there was an issue", { startTime, useSeconds: true }, result.error);
+      process10.exit(ExitCode8.FatalError);
+    }
+    await outro8("Added your domain.", { startTime, useSeconds: true });
+    process10.exit(ExitCode8.Success);
+  });
+  buddy.command("domains:remove <domain>", descriptions.remove).option("--yes", descriptions.skip, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log10.debug("Running `buddy domains:remove <domain>` ...", options);
+    const domain = options.domain || config3.app.url;
+    const opts = { ...options, domain };
+    const startTime = await intro8("buddy domains:remove");
+    if (!opts.yes) {
+      const { confirm } = await prompts2({
+        name: "confirm",
+        type: "confirm",
+        message: `Are you sure you want to remove ${domain}?`
+      });
+      if (!confirm) {
+        await outro8("Cancelled the domains:remove command", { startTime, useSeconds: true, type: "info" });
+        process10.exit(ExitCode8.Success);
+      }
+    }
+    const result = await runAction8(Action7.DomainsRemove, opts);
+    if (result.isErr()) {
+      await outro8("While running the domains:remove command, there was an issue", { startTime, useSeconds: true }, result.error);
+      process10.exit(ExitCode8.FatalError);
+    }
+    await outro8("Removed your domain DNS records.", { startTime, useSeconds: true });
+    process10.exit(ExitCode8.Success);
+  });
+  buddy.on("domains:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process10.exit(1);
+  });
+}
+
+// src/commands/dns.ts
+import process11 from "process";
+import {ExitCode as ExitCode9} from "@stacksjs/types";
+import {config as config5} from "@stacksjs/config";
+import {log as log11, runCommand as runCommand6} from "@stacksjs/cli";
+function dns3(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",
+    pretty: "Display the output as JSON in a pretty format",
+    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: "ANY" }).option("-n, --nameserver <nameserver>", descriptions.nameserver).option("--class <class>", descriptions.nameserver).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: false }).option("-J, --json", descriptions.json, { default: false }).option("-p, --pretty", descriptions.pretty, { default: true }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (domain, options) => {
+    log11.debug("Running `buddy dns [domain]` ...", options);
+    delete options.pretty;
+    delete options.p;
+    const optionsString = Object.entries(options).filter(([key, value]) => key !== "--" && key.length > 1 && value !== false).map(([key, value]) => `--${key} ${value}`).join(" ");
+    await runCommand6(`dog ${domain || config5.app.url} ${optionsString}`);
+    process11.exit(ExitCode9.Success);
+  });
+  buddy.on("dns:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process11.exit(1);
+  });
+}
+
+// src/commands/fresh.ts
+import process12 from "process";
+import {ExitCode as ExitCode10} from "@stacksjs/types";
+import {runAction as runAction9} from "@stacksjs/actions";
+import {intro as intro9, log as log12, outro as outro9} from "@stacksjs/cli";
+import {Action as Action8} from "@stacksjs/enums";
+function fresh(buddy) {
+  const descriptions = {
+    fresh: "Re-installs your npm dependencies",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("fresh", descriptions.fresh).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log12.debug("Running `buddy fresh` ...", options);
+    const perf = await intro9("buddy fresh");
+    const result = await runAction9(Action8.Fresh, { ...options, stdout: "inherit" });
+    if (result.isErr()) {
+      await outro9("While running `buddy fresh`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process12.exit(ExitCode10.FatalError);
+    }
+    await outro9("Freshly reinstalled your dependencies", { startTime: perf, useSeconds: true });
+    process12.exit(ExitCode10.Success);
+  });
+  buddy.on("fresh:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process12.exit(1);
+  });
+}
+
+// src/commands/generate.ts
+import process13 from "process";
+import {
+generateComponentMeta,
+generateCoreSymlink,
+generateIdeHelpers,
+generateLibEntries,
+generateMigrations,
+generatePkgxConfig,
+generateTypes,
+generateVsCodeCustomData,
+generateWebTypes,
+invoke as startGenerationProcess
+} from "@stacksjs/actions";
+import {log as log13} from "@stacksjs/cli";
+import {ExitCode as ExitCode11} from "@stacksjs/types";
+function generate(buddy) {
+  const descriptions = {
+    command: "Automagically build any of your libraries/packages for production use. Select any of the following packages",
+    types: "Generate your TypeScript types",
+    entries: "Generate your function & Component Library Entry Points",
+    webTypes: "Generate web-types.json for IDEs",
+    customData: "Generate VS Code custom data (custom-elements.json) for IDEs",
+    ideHelpers: "Generate IDE helpers",
+    componentMeta: "Generate component meta information",
+    coreSymlink: "Generate symlink of the core framework to the project root",
+    pkgx: "Generate the pkgx configuration file",
+    select: "What are you trying to generate?",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("generate", descriptions.command).option("-t, --types", descriptions.types).option("-e, --entries", descriptions.entries).option("-w, --web-types", descriptions.webTypes).option("-c, --custom-data", descriptions.customData).option("-i, --ide-helpers", descriptions.ideHelpers).option("-c, --component-meta", descriptions.componentMeta).option("-p, --pkgx", descriptions.pkgx).option("-p, --project", descriptions.project, { default: false }).option("--core-symlink", descriptions.coreSymlink).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log13.debug("Running `buddy generate` ...", options);
+    await startGenerationProcess(options);
+    process13.exit(ExitCode11.Success);
+  });
+  buddy.command("generate:types", descriptions.types).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).alias("types:generate").action(async (options) => {
+    log13.debug("Running `buddy generate:types` ...", options);
+    await generateTypes(options);
+  });
+  buddy.command("generate:entries", descriptions.entries).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log13.debug("Running `buddy generate:entries` ...", options);
+    await generateLibEntries(options);
+  });
+  buddy.command("generate:web-types", descriptions.webTypes).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log13.debug("Running `buddy generate:web-types` ...", options);
+    await generateWebTypes(options);
+  });
+  buddy.command("generate:vscode-custom-data", descriptions.customData).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log13.debug("Running `buddy generate:vscode-custom-data` ...", options);
+    await generateVsCodeCustomData(options);
+  });
+  buddy.command("generate:ide-helpers", descriptions.ideHelpers).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log13.debug("Running `buddy generate:ide-helpers` ...", options);
+    await generateIdeHelpers(options);
+  });
+  buddy.command("generate:component-meta", descriptions.componentMeta).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log13.debug("Running `buddy generate:component-meta` ...", options);
+    await generateComponentMeta(options);
+  });
+  buddy.command("generate:pkgx-config", descriptions.pkgx).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action((options) => {
+    log13.debug("Running `buddy generate:pkgx-config` ...", options);
+    generatePkgxConfig();
+  });
+  buddy.command("generate:migrations", "Generate Migrations").action((options) => {
+    log13.debug("Running `buddy generate:migrations` ...", options);
+    generateMigrations();
+  });
+  buddy.command("generate:core-symlink", "Generate core symlink. A shortcut for core developers.").action(async (options) => {
+    log13.debug("Running `buddy core-symlink` ...", options);
+    await generateCoreSymlink();
+  });
+  buddy.on("generate:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process13.exit(1);
+  });
+}
+
+// src/commands/http.ts
+import process14 from "process";
+import {ExitCode as ExitCode12} from "@stacksjs/types";
+import {config as config7} from "@stacksjs/config";
+import {log as log14, runCommandSync as runCommandSync2} from "@stacksjs/cli";
+function http(buddy) {
+  const descriptions = {
+    http: "Send an HTTP request to a domain",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("http [domain]", descriptions.http).option("-p, --project", descriptions.project, { default: false }).action(async (domain, options) => {
+    log14.debug("Running `buddy http [domain]` ...", options);
+    const optionsString = Object.entries(options).filter(([key, value]) => key !== "--" && key.length > 1 && value !== false).map(([key, value]) => `--${key} ${value}`).join(" ");
+    const command = `http GET ${domain || config7.app.url} ${optionsString}`;
+    log14.info(`Running command: ${command}`);
+    await runCommandSync2(command);
+    process14.exit(ExitCode12.Success);
+  });
+}
+
+// src/commands/lint.ts
+import process15 from "process";
+import {intro as intro10, log as log15, outro as outro10} from "@stacksjs/cli";
+import {Action as Action9} from "@stacksjs/enums";
+import {runAction as runAction10} from "@stacksjs/actions";
+function lint(buddy) {
+  const descriptions = {
+    lint: "Automagically lints your project codebase",
+    lintFix: "Automagically fixes all lint errors",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("lint", descriptions.lint).option("-f, --fix", descriptions.lintFix, { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log15.debug("Running `buddy lint` ...", options);
+    const startTime = await intro10("buddy lint");
+    const result = await runAction10(Action9.Lint, options);
+    if (result.isErr()) {
+      await outro10("While running `buddy lint`, there was an issue", { startTime, useSeconds: true }, result.error);
+      process15.exit();
+    }
+    await outro10("Linted your project", { startTime, useSeconds: true });
+  });
+  buddy.command("lint:fix", descriptions.lintFix).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log15.debug("Running `buddy lint:fix` ...", options);
+    log15.info("Fixing lint errors...");
+    const result = await runAction10(Action9.LintFix, { ...options });
+    if (result.isErr()) {
+      log15.error("There was an error lint fixing your code.", result.error);
+      process15.exit();
+    }
+    log15.success("Fixed lint errors");
+  });
+  buddy.on("lint:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process15.exit(1);
+  });
+}
+
+// src/commands/list.ts
+import process16 from "process";
+var {$ } = globalThis.Bun;
+import {projectPath} from "@stacksjs/path";
+import {log as log16} from "@stacksjs/logging";
+function list(buddy) {
+  const descriptions = {
+    list: "List all of the project-specific Buddy commands",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("list", descriptions.list).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log16.debug("Running `buddy list` ...", options);
+    $.cwd(projectPath());
+    const test = await $`buddy --help`.text();
+    const commandsSection = test.match(/Commands:.*?(?=For more info, run any command with the)/s)?.[0];
+    if (commandsSection) {
+      const cleanedCommands = commandsSection.replace("Commands:", "").replace(/^\s+/gm, "");
+      console.log(cleanedCommands);
+      return;
+    }
+    console.error("#1 - Please reach out to our Discord for helper: https://discord.gg/stacksjs");
+  });
+  buddy.on("list:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process16.exit(1);
+  });
+}
+
+// src/commands/install.ts
+import process17 from "process";
+import {log as log17, runCommand as runCommand7} from "@stacksjs/cli";
+import {path as p3} from "@stacksjs/path";
+function install2(buddy) {
+  const descriptions = {
+    install: "Install your dependencies",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("install", descriptions.install).option("-p, --project", descriptions.project, { default: false }).option("-v, --verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log17.debug("Running `buddy install` ...", options);
+    await runCommand7("bun install", {
+      ...options,
+      cwd: p3.projectPath()
+    });
+  });
+  buddy.on("install:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process17.exit(1);
+  });
+}
+
+// src/commands/key.ts
+import process18 from "process";
+import {intro as intro11, log as log18, outro as outro11} from "@stacksjs/cli";
+import {runAction as runAction11} from "@stacksjs/actions";
+import {Action as Action10} from "@stacksjs/enums";
+function key(buddy) {
+  const descriptions = {
+    command: "Generate & set the application key.",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("key:generate", descriptions.command).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log18.debug("Running `buddy key:generate` ...", options);
+    await intro11("buddy key:generate");
+    const result = await runAction11(Action10.KeyGenerate, options);
+    if (result.isErr()) {
+      log18.error("Failed to set random application key.", result.error);
+      process18.exit();
+    }
+    await outro11("Random application key set.");
+  });
+  buddy.on("key:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process18.exit(1);
+  });
+}
+
+// src/commands/make.ts
+import process19 from "process";
+import {
+createModel,
+createNotification,
+invoke,
+makeComponent,
+makeDatabase,
+makeFunction,
+makeLanguage,
+makePage,
+makeStack
+} from "@stacksjs/actions";
+import {intro as intro12, italic as italic4, outro as outro12, runCommand as runCommand8} from "@stacksjs/cli";
+import {localUrl} from "@stacksjs/config";
+import {path as p4} from "@stacksjs/path";
+import {log as log19} from "@stacksjs/logging";
+import {ExitCode as ExitCode13} from "@stacksjs/types";
+function make(buddy) {
+  const descriptions = {
+    model: "Create a new model",
+    component: "Create a new component",
+    page: "Create a new page",
+    function: "Create a new function",
+    language: "Create a new language",
+    database: "Create a new database",
+    migration: "Create a new migration",
+    factory: "Create a new factory",
+    notification: "Create a new notification",
+    stack: "Create a new stack",
+    certificate: "Create a new SSL Certificate",
+    select: "What are you trying to make?",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("make", "The make command").option("-c, --component", descriptions.component, { default: false }).option("-p, --page", descriptions.page, { default: false }).option("-f, --function", descriptions.function, { default: false }).option("-l, --language", descriptions.language, { default: false }).option("-d, --database", descriptions.database, { default: false }).option("-m, --migration", descriptions.migration, { default: false }).option("-f, --factory", descriptions.factory, { default: false }).option("-n, --notification", descriptions.notification, { default: false }).option("-s, --stack", descriptions.stack, { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log19.debug("Running `buddy make` ...", options);
+    const name = buddy.args[0];
+    if (!name) {
+      log19.error("You need to specify a name. Read more about the documentation here.");
+      process19.exit();
+    }
+    await invoke(options);
+    process19.exit(ExitCode13.Success);
+  });
+  buddy.command("make:component", descriptions.component).option("-n, --name", "The name of the component").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log19.debug("Running `buddy make:component` ...", options);
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log19.error("You need to specify a name. Read more about the documentation here.");
+      process19.exit();
+    }
+    await makeComponent(options);
+  });
+  buddy.command("make:database", descriptions.database).option("-n, --name", "The name of the database").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action((options) => {
+    log19.debug("Running `buddy make:database` ...", options);
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log19.error("You need to specify a name. Read more about the documentation here.");
+      process19.exit();
+    }
+    makeDatabase(options);
+  });
+  buddy.command("make:factory", descriptions.factory).option("-n, --name", "The name of the factory").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action((options) => {
+    log19.debug("Running `buddy make:factory` ...", options);
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log19.error("You need to specify a name. Read more about the documentation here.");
+      process19.exit();
+    }
+  });
+  buddy.command("make:view", descriptions.page).alias("make:page").option("-n, --name", "The name of the page").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log19.debug("Running `buddy make:view` ...", options);
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log19.error("You need to specify a name. Read more about the documentation here.");
+      process19.exit();
+    }
+    await makePage(options);
+  });
+  buddy.command("make:function", descriptions.function).option("-n, --name", "The name of the function").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log19.debug("Running `buddy make:function` ...", options);
+    await makeFunction(options);
+  });
+  buddy.command("make:lang", descriptions.language).option("-n, --name", "The name of the language").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log19.debug("Running `buddy make:lang` ...", options);
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log19.error("You need to specify a name. Read more about the documentation here.");
+      process19.exit();
+    }
+    await makeLanguage(options);
+  });
+  buddy.command("make:notification", descriptions.notification).option("-n, --name", "The name of the notification").option("-e, --email", "Is it an email notification?", { default: true }).option("-c, --chat", "Is it a chat notification?", { default: false }).option("-s, --sms", "Is it a SMS notification?", { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log19.debug("Running `buddy make:notification` ...", options);
+    const perf = await intro12("buddy make:notification");
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log19.error("You need to specify a name. Read more about the documentation here.");
+      process19.exit();
+    }
+    const result = await createNotification(options);
+    if (!result) {
+      await outro12("While running the make:notification command, there was an issue", { startTime: perf, useSeconds: true });
+      process19.exit();
+    }
+    await outro12(`Created your ${italic4(name)} notification.`, { startTime: perf, useSeconds: true });
+    process19.exit(ExitCode13.Success);
+  });
+  buddy.command("make:stack", descriptions.stack).option("-n, --name", "The name of the stack").option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action((options) => {
+    log19.debug("Running `buddy make:stack` ...", options);
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log19.error("You need to specify a name. Read more about the documentation here.");
+      process19.exit();
+    }
+    makeStack(options);
+  });
+  buddy.command("make:model", descriptions.model).option("-n, --name", "The name of the model").action(async (options) => {
+    log19.debug("Running `buddy make:model` ...", options);
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log19.error("You need to specify a model name");
+      process19.exit();
+    }
+    await createModel(options);
+  });
+  buddy.command("make:migration", descriptions.migration).option("-n, --name", "The name of the migration").option("-e, --env", "The environment to run the migration in", { default: "dev" }).action((options) => {
+    log19.debug("Running `buddy make:migration` ...", options);
+    const name = buddy.args[0] || options.name;
+    options.name = name;
+    if (!name) {
+      log19.error("You need to specify a migration name");
+      process19.exit();
+    }
+    log19.info(path, name);
+  });
+  buddy.command("make:certificate", descriptions.certificate).alias("make:cert").example("buddy make:certificate").action(async (options) => {
+    log19.debug("Running `buddy make:certificate` ...", options);
+    const domain = await localUrl();
+    log19.info(`Creating SSL certificate...`);
+    await runCommand8(`mkcert ${domain}`, {
+      cwd: p4.projectStoragePath("keys")
+    });
+    log19.success("Certificate created");
+    log19.info(`Installing SSL certificate...`);
+    await runCommand8(`mkcert -install`, {
+      cwd: p4.projectStoragePath("keys")
+    });
+    log19.success("Certificate installed");
+  });
+  buddy.on("make:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process19.exit(1);
+  });
+}
+
+// src/commands/migrate.ts
+import process20 from "process";
+import {ExitCode as ExitCode14} from "@stacksjs/types";
+import {runAction as runAction12} from "@stacksjs/actions";
+import {intro as intro13, log as log20, outro as outro13} from "@stacksjs/cli";
+import {Action as Action11} from "@stacksjs/enums";
+function migrate(buddy) {
+  const descriptions = {
+    migrate: "Migrates your database",
+    dns: "Writes the DNS records for a domain to ./config/dns.ts",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("migrate", descriptions.migrate).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log20.debug("Running `buddy migrate` ...", options);
+    const perf = await intro13("buddy migrate");
+    const result = await runAction12(Action11.Migrate, { ...options });
+    if (result.isErr()) {
+      await outro13("While running the migrate command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process20.exit();
+    }
+    const APP_ENV = process20.env.APP_ENV || "local";
+    await outro13(`Migrated your ${APP_ENV} database.`, { startTime: perf, useSeconds: true });
+    process20.exit(ExitCode14.Success);
+  });
+  buddy.command("migrate:dns", descriptions.migrate).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log20.debug("Running `buddy migrate:dns` ...", options);
+    const perf = await intro13("buddy migrate:dns");
+    const result = await runAction12(Action11.MigrateDns, { ...options });
+    if (result.isErr()) {
+      await outro13("While running the migrate:dns command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process20.exit();
+    }
+    const APP_URL = process20.env.APP_URL || "undefined";
+    await outro13(`Migrated your ${APP_URL} DNS.`, { startTime: perf, useSeconds: true });
+    process20.exit(ExitCode14.Success);
+  });
+  buddy.on("migrate:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process20.exit(1);
+  });
+}
+
+// src/commands/ports.ts
+import process21 from "process";
+import {ExitCode as ExitCode15} from "@stacksjs/types";
+import {ports as projectPorts} from "@stacksjs/config";
+import {log as log21} from "@stacksjs/logging";
+import {findProjectPath, path as p5, projectPath as projectPath2} from "@stacksjs/path";
+var {$: $2 } = globalThis.Bun;
+import {intro as intro14, italic as italic5, outro as outro14} from "@stacksjs/cli";
+import {findStacksProjects} from "@stacksjs/utils";
+function ports(buddy) {
+  const descriptions = {
+    command: "Let buddy check your project for potential issues and misconfigurations",
+    ports: "Check if the ports are available",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("ports", descriptions.command).option("-l, --list", "List the used ports", { default: true }).option("-c, --check", "Check if the ports are available", { default: false }).option("-p, --project [name]", descriptions.project, { default: undefined }).option("-q, --quiet", "Use minimal output", { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log21.debug("Running `buddy ports` ...", options);
+    let perf;
+    if (!options.quiet)
+      perf = await intro14("buddy ports");
+    if (options.project) {
+      const path10 = await findProjectPath(options.project);
+      log21.debug(`Path: ${path10}`);
+      const ports2 = await getPortsForProjectPath(path10, options);
+      log21.debug(`./buddy ports --quiet response for ${projectPath2}`, ports2);
+      outputPorts(ports2, options);
+    } else {
+      outputPorts(projectPorts, options);
+    }
+    if (!options.quiet)
+      await outro14("Exited", { startTime: perf, useSeconds: false });
+    process21.exit(ExitCode15.Success);
+  });
+  buddy.command("ports:list", descriptions.ports).option("-p, --project [name]", descriptions.project, { default: undefined }).option("-q, --quiet", "Use minimal output", { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log21.debug("Running `buddy ports:list` ...", options);
+    let perf;
+    if (!options.quiet)
+      perf = await intro14("buddy ports:list");
+    if (options.project) {
+      if (!options.quiet)
+        log21.info(`Listing ports for project: ${italic5(options.project)}`);
+      const path10 = await findProjectPath(options.project);
+      log21.debug(`Path: ${path10}`);
+      const ports2 = await getPortsForProjectPath(path10, options);
+      outputPorts(ports2, options);
+    } else {
+      outputPorts(projectPorts, options);
+    }
+    if (!options.quiet)
+      await outro14("Exited", { startTime: perf, useSeconds: false });
+    process21.exit(ExitCode15.Success);
+  });
+  buddy.command("ports:check", descriptions.ports).option("-p, --project [name]", descriptions.project, { default: projectPath2() }).option("-q, --quiet", "Use minimal output", { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log21.debug("Running `buddy ports:check` ...", options);
+    let perf;
+    if (!options.quiet)
+      perf = await intro14("buddy ports:check");
+    const projects = await findStacksProjects(undefined, { quiet: true });
+    log21.debug("Running `buddy ports`");
+    log21.debug(`Found ${projects.length} projects`);
+    log21.debug("Projects:", projects);
+    const projectsPorts = {};
+    for (const project of projects)
+      projectsPorts[project] = await getPortsForProjectPath(project, options);
+    log21.info("ProjectsPorts:", projectsPorts);
+    if (!options.quiet)
+      await outro14("Exited", { startTime: perf, useSeconds: false });
+    process21.exit(ExitCode15.Success);
+  });
+  buddy.on("ports:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process21.exit(1);
+  });
+}
+async function getPortsForProjectPath(path10, options) {
+  if (!options.quiet)
+    log21.info(`Checking ports for project: ${italic5(path10)}`);
+  $2.cwd(path10);
+  $2.env(await import(`${path10}/.env`));
+  const projectList = await $2`./buddy projects:list --quiet`.text();
+  log21.debug("ProjectListResponse", projectList);
+  const projects = projectList.split("\n").filter((line) => line.startsWith("   - ")).map((line) => line.trim().substring(4));
+  log21.debug("Projects:", projects);
+  const ppath = options.project ?? p5.projectPath();
+  let projectPath3 = projects.find((project) => project.includes(ppath));
+  log21.debug(`Checking ports for project: ${projectPath3}`);
+  if (projectPath3 === "" || !projectPath3)
+    projectPath3 = p5.projectPath();
+  log21.debug(`\$ Running: ./buddy ports:list --quiet via ${projectPath3}`);
+  const response = await $2`./buddy ports:list --quiet`.json();
+  log21.debug(`Response for ./buddy ports:list --quiet via ${projectPath3}`, response);
+  let validJsonString = response.replace(/(\w+)(?=\s*:)/g, '"$1"');
+  validJsonString = validJsonString.replace(/,(\s*})/g, "$1");
+  const ports2 = JSON.parse(validJsonString);
+  log21.debug(`Ports for ${projectPath3}`, ports2);
+  return ports2;
+}
+var outputPorts = function(ports2, options) {
+  if (!options.quiet)
+    console.log("");
+  console.log(ports2);
+  if (!options.quiet)
+    console.log("");
+};
+
+// src/commands/prepublish.ts
+import process22 from "process";
+import {Action as Action12} from "@stacksjs/enums";
+import {runAction as runAction13} from "@stacksjs/actions";
+import {log as log22} from "@stacksjs/logging";
+function prepublish(buddy) {
+  const descriptions = {
+    command: "Run your prepublish script",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("prepublish", descriptions.command).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log22.debug("Running `buddy prepublish` ...", options);
+    await runAction13(Action12.Prepublish, options);
+  });
+  buddy.on("prepublish:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process22.exit(1);
+  });
+}
+
+// src/commands/projects.ts
+import process23 from "process";
+import {ExitCode as ExitCode16} from "@stacksjs/types";
+import {intro as intro15, log as log23} from "@stacksjs/cli";
+import {findStacksProjects as findStacksProjects2} from "@stacksjs/utils";
+function projects(buddy) {
+  const descriptions = {
+    projects: "Find all Stacks projects on your system",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("projects", descriptions.projects).option("-q, --quiet", "Use minimal output", { default: false }).option("-l, --list", "List all local Stacks projects", { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log23.debug("Running `buddy projects` ...", options);
+    if (!options.quiet)
+      await intro15("buddy projects");
+    const projects2 = await findStacksProjects2(undefined, options);
+    for (const project of projects2)
+      console.log("   - ", project);
+    process23.exit(ExitCode16.Success);
+  });
+  buddy.command("projects:list", descriptions.projects).option("-q, --quiet", "Use minimal output", { default: false }).option("-l, --list", "List all local Stacks projects", { default: true }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log23.debug("Running `buddy projects` ...", options);
+    if (!options.quiet)
+      await intro15("buddy projects:list");
+    const projects2 = await findStacksProjects2(undefined, options);
+    for (const project of projects2)
+      console.log("   - ", project);
+    process23.exit(ExitCode16.Success);
+  });
+  buddy.on("projects:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process23.exit(1);
+  });
+}
+
+// src/commands/release.ts
+import process24 from "process";
+import {Action as Action13} from "@stacksjs/enums";
+import {ExitCode as ExitCode17} from "@stacksjs/types";
+import {intro as intro16, log as log24, outro as outro15} from "@stacksjs/cli";
+import {runAction as runAction14} from "@stacksjs/actions";
+function release(buddy) {
+  buddy.command("release", descriptions.release).option("--dry-run", descriptions.dryRun, { default: false }).option("-p, --project", descriptions.project, { default: false }).option("--verbose", descriptions.verbose, { default: false }).action(async (options) => {
+    log24.debug("Running `buddy release` ...", options);
+    if (options.dryRun)
+      log24.warn("Dry run enabled. No changes will be made or committed.");
+    const startTime = await intro16("buddy release");
+    const result = await runAction14(Action13.Release, {
+      stdin: "inherit",
+      ...options
+    });
+    if (result.isErr()) {
+      log24.error("Failed to release", result.error);
+      process24.exit(ExitCode17.FatalError);
+    }
+    await outro15("Triggered CI/CD Release Workflow", { startTime, useSeconds: true });
+  });
+  buddy.on("release:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process24.exit(1);
+  });
+}
+var descriptions = {
+  release: "Release a new version of your libraries/packages",
+  project: "Target a specific project",
+  dryRun: "Run the release without actually releasing",
+  verbose: "Enable verbose output"
+};
+
+// src/commands/seed.ts
+import process25 from "process";
+import {ExitCode as ExitCode18} from "@stacksjs/types";
+import {runAction as runAction15} from "@stacksjs/actions";
+import {intro as intro17, log as log25, outro as outro16} from "@stacksjs/cli";
+import {Action as Action14} from "@stacksjs/enums";
+function seed(buddy) {
+  const descriptions2 = {
+    seed: "Seed your database",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("seed", descriptions2.seed).option("-p, --project", descriptions2.project, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    log25.debug("Running `buddy seed` ...", options);
+    const perf = await intro17("buddy seed");
+    const result = await runAction15(Action14.Seed, options);
+    if (result.isErr()) {
+      await outro16("While running the seed command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process25.exit(ExitCode18.FatalError);
+    }
+    const APP_ENV = process25.env.APP_ENV || "local";
+    await outro16(`Seeded your ${APP_ENV} database.`, { startTime: perf, useSeconds: true });
+    process25.exit(ExitCode18.Success);
+  });
+  buddy.on("seed:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process25.exit(1);
+  });
+}
+
+// src/commands/setup.ts
+import process26 from "process";
+import {path as p6} from "@stacksjs/path";
+import {Action as Action15} from "@stacksjs/enums";
+import {handleError} from "@stacksjs/error-handling";
+import {storage as storage3} from "@stacksjs/storage";
+import {log as log26, runCommand as runCommand9} from "@stacksjs/cli";
+import {ExitCode as ExitCode19} from "@stacksjs/types";
+function setup(buddy) {
+  const descriptions2 = {
+    setup: "This command ensures your project is setup correctly",
+    ohMyZsh: "Enable Oh My Zsh",
+    aws: "Ensures AWS is connected to the project",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("setup", descriptions2.setup).alias("ensure").option("-p, --project", descriptions2.project, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    log26.debug("Running `buddy setup` ...", options);
+    if (!await isPkgxInstalled())
+      await installPkgx();
+    await optimizePkgxDeps();
+    await initializeProject(options);
+  });
+  buddy.command("setup:oh-my-zsh", descriptions2.ohMyZsh).alias("upgrade:oh-my-zsh").option("--verbose", descriptions2.verbose, { default: false }).action(async (_options) => {
+    log26.debug("Running `buddy setup:oh-my-zsh` ...", _options);
+    const result = await runAction(Action15.UpgradeShell);
+    if (result.isErr()) {
+      log26.error(result.error);
+      process26.exit(ExitCode19.FatalError);
+    }
+  });
+  buddy.on("setup:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process26.exit(ExitCode19.FatalError);
+  });
+}
+async function isPkgxInstalled() {
+  const result = await runCommand9("pkgx --version", { silent: true });
+  if (result.isOk())
+    return true;
+  return false;
+}
+async function installPkgx() {
+  const result = await runCommand9(p6.frameworkPath("scripts/pkgx-install"));
+  if (result.isOk())
+    return;
+  handleError(result.error);
+  process26.exit(ExitCode19.FatalError);
+}
+async function initializeProject(options) {
+  log26.info("Installing dependencies...");
+  const result = await runCommand9("bun install", {
+    cwd: options.cwd || p6.projectPath()
+  });
+  if (result.isErr()) {
+    handleError(result.error);
+    process26.exit(ExitCode19.FatalError);
+  }
+  log26.success("Installed node_modules");
+  ensureEnvIsSet(options);
+  const keyResult = await runCommand9("buddy key:generate", {
+    cwd: options.cwd || p6.projectPath()
+  });
+  if (keyResult.isErr()) {
+    handleError(keyResult.error);
+    process26.exit(ExitCode19.FatalError);
+  }
+  log26.info("Ensuring AWS is connected...");
+  const awsResult = await runCommand9("buddy configure:aws", {
+    cwd: options.cwd || p6.projectPath()
+  });
+  if (awsResult.isErr()) {
+    handleError(awsResult.error);
+    process26.exit(ExitCode19.FatalError);
+  }
+  log26.success("Configured AWS");
+  log26.success("Project is setup");
+  log26.info("Happy coding! \uD83D\uDC99");
+}
+async function optimizePkgxDeps() {
+  return new Promise((resolve2) => setTimeout(resolve2, 300));
+}
+async function ensureEnvIsSet(options) {
+  log26.info("Ensuring .env exists...");
+  if (storage3.doesNotExist(p6.projectPath(".env"))) {
+    const envResult = await runCommand9("cp .env.example .env", {
+      cwd: options.cwd || p6.projectPath()
+    });
+    if (envResult.isErr()) {
+      handleError(envResult.error);
+      process26.exit(ExitCode19.FatalError);
+    }
+    log26.success(".env created");
+  } else {
+    log26.success(".env existed");
+  }
+}
+
+// src/commands/test.ts
+import process27 from "process";
+import {runAction as runAction16} from "@stacksjs/actions";
+import {intro as intro18, outro as outro17} from "@stacksjs/cli";
+import {projectPath as projectPath3} from "@stacksjs/path";
+import {Action as Action16} from "@stacksjs/enums";
+function test(buddy) {
+  const descriptions2 = {
+    command: "Runs your test suite",
+    types: "Typechecks your codebase",
+    coverage: "Generates a test coverage report",
+    ui: "Runs your test suite in the browser",
+    unit: "Runs your unit tests",
+    feature: "Runs your feature tests",
+    showReport: "Show the test report",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("test", descriptions2.command).option("--ui", descriptions2.ui, { default: false }).option("-p, --project", descriptions2.project, { default: false }).option("--verbose", descriptions2.verbose, { default: true }).action(async (options) => {
+    const perf = await intro18("buddy test");
+    const result = await runAction16(Action16.Test, { ...options, cwd: projectPath3() });
+    if (result.isErr()) {
+      await outro17("While running `buddy test`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process27.exit();
+    }
+    await outro17("Finished running tests", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:unit", descriptions2.unit).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    const perf = await intro18("buddy test:unit");
+    const result = await runAction16(Action16.TestUnit, { ...options, verbose: true, cwd: projectPath3() });
+    if (result.isErr()) {
+      await outro17("While running `buddy test:unit`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process27.exit();
+    }
+    await outro17("Finished running unit tests", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:feature", descriptions2.feature).option("--show-report", descriptions2.showReport, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    const perf = await intro18("buddy test:feature");
+    let result;
+    if (options.showReport)
+      result = await runAction16(Action16.ShowFeatureTestReport, { ...options, verbose: true, cwd: projectPath3() });
+    else
+      result = await runAction16(Action16.TestFeature, { ...options, verbose: true, cwd: projectPath3() });
+    if (result.isErr()) {
+      await outro17("While running `buddy test:feature`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process27.exit();
+    }
+    await outro17("Finished running feature tests", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:ui", descriptions2.command).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    const perf = await intro18("buddy test:ui");
+    const result = await runAction16(Action16.TestUi, { ...options, verbose: true, cwd: projectPath3() });
+    if (result.isErr()) {
+      await outro17("While running `buddy test:ui`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process27.exit();
+    }
+    await outro17("Finished running tests in the browser", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:types", descriptions2.types).alias("typecheck").option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    const perf = await intro18("buddy test:types");
+    const result = await runAction16(Action16.Typecheck, { ...options, verbose: true, cwd: projectPath3() });
+    if (result.isErr()) {
+      await outro17("While running `buddy test:types`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process27.exit();
+    }
+    await outro17("Finished running typecheck", { startTime: perf, useSeconds: true });
+  });
+  buddy.command("test:coverage", descriptions2.coverage).action(async (options) => {
+    const perf = await intro18("buddy test:coverage");
+    const result = await runAction16(Action16.TestCoverage, { ...options, cwd: projectPath3(), verbose: true });
+    if (result.isErr()) {
+      await outro17("While running `buddy test:coverage`, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process27.exit();
+    }
+    await outro17("Generated the test coverage report", { startTime: perf, useSeconds: true });
+    process27.exit();
+  });
+  buddy.on("test:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process27.exit(1);
+  });
+}
+
+// src/commands/tinker.ts
+import process28 from "process";
+import {ExitCode as ExitCode20} from "@stacksjs/types";
+import {runAction as runAction17} from "@stacksjs/actions";
+import {intro as intro19, log as log27, outro as outro18} from "@stacksjs/cli";
+import {Action as Action17} from "@stacksjs/enums";
+function tinker(buddy) {
+  const descriptions2 = {
+    tinker: "Tinker with your code",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("tinker", descriptions2.tinker).option("-p, --project", descriptions2.project, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    log27.debug("Running `buddy tinker` ...", options);
+    const perf = await intro19("buddy tinker");
+    const result = await runAction17(Action17.Tinker, options);
+    if (result.isErr()) {
+      await outro18("While running the tinker command, there was an issue", { startTime: perf, useSeconds: true }, result.error || undefined);
+      process28.exit();
+    }
+    await outro18("Tinker mode exited.", { startTime: perf, useSeconds: true });
+    process28.exit(ExitCode20.Success);
+  });
+  buddy.on("tinker:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process28.exit(1);
+  });
+}
+
+// src/commands/types.ts
+import process29 from "process";
+import {generateTypes as generateTypes2} from "@stacksjs/actions";
+import {log as log28} from "@stacksjs/logging";
+function types21(buddy) {
+  const descriptions2 = {
+    generate: "Generate the types of & for your library/libraries",
+    fix: "wip",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("types:generate", descriptions2.generate).option("-p, --project", descriptions2.project, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    log28.debug("Running `buddy types:generate` ...", options);
+    await generateTypes2();
+  });
+  buddy.command("types:fix", descriptions2.fix).option("-p, --project", descriptions2.project, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).action(async () => {
+  });
+  buddy.on("types:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process29.exit(1);
+  });
+}
+
+// src/commands/upgrade.ts
+import process30 from "process";
+import {runAction as runAction18} from "@stacksjs/actions";
+import {intro as intro20, log as log29, outro as outro19} from "@stacksjs/cli";
+import {ExitCode as ExitCode21} from "@stacksjs/types";
+import {Action as Action18} from "@stacksjs/enums";
+function upgrade(buddy) {
+  const descriptions2 = {
+    command: "Upgrade dependencies, framework, package manager, JS/TS runtime",
+    framework: "Upgrade the Stacks framework",
+    dependencies: "Upgrade your dependencies (pkgx.yaml & package.json)",
+    bun: "Upgrade Bun to the latest version",
+    shell: "Upgrade the to the latest shell integration (currently only supports Oh My Zsh)",
+    binary: "Upgrade the `stacks` binary to the latest version. Please note, the binary is moved to the `~/.stacks/bin` directory",
+    all: "Upgrade Node, package manager, project dependencies, and framework",
+    force: "Overwrite possible local updates with remote framework updates",
+    select: "What are you trying to upgrade?",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("upgrade", descriptions2.command).option("-d, --dependencies", descriptions2.dependencies, { default: false }).option("-b, --bun", descriptions2.bun, { default: false }).option("-a, --all", descriptions2.all, { default: false }).option("-f, --force", descriptions2.force, { default: false }).option("--framework", descriptions2.framework, { default: false }).option("-p, --project", descriptions2.project, { default: false }).option("-s, --shell", descriptions2.shell, { default: false }).option("-b, --binary", descriptions2.binary, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).alias("update").example("buddy upgrade -a --verbose").action(async (options) => {
+    log29.debug("Running `buddy upgrade` ...", options);
+    const perf = await intro20("buddy upgrade");
+    if (hasNoOptions2(options)) {
+      let answers = await log29.prompt.require().multiselect(descriptions2.select, {
+        options: [
+          { value: "dependencies", label: "Dependencies" },
+          { value: "framework", label: "Framework" },
+          { value: "bun", label: "Bun" },
+          { value: "shell", label: "Shell" },
+          { value: "binary", label: "Binary" }
+        ]
+      });
+      if (answers !== null)
+        process30.exit(ExitCode21.InvalidArgument);
+      if (isString(answers))
+        answers = [answers];
+      options = answers.reduce((a, v) => ({ ...a, [v]: true }), {});
+    }
+    const result = await runAction18(Action18.Upgrade, options);
+    if (result.isErr()) {
+      await outro19("While running the buddy:upgrade command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process30.exit();
+    }
+    await outro19("Upgrade complete.", { startTime: perf, useSeconds: true });
+    process30.exit();
+  });
+  buddy.command("upgrade:framework", descriptions2.framework).option("-p, --project", descriptions2.project, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).example("buddy upgrade:framework --verbose").action(async (options) => {
+    log29.debug("Running `buddy upgrade:framework` ...", options);
+    await runAction18(Action18.Upgrade, options);
+  });
+  buddy.command("upgrade:dependencies", descriptions2.dependencies).option("-p, --project", descriptions2.project, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).alias("upgrade:deps").example("buddy upgrade:dependencies --verbose").action(async (options) => {
+    log29.debug("Running `buddy upgrade:dependencies` ...", options);
+    await runAction18(Action18.Upgrade, options);
+  });
+  buddy.command("upgrade:bun", descriptions2.bun).option("-p, --project", descriptions2.project, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    log29.debug("Running `buddy upgrade:bun` ...", options);
+    const perf = await intro20("buddy upgrade:bun");
+    const result = await runAction18(Action18.UpgradeBun, options);
+    if (result.isErr()) {
+      await outro19("While running the buddy upgrade:bun command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process30.exit();
+    }
+    process30.exit(ExitCode21.Success);
+  });
+  buddy.command("upgrade:all", descriptions2.all).option("-p, --project", descriptions2.project, { default: false }).option("--verbose", descriptions2.verbose, { default: false }).action(async (options) => {
+    log29.debug("Running `buddy upgrade:all` ...", options);
+    await runAction18(Action18.Upgrade, options);
+  });
+  buddy.command("upgrade:shell", descriptions2.shell).option("--verbose", descriptions2.verbose, { default: false }).example("buddy upgrade:shell").action(async (options) => {
+    log29.debug("Running `buddy upgrade:shell` ...", options);
+    const perf = await intro20("buddy upgrade:shell");
+    const result = await runAction18(Action18.UpgradeShell, options);
+    if (result.isErr()) {
+      await outro19("While running the buddy upgrade:shell command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process30.exit();
+    }
+    process30.exit(ExitCode21.Success);
+  });
+  buddy.command("upgrade:binary", descriptions2.binary).option("--verbose", descriptions2.verbose, { default: false }).example("buddy upgrade:binary").action(async (options) => {
+    if (process30.getuid && process30.getuid() !== 0) {
+      log29.warn("To upgrade the binary, you need to run this command with sudo, or as root.");
+      process30.exit(0);
+    }
+    log29.debug("Running `buddy upgrade:binary` ...", options);
+    const perf = await intro20("buddy upgrade:binary");
+    const result = await runAction18(Action18.UpgradeBinary, options);
+    if (result.isErr()) {
+      await outro19("While running the buddy upgrade:binary command, there was an issue", { startTime: perf, useSeconds: true }, result.error);
+      process30.exit();
+    }
+    process30.exit(ExitCode21.Success);
+  });
+  buddy.on("upgrade:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process30.exit(1);
+  });
+}
+var hasNoOptions2 = function(options) {
+  return !options.framework && !options.dependencies && !options.bun && !options.shell && !options.binary && !options.all;
+};
+
+// src/commands/version.ts
+import process31 from "process";
+import {bold as bold3, dim as dim2, green, intro as intro21, log as log30} from "@stacksjs/cli";
+import {storage as storage5} from "@stacksjs/storage";
+function version(buddy) {
+  const descriptions2 = {
+    version: "Retrieving Stacks build version"
+  };
+  buddy.command("version", descriptions2.version).action(async () => {
+    log30.debug("Running `buddy version` ...");
+    await intro21("buddy version");
+    const pkg = await storage5.readPackageJson("./package.json");
+    const bunVersion = "wip";
+    const stacksVersion = pkg.version;
+    log30.info(green(bold3("@stacksjs/ ")) + dim2(` ${stacksVersion}`));
+    log30.info(green(bold3("Bun: ")) + dim2(`   ${bunVersion}`));
+  });
+  buddy.on("version:*", () => {
+    console.error("Invalid command: %s\nSee --help for a list of available commands.", buddy.args.join(" "));
+    process31.exit(1);
+  });
+}
+export { build, changelog, clean, cloud2 as cloud, commit, configure, create, deploy, dev, startDevelopmentServer, domains, dns3 as dns, fresh, generate, http, lint, list, install2 as install, key, make, migrate, ports, prepublish, projects, release, seed, setup, optimizePkgxDeps, ensureEnvIsSet, test, tinker, types21 as types, upgrade, version };