@stacksjs/buddy 0.70.59 → 0.70.60

package/dist/commands/ports.js

@@ -0,0 +1,118 @@
+import { $ } from "bun";
+import process from "node:process";
+import { intro, italic, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { ports as projectPorts } from "@stacksjs/config";
+import { log } from "@stacksjs/logging";
+import { findProjectPath, path as p, projectPath } from "@stacksjs/path";
+import { ExitCode } from "@stacksjs/types";
+import { findStacksProjects } from "@stacksjs/utils";
+export 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: !0 }).option("-c, --check", "Check if the ports are available", {
+    default: !1
+  }).option("-p, --project [name]", descriptions.project, {
+    default: void 0
+  }).option("-q, --quiet", "Use minimal output", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy ports` ...", options);
+    let perf;
+    if (!options.quiet)
+      perf = await intro("buddy ports");
+    if (options.project) {
+      const path = await findProjectPath(options.project);
+      log.debug(`Path: ${path}`);
+      const ports = await getPortsForProjectPath(path, options);
+      log.debug(`./buddy ports --quiet response for ${projectPath}`, ports);
+      outputPorts(ports, options);
+    } else
+      outputPorts(projectPorts, options);
+    if (!options.quiet)
+      await outro("Exited", { startTime: perf, useSeconds: !1 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("ports:list", descriptions.ports).option("-p, --project [name]", descriptions.project, {
+    default: void 0
+  }).option("-q, --quiet", "Use minimal output", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy ports:list` ...", options);
+    let perf;
+    if (!options.quiet)
+      perf = await intro("buddy ports:list");
+    if (options.project) {
+      if (!options.quiet)
+        log.info(`Listing ports for project: ${italic(options.project)}`);
+      const path = await findProjectPath(options.project);
+      log.debug(`Path: ${path}`);
+      const ports = await getPortsForProjectPath(path, options);
+      outputPorts(ports, options);
+    } else
+      outputPorts(projectPorts, options);
+    if (!options.quiet)
+      await outro("Exited", { startTime: perf, useSeconds: !1 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("ports:check", descriptions.ports).option("-p, --project [name]", descriptions.project, {
+    default: projectPath()
+  }).option("-q, --quiet", "Use minimal output", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy ports:check` ...", options);
+    let perf;
+    if (!options.quiet)
+      perf = await intro("buddy ports:check");
+    const projects = await findStacksProjects(void 0, { quiet: !0 });
+    log.debug("Running `buddy ports`");
+    log.debug(`Found ${projects.length} projects`);
+    log.debug("Projects:", projects);
+    const projectsPorts = {};
+    for (const project of projects)
+      projectsPorts[project] = await getPortsForProjectPath(project, options);
+    log.info("ProjectsPorts:", projectsPorts);
+    if (!options.quiet)
+      await outro("Exited", { startTime: perf, useSeconds: !1 });
+    process.exit(ExitCode.Success);
+  });
+  onUnknownSubcommand(buddy, "ports");
+}
+async function getPortsForProjectPath(path, options) {
+  if (!options.quiet)
+    log.info(`Checking ports for project: ${italic(path)}`);
+  $.cwd(path);
+  try {
+    $.env(await import(`${path}/.env`));
+  } catch (err) {
+    if (!options.quiet)
+      log.warn(`[ports] Failed to load ${path}/.env (${err.message}). Falling back to current environment.`);
+  }
+  const projectList = await $`./buddy projects:list --quiet`.text();
+  log.debug("ProjectListResponse", projectList);
+  const projects = projectList.split(`
+`).filter((line) => line.startsWith("   - ")).map((line) => line.trim().substring(4));
+  log.debug("Projects:", projects);
+  const ppath = options.project ?? p.projectPath();
+  let projectPath = projects.find((project) => project.includes(ppath));
+  log.debug(`Checking ports for project: ${projectPath}`);
+  if (projectPath === "" || !projectPath)
+    projectPath = p.projectPath();
+  log.debug(`$ Running: ./buddy ports:list --quiet via ${projectPath}`);
+  const response = await $`./buddy ports:list --quiet`.json();
+  log.debug(`Response for ./buddy ports:list --quiet via ${projectPath}`, response);
+  let validJsonString = response.replace(/(\w+)(?=\s*:)/g, '"$1"');
+  validJsonString = validJsonString.replace(/,(\s*\})/g, "$1");
+  let ports;
+  try {
+    ports = JSON.parse(validJsonString);
+  } catch {
+    throw Error(`Failed to parse ports configuration: ${validJsonString.slice(0, 200)}`);
+  }
+  log.debug(`Ports for ${projectPath}`, ports);
+  return ports;
+}
+function outputPorts(ports, options) {
+  if (!options.quiet)
+    console.log("");
+  console.log(ports);
+  if (!options.quiet)
+    console.log("");
+}

package/dist/commands/prepublish.js

@@ -0,0 +1,17 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { Action } from "@stacksjs/enums";
+import { log } from "@stacksjs/logging";
+import { onUnknownSubcommand } from "@stacksjs/cli";
+export 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 [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy prepublish` ...", options);
+    await runAction(Action.Prepublish, options);
+  });
+  onUnknownSubcommand(buddy, "prepublish");
+}

package/dist/commands/projects.js

@@ -0,0 +1,29 @@
+import process from "node:process";
+import { intro, log, onUnknownSubcommand } from "@stacksjs/cli";
+import { ExitCode } from "@stacksjs/types";
+import { findStacksProjects } from "@stacksjs/utils";
+export 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: !1 }).option("-l, --list", "List all local Stacks projects", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy projects` ...", options);
+    if (!options.quiet)
+      await intro("buddy projects");
+    const projects = await findStacksProjects(void 0, options);
+    for (const project of projects)
+      console.log("   - ", project);
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("projects:list", descriptions.projects).option("-q, --quiet", "Use minimal output", { default: !1 }).option("-l, --list", "List all local Stacks projects", { default: !0 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy projects` ...", options);
+    if (!options.quiet)
+      await intro("buddy projects:list");
+    const projects = await findStacksProjects(void 0, options);
+    for (const project of projects)
+      console.log("   - ", project);
+    process.exit(ExitCode.Success);
+  });
+  onUnknownSubcommand(buddy, "projects");
+}

package/dist/commands/publish.js

@@ -0,0 +1,169 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { cp, readdir, stat } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import process from "node:process";
+import { italic, log, onUnknownSubcommand } from "@stacksjs/cli";
+import { path } from "@stacksjs/path";
+import { fs, globSync } from "@stacksjs/storage";
+import { ExitCode } from "@stacksjs/types";
+export function publish(buddy) {
+  const descriptions = {
+    command: "Publish a Stacks default into your userland (app/) directory so you can customize it",
+    model: "Publish a default model from storage/framework/defaults/app/Models/ to app/Models/",
+    controller: "Publish a default controller from storage/framework/defaults/app/Controllers/ to app/Controllers/",
+    middleware: "Publish a default middleware from storage/framework/defaults/app/Middleware/ to app/Middleware/",
+    action: "Publish a default action from storage/framework/defaults/app/Actions/ to app/Actions/",
+    core: "Publish a framework package source from node_modules/@stacksjs/<pkg>/ into storage/framework/core/<pkg>/ for editing",
+    name: "The name of the resource to publish (e.g. Cart, User)",
+    pkg: "The name of the framework package (e.g. router, orm, faker \u2014 without @stacksjs/ prefix)",
+    force: "Overwrite an existing userland file",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("publish:model <name>", descriptions.model).option("--force", descriptions.force, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (name, options) => {
+    await publishResource({
+      kind: "model",
+      name,
+      defaultsDir: path.frameworkPath("defaults/app/Models"),
+      userDir: path.userModelsPath(),
+      force: !!options.force
+    });
+  });
+  buddy.command("publish:controller <name>", descriptions.controller).option("--force", descriptions.force, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (name, options) => {
+    await publishResource({
+      kind: "controller",
+      name,
+      defaultsDir: path.frameworkPath("defaults/app/Controllers"),
+      userDir: path.userControllersPath(),
+      force: !!options.force
+    });
+  });
+  buddy.command("publish:middleware <name>", descriptions.middleware).option("--force", descriptions.force, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (name, options) => {
+    await publishResource({
+      kind: "middleware",
+      name,
+      defaultsDir: path.frameworkPath("defaults/app/Middleware"),
+      userDir: path.userMiddlewarePath(),
+      force: !!options.force
+    });
+  });
+  buddy.command("publish:action <name>", descriptions.action).option("--force", descriptions.force, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (name, options) => {
+    await publishResource({
+      kind: "action",
+      name,
+      defaultsDir: path.frameworkPath("defaults/app/Actions"),
+      userDir: path.userActionsPath(),
+      force: !!options.force
+    });
+  });
+  buddy.command("publish:core <pkg>", descriptions.core).option("--force", descriptions.force, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (pkg, options) => {
+    await publishCorePackage(pkg, !!options.force);
+  });
+  buddy.command("publish [resource] [name]", descriptions.command).option("--force", descriptions.force, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (resource, name, options) => {
+    if (!resource || !name) {
+      log.error("Usage: buddy publish:<resource> <Name>  (e.g. buddy publish:model Cart)");
+      process.exit(ExitCode.FatalError);
+    }
+    const handler = {
+      model: () => publishResource({
+        kind: "model",
+        name,
+        defaultsDir: path.frameworkPath("defaults/app/Models"),
+        userDir: path.userModelsPath(),
+        force: !!options.force
+      }),
+      controller: () => publishResource({
+        kind: "controller",
+        name,
+        defaultsDir: path.frameworkPath("defaults/app/Controllers"),
+        userDir: path.userControllersPath(),
+        force: !!options.force
+      }),
+      middleware: () => publishResource({
+        kind: "middleware",
+        name,
+        defaultsDir: path.frameworkPath("defaults/app/Middleware"),
+        userDir: path.userMiddlewarePath(),
+        force: !!options.force
+      }),
+      action: () => publishResource({
+        kind: "action",
+        name,
+        defaultsDir: path.frameworkPath("defaults/app/Actions"),
+        userDir: path.userActionsPath(),
+        force: !!options.force
+      }),
+      core: () => publishCorePackage(name, !!options.force)
+    }[resource.toLowerCase()];
+    if (!handler) {
+      log.error(`Unknown publishable resource: ${italic(resource)}`);
+      log.info("Available: model, controller, middleware, action, core");
+      process.exit(ExitCode.FatalError);
+    }
+    await handler();
+  });
+  onUnknownSubcommand(buddy, "publish");
+}
+async function publishCorePackage(pkg, force) {
+  const shortName = pkg.replace(/^@stacksjs\//, "").replace(/^core\//, ""), fail = (msg, hint) => {
+    process.stderr.write(`${msg}
+`);
+    if (hint)
+      process.stderr.write(`  ${hint}
+`);
+    process.exit(ExitCode.FatalError);
+  };
+  if (!shortName || shortName.includes("/") || shortName.includes(".."))
+    fail(`Invalid package name: ${pkg}`, "Use a short name like `router` or the fully qualified `@stacksjs/router`.");
+  const sourceDir = resolve(process.cwd(), "node_modules", "@stacksjs", shortName), targetDir = path.frameworkPath(`core/${shortName}`);
+  try {
+    if (!(await stat(sourceDir)).isDirectory())
+      fail(`${sourceDir} is not a directory.`);
+  } catch {
+    fail(`Could not find @stacksjs/${shortName} in node_modules.`, "Run `bun install` first, or check the package name.");
+  }
+  if (existsSync(targetDir) && !force)
+    fail(`Already published: ${targetDir.replace(`${process.cwd()}/`, "")}`, "Pass --force to overwrite.");
+  mkdirSync(dirname(targetDir), { recursive: !0 });
+  const SKIP = new Set(["node_modules", "dist", ".bun", ".cache", "tsconfig.tsbuildinfo"]);
+  let copied = 0;
+  await copyTreeFiltered(sourceDir, targetDir, SKIP, () => copied++);
+  log.success(`Published @stacksjs/${shortName} \u2192 ${italic(targetDir.replace(`${process.cwd()}/`, ""))} (${copied} files)`);
+  log.info("Edit freely \u2014 local changes win over the installed package.");
+}
+async function copyTreeFiltered(sourceDir, targetDir, skip, onFile) {
+  mkdirSync(targetDir, { recursive: !0 });
+  const entries = await readdir(sourceDir, { withFileTypes: !0 });
+  for (const entry of entries) {
+    if (skip.has(entry.name))
+      continue;
+    const src = `${sourceDir}/${entry.name}`, dst = `${targetDir}/${entry.name}`;
+    if (entry.isDirectory()) {
+      await copyTreeFiltered(src, dst, skip, onFile);
+      continue;
+    }
+    await cp(src, dst, { force: !0, dereference: !0 });
+    onFile();
+  }
+}
+async function publishResource(ctx) {
+  const { kind, name, defaultsDir, userDir, force } = ctx, fileName = name.endsWith(".ts") ? name : `${name}.ts`, matches = globSync([`${defaultsDir}/**/${fileName}`], { absolute: !0 });
+  if (!matches.length) {
+    log.error(`Could not find default ${kind}: ${italic(fileName)}`);
+    log.info(`Looked under: ${italic(defaultsDir)}`);
+    process.exit(ExitCode.FatalError);
+  }
+  if (matches.length > 1) {
+    log.warn(`Multiple defaults match ${italic(fileName)}; using the first:`);
+    for (const m of matches)
+      log.info(`  ${m}`);
+  }
+  const sourcePath = matches[0], targetPath = `${userDir.replace(/\/$/, "")}/${fileName}`;
+  if (existsSync(targetPath) && !force) {
+    log.error(`Already exists: ${italic(targetPath)}`);
+    log.info("Pass --force to overwrite.");
+    process.exit(ExitCode.FatalError);
+  }
+  mkdirSync(dirname(targetPath), { recursive: !0 });
+  await fs.promises.copyFile(sourcePath, targetPath);
+  log.success(`Published ${kind} ${italic(name)} \u2192 ${italic(targetPath.replace(`${process.cwd()}/`, ""))}`);
+}

package/dist/commands/queue.js

@@ -0,0 +1,249 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function queue(buddy) {
+  const descriptions = {
+    project: "Target a specific project",
+    queue: "Specify queue name",
+    verbose: "Enable verbose output",
+    id: "Job or batch ID",
+    all: "Apply to all items",
+    force: "Force the operation without confirmation",
+    connection: "Queue connection to use",
+    concurrency: "Number of concurrent workers"
+  };
+  buddy.command("queue:work", "Start processing jobs on the queue").option("-p, --project [project]", descriptions.project, { default: !1 }).option("-q, --queue [queue]", descriptions.queue, { default: !1 }).option("-c, --connection [connection]", descriptions.connection, { default: !1 }).option("--concurrency [concurrency]", descriptions.concurrency, { default: "1" }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:work` ...", options);
+    const SHUTDOWN_GRACE_MS = 1e4;
+    let shuttingDown = !1;
+    const cleanup = (signal) => {
+      if (shuttingDown)
+        return;
+      shuttingDown = !0;
+      log.info(`[queue] Received ${signal}, draining workers (max ${SHUTDOWN_GRACE_MS / 1000}s)\u2026`);
+      import("@stacksjs/queue").then(({ stopProcessor }) => stopProcessor({ graceMs: SHUTDOWN_GRACE_MS })).catch((error) => log.error("[queue] stopProcessor failed", error));
+      setTimeout(() => {
+        log.warn("[queue] Drain timeout exceeded \u2014 forcing shutdown.");
+        process.exit(ExitCode.FatalError);
+      }, SHUTDOWN_GRACE_MS).unref();
+    };
+    process.on("SIGINT", () => cleanup("SIGINT"));
+    process.on("SIGTERM", () => cleanup("SIGTERM"));
+    const perf = await intro("buddy queue:work"), result = await runAction(Action.QueueWork, options);
+    if (result.isErr) {
+      await outro("While running the queue:work command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:failed", "List all failed jobs").option("-p, --project [project]", descriptions.project, { default: !1 }).option("-q, --queue [queue]", descriptions.queue, { default: !1 }).option("--since [duration]", "Only show jobs failed since (e.g. 1h, 30m, 2d)", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:failed` ...", options);
+    const perf = await intro("buddy queue:failed"), result = await runAction(Action.QueueFailed, options);
+    if (result.isErr) {
+      await outro("While running the queue:failed command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Listed all failed jobs", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:retry [id]", "Retry failed jobs").option("-p, --project [project]", descriptions.project, { default: !1 }).option("-q, --queue [queue]", descriptions.queue, { default: !1 }).option("--all", descriptions.all, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (id, options) => {
+    log.debug("Running `buddy queue:retry` ...", options);
+    const perf = await intro("buddy queue:retry"), result = await runAction(Action.QueueRetry, { ...options, id });
+    if (result.isErr) {
+      await outro("While running the queue:retry command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    const message = options.all ? "Retried all failed jobs" : `Retried failed job ${id}`;
+    await outro(message, {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:clear", "Clear all jobs from the queue").option("-p, --project [project]", descriptions.project, { default: !1 }).option("-q, --queue [queue]", descriptions.queue, { default: !1 }).option("--force", descriptions.force, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:clear` ...", options);
+    const perf = await intro("buddy queue:clear"), result = await runAction(Action.QueueClear, options);
+    if (result.isErr) {
+      await outro("While running the queue:clear command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    const queueName = options.queue || "default";
+    await outro(`Cleared all jobs from the "${queueName}" queue`, {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:list", "List queued jobs (flat row view, filterable by queue/status)").option("-p, --project [project]", descriptions.project, { default: !1 }).option("-q, --queue [queue]", descriptions.queue, { default: !1 }).option("--status [status]", "Filter by pending | reserved | delayed", { default: !1 }).option("--limit [limit]", "Maximum rows to display (default 50)", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:list` ...", options);
+    const perf = await intro("buddy queue:list"), result = await runAction(Action.QueueList, options);
+    if (result.isErr) {
+      await outro("While running the queue:list command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Listed queued jobs", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:status", "Display the status of queue workers").option("-p, --project [project]", descriptions.project, { default: !1 }).option("-q, --queue [queue]", descriptions.queue, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:status` ...", options);
+    const perf = await intro("buddy queue:status"), result = await runAction(Action.QueueStatus, options);
+    if (result.isErr) {
+      await outro("While running the queue:status command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Queue status displayed", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:flush", "Delete all failed jobs").option("-p, --project [project]", descriptions.project, { default: !1 }).option("-q, --queue [queue]", descriptions.queue, { default: !1 }).option("--force", descriptions.force, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:flush` ...", options);
+    const perf = await intro("buddy queue:flush"), result = await runAction(Action.QueueFlush, options);
+    if (result.isErr) {
+      await outro("While running the queue:flush command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Flushed all failed jobs", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:dlq", "List dead-letter jobs (jobs that re-failed after retry)").option("-p, --project [project]", descriptions.project, { default: !1 }).option("-q, --queue [queue]", descriptions.queue, { default: !1 }).option("--reason [reason]", "Filter by reason (repeat-failure | poison-detected | circuit-broken | manual)", { default: !1 }).option("--since [duration]", "Only show rows dead-lettered since (e.g. 1h, 30m, 2d)", { default: !1 }).option("--limit [limit]", "Maximum rows to display (default 100)", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:dlq` ...", options);
+    const perf = await intro("buddy queue:dlq"), result = await runAction(Action.QueueDlq, options);
+    if (result.isErr) {
+      await outro("While running queue:dlq there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Listed dead-letter jobs", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:dlq:retry", "Re-enqueue a dead-letter job back into its queue").option("--id [id]", "Dead-letter row id to retry", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:dlq:retry` ...", options);
+    const perf = await intro("buddy queue:dlq:retry"), result = await runAction(Action.QueueDlqRetry, options);
+    if (result.isErr) {
+      await outro("While running queue:dlq:retry there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Re-enqueued dead-letter job", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:dlq:purge", "Delete dead-letter rows older than a retention window").option("--older-than-days [days]", "Retention window in days (default 30)", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:dlq:purge` ...", options);
+    const perf = await intro("buddy queue:dlq:purge"), result = await runAction(Action.QueueDlqPurge, options);
+    if (result.isErr) {
+      await outro("While running queue:dlq:purge there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Purged dead-letter rows", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:quarantine", "List quarantined jobs (or --add a manual quarantine)").option("--add [jobName]", "Manually quarantine a job class", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:quarantine` ...", options);
+    const perf = await intro("buddy queue:quarantine"), result = await runAction(Action.QueueQuarantine, options);
+    if (result.isErr) {
+      await outro("While running queue:quarantine there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("queue:quarantine done", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:unquarantine", "Lift the quarantine on a job class").option("--name [name]", "Job class name to unquarantine", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:unquarantine` ...", options);
+    const perf = await intro("buddy queue:unquarantine"), result = await runAction(Action.QueueUnquarantine, options);
+    if (result.isErr) {
+      await outro("While running queue:unquarantine there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Unquarantined", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:pause", "Manually pause a queue (circuit-breaker)").option("--queue [name]", "Queue name to pause", { default: !1 }).option("--for [seconds]", "Pause duration in seconds (default 300)", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:pause` ...", options);
+    const perf = await intro("buddy queue:pause"), result = await runAction(Action.QueuePause, options);
+    if (result.isErr) {
+      await outro("While running queue:pause there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Paused queue", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:resume", "Resume a paused queue (circuit-breaker)").option("--queue [name]", "Queue name to resume", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:resume` ...", options);
+    const perf = await intro("buddy queue:resume"), result = await runAction(Action.QueueResume, options);
+    if (result.isErr) {
+      await outro("While running queue:resume there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Resumed queue", { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:table", "Create a migration for the jobs database table").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:table` ...", options);
+    const perf = await intro("buddy queue:table"), result = await runAction(Action.QueueTable, options);
+    if (result.isErr) {
+      await outro("While running the queue:table command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Jobs table migration created", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:monitor", "Monitor queue status in real-time").option("-p, --project [project]", descriptions.project, { default: !1 }).option("-q, --queue [queue]", descriptions.queue, { default: !1 }).option("-i, --interval [interval]", "Refresh interval in milliseconds", { default: "2000" }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:monitor` ...", options);
+    const result = await runAction(Action.QueueMonitor, options);
+    if (result.isErr) {
+      log.error("While running the queue:monitor command, there was an issue", result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:inspect [id]", "Inspect a specific job").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--failed", "Inspect a failed job", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (id, options) => {
+    log.debug("Running `buddy queue:inspect` ...", options);
+    const perf = await intro("buddy queue:inspect"), result = await runAction(Action.QueueInspect, { ...options, id });
+    if (result.isErr) {
+      await outro("While running the queue:inspect command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Job inspection complete", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:schedule", "Start the job scheduler for cron-based jobs").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:schedule` ...", options);
+    const result = await runAction(Action.QueueSchedule, options);
+    if (result.isErr) {
+      log.error("While running the queue:schedule command, there was an issue", result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("queue:schedule:list", "List all scheduled jobs").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy queue:schedule:list` ...", options);
+    const perf = await intro("buddy queue:schedule:list"), result = await runAction(Action.QueueScheduleList, options);
+    if (result.isErr) {
+      await outro("While running the queue:schedule:list command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Listed all scheduled jobs", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  onUnknownSubcommand(buddy, "queue");
+}

package/dist/commands/release.js

@@ -0,0 +1,30 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, italic, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+const descriptions = {
+  release: "Release a new version of your libraries/packages",
+  project: "Target a specific project",
+  dryRun: "Run the release without actually releasing",
+  bump: "Non-interactive bump: patch | minor | major | prepatch | preminor | premajor | prerelease | x.y.z",
+  verbose: "Enable verbose output"
+};
+export function release(buddy) {
+  buddy.command("release", descriptions.release).option("--dry-run", descriptions.dryRun, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--bump <type>", descriptions.bump).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy release` ...", options);
+    if (options.dryRun)
+      log.warn("Dry run enabled. No changes will be made or committed.");
+    const startTime = await intro("buddy release"), result = await runAction(Action.Release, options);
+    if (result.isErr) {
+      log.error("Failed to release", result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Triggered CI/CD Release via GitHub Actions", {
+      startTime,
+      useSeconds: !0
+    });
+    log.info(`Follow along: ${italic("https://github.com/stacksjs/stacks/actions")}`);
+  });
+  onUnknownSubcommand(buddy, "release");
+}

package/dist/commands/route.js

@@ -0,0 +1,21 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function route(buddy) {
+  const descriptions = {
+    route: "Lists your routes",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("route:list", descriptions.route).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    const perf = await intro("buddy route:list"), result = await runAction(Action.RouteList, options);
+    if (result.isErr) {
+      await outro("While running the route:list command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Successfully listed routes");
+    process.exit(ExitCode.Success);
+  });
+  onUnknownSubcommand(buddy, "route");
+}