@stacksjs/buddy 0.70.88 → 0.70.91

package/dist/commands/queue.js

@@ -0,0 +1,248 @@
+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 PARENT_BACKSTOP_MS = (Number(process.env.STACKS_QUEUE_SHUTDOWN_GRACE_MS) || 1e4) + 5000;
+    let shuttingDown = !1;
+    const onSignal = (signal) => {
+      if (shuttingDown)
+        return;
+      shuttingDown = !0;
+      log.info(`[queue] Received ${signal}; waiting for the worker to drain\u2026`);
+      setTimeout(() => {
+        log.warn("[queue] Worker drain overran its window \u2014 forcing shutdown.");
+        process.exit(ExitCode.FatalError);
+      }, PARENT_BACKSTOP_MS).unref();
+    };
+    process.on("SIGINT", () => onSignal("SIGINT"));
+    process.on("SIGTERM", () => onSignal("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.d.ts

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

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.d.ts

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

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");
+}

package/dist/commands/saas.d.ts

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

package/dist/commands/saas.js

@@ -0,0 +1,25 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, log, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function saas(buddy) {
+  const descriptions = {
+    stripe: "Sets up stripe products in the dashboard",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("stripe:setup", descriptions.stripe).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy stripe:setup` ...", options);
+    const perf = await intro("buddy stripe:setup"), result = await runAction(Action.StripeSetup, options);
+    if (result.isErr) {
+      await outro("While running the stripe:setup command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Stripe products created successfully", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+}

package/dist/commands/schedule.d.ts

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

package/dist/commands/schedule.js

@@ -0,0 +1,61 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, log, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function schedule(buddy) {
+  const descriptions = {
+    project: "Target a specific project",
+    schedule: "Run the scheduler",
+    verbose: "Enable verbose output",
+    list: "List all registered scheduled tasks with their next run time",
+    status: "Show currently-held overlap locks (this-process only)"
+  };
+  buddy.command("schedule:run", descriptions.schedule).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy schedule:run` ...", options);
+    const perf = await intro("buddy schedule:run"), result = await runAction(Action.ScheduleRun, options);
+    if (result.isErr) {
+      await outro("While running the schedule:run command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("schedule:list", descriptions.list).action(async () => {
+    try {
+      await import(`${process.cwd()}/routes/scheduler.ts`).catch(() => {
+        log.warn("[schedule:list] no routes/scheduler.ts found \u2014 registry will be empty unless tasks were registered elsewhere");
+      });
+      const { Schedule } = await import("@stacksjs/scheduler"), jobs = Schedule.listJobs();
+      if (jobs.length === 0) {
+        log.info("No scheduled tasks registered.");
+        process.exit(ExitCode.Success);
+      }
+      const nameWidth = Math.max(4, ...jobs.map((j) => j.name.length)), patternWidth = Math.max(7, ...jobs.map((j) => (j.pattern ?? "").length));
+      log.info(`${"NAME".padEnd(nameWidth)}  ${"PATTERN".padEnd(patternWidth)}  TIMEZONE                   NEXT RUN (UTC)`);
+      for (const j of jobs) {
+        const next = j.nextRun ? j.nextRun.toISOString() : "\u2014";
+        log.info(`${j.name.padEnd(nameWidth)}  ${(j.pattern ?? "").padEnd(patternWidth)}  ${(j.timezone ?? "UTC").padEnd(25)}  ${next}`);
+      }
+      process.exit(ExitCode.Success);
+    } catch (err) {
+      log.error(`[schedule:list] failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command("schedule:status", descriptions.status).action(async () => {
+    try {
+      const { Schedule } = await import("@stacksjs/scheduler"), held = Schedule.listLocks();
+      if (held.length === 0)
+        log.info("No in-process scheduler locks held.");
+      else {
+        log.info(`Held locks (${held.length}):`);
+        for (const name of held)
+          log.info(`  \u2022 ${name}`);
+      }
+      process.exit(ExitCode.Success);
+    } catch (err) {
+      log.error(`[schedule:status] failed: ${err instanceof Error ? err.message : String(err)}`);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+}

package/dist/commands/search.d.ts

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

package/dist/commands/search.js

@@ -0,0 +1,84 @@
+import process from "node:process";
+import { runAction } from "@stacksjs/actions";
+import { intro, log, outro } from "@stacksjs/cli";
+import { Action } from "@stacksjs/enums";
+import { ExitCode } from "@stacksjs/types";
+export function search(buddy) {
+  const descriptions = {
+    import: "Indexes database data to search engine",
+    flush: "Flushes all data from search engine",
+    settings: "Update index settings",
+    list: "List index settings",
+    model: "Target a specific model",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("search-engine:update", descriptions.import).option("-m, --model [model]", descriptions.model, { default: "" }).option("-f, --flush [flush]", descriptions.flush, { default: !1 }).option("-s, --settings [settings]", descriptions.settings, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).option("-p, --project [project]", descriptions.project, { default: !1 }).action(async (options) => {
+    log.debug("Running `search-engine:update` ...", options);
+    let actionString = Action.SearchEngineImport, introString = "search-engine:update";
+    if (options.model) {
+      actionString = Action.SearchEngineImport;
+      introString = `search-engine:update --model ${options.model}`;
+    }
+    if (options.settings) {
+      actionString = Action.SearchEnginePushSettings;
+      introString = "search-engine:update --settings";
+    }
+    if (options.flush) {
+      actionString = Action.SearchEngineFlush;
+      introString = "search-engine:update --flush";
+    }
+    const perf = await intro(introString), result = await runAction(actionString, options);
+    if (result.isErr) {
+      await outro("While running the search-engine:update command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Successfully imported model data to search engine.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+  });
+  buddy.command("search-engine:settings", descriptions.list).option("-m, --model [model]", descriptions.model, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    if (!options.model)
+      log.error("Missing required option --model");
+    log.debug("Running `search-engine:settings` ...", options);
+    const perf = await intro("search-engine:settings"), result = await runAction(Action.SearchEngineListSettings, options);
+    if (result.isErr) {
+      await outro("While running the search-engine:settings command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro("Successfully listed search engine index settings.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("search:reindex [model]", "Re-index a model (Scout-style alias for search-engine:update)").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (model, options) => {
+    const opts = { ...options, model: model ?? "" };
+    log.debug("Running `search:reindex` ...", opts);
+    const perf = await intro(`search:reindex${model ? ` ${model}` : ""}`), result = await runAction(Action.SearchEngineImport, opts);
+    if (result.isErr) {
+      await outro("While running the search:reindex command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro(model ? `Reindexed ${model}.` : "Reindexed all searchable models.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("search:flush [model]", "Delete all documents from a model index (Scout-style alias)").option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (model, options) => {
+    const opts = { ...options, model: model ?? "", flush: !0 };
+    log.debug("Running `search:flush` ...", opts);
+    const perf = await intro(`search:flush${model ? ` ${model}` : ""}`), result = await runAction(Action.SearchEngineFlush, opts);
+    if (result.isErr) {
+      await outro("While running the search:flush command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
+      process.exit(ExitCode.FatalError);
+    }
+    await outro(model ? `Flushed ${model} from search.` : "Flushed all model indices.", {
+      startTime: perf,
+      useSeconds: !0
+    });
+    process.exit(ExitCode.Success);
+  });
+}

package/dist/commands/seed.d.ts

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

package/dist/commands/seed.js

@@ -0,0 +1,71 @@
+import process from "node:process";
+import { intro, log, onUnknownSubcommand, outro } from "@stacksjs/cli";
+import { ExitCode } from "@stacksjs/types";
+export function seed(buddy) {
+  const descriptions = {
+    seed: "Seed your database",
+    project: "Target a specific project",
+    verbose: "Enable verbose output"
+  };
+  buddy.command("seed", descriptions.seed).alias("db:seed").option("-p, --project [project]", descriptions.project, { default: !1 }).option("-c, --class [class]", "Run a specific seeder class from database/seeders/", { default: "" }).option("--allow-protected", "Seed auth/oauth models even on a non-fresh DB (will invalidate live tokens)", { default: !1 }).option("--fresh", "Truncate tables before seeding", { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
+    log.debug("Running `buddy seed` ...", options);
+    const perf = await intro("buddy seed");
+    if (options.class) {
+      const { injectGlobalAutoImports } = await import("@stacksjs/server");
+      await injectGlobalAutoImports();
+      const { runClassSeeders } = await import("@stacksjs/database"), result = await runClassSeeders({ class: options.class });
+      await outro(`Class seeders: ran=${result.ran.length}, skipped=${result.skipped.length}`, { startTime: perf, useSeconds: !0 });
+      process.exit(result.ran.length > 0 ? ExitCode.Success : ExitCode.FatalError);
+    }
+    const { injectGlobalAutoImports } = await import("@stacksjs/server");
+    await injectGlobalAutoImports();
+    const { runClassSeeders, listSeedableModels } = await import("@stacksjs/database"), { path } = await import("@stacksjs/path"), { fs } = await import("@stacksjs/storage"), seedableModels = await listSeedableModels(), seedersDir = path.projectPath("database/seeders"), existingSeederFiles = fs.existsSync(seedersDir) ? new Set(fs.readdirSync(seedersDir).filter((f) => f.endsWith(".ts"))) : new Set, unmigratedModels = seedableModels.filter((m) => !existingSeederFiles.has(`${m.name}Seeder.ts`));
+    if (unmigratedModels.length > 0)
+      log.warn(`[seed] ${unmigratedModels.length} model(s) declare the deprecated \`useSeeder\` trait but have no class seeder file: ${unmigratedModels.map((m) => m.name).join(", ")}. ` + "The auto-walker has been removed (stacksjs/stacks#1919) \u2014 these models will NOT seed. " + "Run `./buddy seed:scaffold` to codemod a class seeder per model and strip the trait (stacksjs/stacks#1929), then re-run `./buddy seed`.");
+    const classResult = await runClassSeeders(), APP_ENV = process.env.APP_ENV || "local", ran = classResult.ran.length;
+    await outro(`Seeded your ${APP_ENV} database. Class seeders: ran=${ran}, skipped=${classResult.skipped.length}.`, { startTime: perf, useSeconds: !0 });
+    process.exit(ExitCode.Success);
+  });
+  buddy.command("seed:scaffold", "Generate class seeders for every model with a useSeeder trait (codemod for stacksjs/stacks#1919)").option("--force", "Overwrite existing seeder files", { default: !1 }).option("--dry-run", "Print what would be generated without writing files", { default: !1 }).action(async (options) => {
+    const perf = await intro("buddy seed:scaffold");
+    try {
+      const { scaffoldClassSeedersFromModels } = await import("@stacksjs/database"), result = await scaffoldClassSeedersFromModels({
+        force: options.force,
+        dryRun: options.dryRun
+      }), generated = result.generated.length, alreadyThere = result.skipped.filter((s) => s.reason === "already-exists").length, stripped = result.strippedTrait.length, errors = result.errors.length;
+      for (const g of result.generated)
+        console.log(`  + ${g.model} \u2192 ${g.file}`);
+      for (const s of result.skipped.filter((s) => s.reason === "already-exists"))
+        console.log(`  \xB7 ${s.model}: seeder exists (pass --force to overwrite)`);
+      for (const t of result.strippedTrait)
+        console.log(`  - ${t.model}: removed useSeeder trait from model`);
+      for (const t of result.traitStripSkipped)
+        log.warn(`  ! ${t.model}: useSeeder value couldn't be auto-removed \u2014 strip it manually (${t.file})`);
+      for (const e of result.errors)
+        log.warn(`  ! ${e.model}: ${e.error}`);
+      const verb = options.dryRun ? "would generate" : "generated", strippedVerb = options.dryRun ? "would strip" : "stripped";
+      await outro(`Seeder scaffold: ${verb} ${generated}, skipped ${alreadyThere} existing, ${strippedVerb} ${stripped} trait(s), ${errors} error(s).`, { startTime: perf, useSeconds: !0 });
+      process.exit(errors > 0 && generated === 0 ? ExitCode.FatalError : ExitCode.Success);
+    } catch (err) {
+      await outro("seed:scaffold failed", { startTime: perf, useSeconds: !0 }, err);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  buddy.command("seed:roles", "Seed default RBAC role packs (admin, dev, client)").alias("roles:seed").action(async () => {
+    const perf = await intro("buddy seed:roles");
+    try {
+      const { seedDefaultRoles } = await import("@stacksjs/auth"), result = await seedDefaultRoles();
+      if (result.created.length === 0 && result.skipped.length > 0)
+        await outro(`All ${result.skipped.length} default role packs already exist \u2014 nothing to do.`, { startTime: perf, useSeconds: !0 });
+      else {
+        const createdNames = result.created.map((r) => r.name).join(", ");
+        await outro(`Created ${result.created.length} role pack(s): ${createdNames}. Skipped ${result.skipped.length} existing.`, { startTime: perf, useSeconds: !0 });
+      }
+      process.exit(ExitCode.Success);
+    } catch (err) {
+      await outro("Failed to seed default roles. Most often: migrations haven't run yet (try `./buddy migrate` first).", { startTime: perf, useSeconds: !0 }, err);
+      process.exit(ExitCode.FatalError);
+    }
+  });
+  onUnknownSubcommand(buddy, "seed");
+}

package/dist/commands/serve.d.ts

@@ -0,0 +1,25 @@
+import type { CLI } from '@stacksjs/types';
+/**` requests (and any non-GET/HEAD verb) are
+ * reverse-proxied to the API process — mirroring the dev views server — so
+ * scaffolded `fetch('/api/...')` calls behave identically in production
+ * (stacksjs/stacks#1950). The API runs as a separate process
+ * (core/actions/src/serve/api.ts), deployed as a second systemd service via
+ * the `api` site in config/cloud.ts. Override `API_URL` when the API lives
+ * on another host, or `PORT_API` when only the port differs.
+ *
+ * This is the entry the Hetzner deploy runs as a systemd service
+ * (`bun storage/framework/core/buddy/src/cli.ts serve`).
+ */
+export declare function serve(buddy: CLI): void;
+/**
+ * `buddy serve:api` — boot the production API server (bun-router routes).
+ *
+ * The twin of `buddy serve`: where that serves the STX frontend, this runs the
+ * loopback API the frontend proxies `/api` + non-GET requests to. The entry
+ * (`@stacksjs/actions/serve/api`) is resolved through the module graph, so it
+ * works whether the framework is vendored at `storage/framework/core` OR only
+ * installed under `node_modules/@stacksjs/actions`. This keeps deployments from
+ * having to hardcode a `storage/framework/core/...` path in their `start`
+ * command — `./buddy serve:api` resolves the framework wherever it lives.
+ */
+export declare function serveApi(buddy: CLI): void;