@basaltkit/cli 1.1.0 → 1.2.0

package/README.md

@@ -87,7 +87,7 @@ Without registering anything, `runCli` always provides:
 | `basalt list` (or `basalt` with no arguments) | Lists all available commands, with their descriptions |
 | `basalt routes` | Lists the HTTP routes registered by the application (read from the `http:routes` metadata bucket, populated by HTTP adapters such as `@basaltkit/fastify`) |
 | `basalt schedule:list` | Lists scheduled tasks and their cron expressions (read from the `schedule:entries` bucket, populated by `@basaltkit/scheduler`) |
-| `basalt dev [--entry=<file>]` | Runs the app with file watching + auto-restart (delegates to `tsx watch` when available, otherwise `node --watch`) |
+| `basalt dev [--entry] [--worker] [--queue] [--no-routes]` | Runs the app with watch + restart, **prints the route table on boot**, and with `--worker` also starts a watched `queue:work` alongside it (server + worker in one command). Delegates watching to `tsx watch` / `node --watch`. |
 | `basalt upgrade [--dry] [--only=<id>]` | Applies framework upgrade codemods (ships the `@machize/*` → `@basaltkit/*` scope rename; `--dry` previews) |
 | `basalt publish [<id>] [--force]` | Copies a bundled stub group into the app — `dockerfile`, `ci`, `editorconfig` (run with no id to list) |
 

package/dist/index.d.ts

@@ -104,7 +104,31 @@ interface DevRunner {
 declare function resolveDevRunner(entry: string, options?: {
     tsx?: boolean;
 }): DevRunner;
-/** `basalt dev [--entry=<file>]` — run the app with watch + restart. */
+/** A route as published into the `http:routes` metadata bucket by an adapter. */
+interface DevRoute {
+    method: string;
+    url: string;
+    meta?: Record<string, unknown>;
+}
+/**
+ * Formats the registered routes into printable rows (method, url, and a compact
+ * flags column for auth/rate-limit) — sorted by url then method. Pure: this is
+ * what `basalt dev` prints on boot, and `pnpm dev` (plain tsx watch) can't.
+ */
+declare function devRouteRows(routes: DevRoute[]): {
+    method: string;
+    url: string;
+    flags: string;
+}[];
+/**
+ * `basalt dev [--entry=<file>] [--worker] [--queue=<name>] [--no-routes]`
+ *
+ * A richer dev loop than a bare `tsx watch`: prints the app's **route table** on
+ * boot (the app is already booted by the CLI runner, so routes are known), then
+ * runs the server with watch/restart — and, with `--worker`, also starts a
+ * watched queue worker alongside it (server + worker in one command, the real
+ * producer/worker topology).
+ */
 declare const devCommand: CommandDefinition;
 
 /**
@@ -190,4 +214,4 @@ declare function nodePublishFs(dir: string): PublishFs;
 /** `basalt publish [<id>] [--dir=<path>] [--force]` — list, or copy a stub group. */
 declare const publishCommand: CommandDefinition;
 
-export { type CommandContext, type CommandDefinition, type CommandIo, DEV_ENTRY_CANDIDATES, type DevRunner, type Edit, MIGRATIONS, type Migration, PUBLISHABLES, type ParsedArgv, type PublishFs, type PublishResult, type Publishable, type PublishableFile, type RouteMetadata, type RunCliOptions, type ScheduleMetadata, type UpgradeFs, type UpgradeReport, builtinCommands, commandsPlugin, consoleIo, defineCommand, devCommand, memoryIo, nodePublishFs, nodeUpgradeFs, parseArgv, publishCommand, renameMachizeScope, renderTable, resolveDevEntry, resolveDevRunner, routesCommand, runCli, runPublish, runUpgrade, scheduleListCommand, upgradeCommand };
+export { type CommandContext, type CommandDefinition, type CommandIo, DEV_ENTRY_CANDIDATES, type DevRoute, type DevRunner, type Edit, MIGRATIONS, type Migration, PUBLISHABLES, type ParsedArgv, type PublishFs, type PublishResult, type Publishable, type PublishableFile, type RouteMetadata, type RunCliOptions, type ScheduleMetadata, type UpgradeFs, type UpgradeReport, builtinCommands, commandsPlugin, consoleIo, defineCommand, devCommand, devRouteRows, memoryIo, nodePublishFs, nodeUpgradeFs, parseArgv, publishCommand, renameMachizeScope, renderTable, resolveDevEntry, resolveDevRunner, routesCommand, runCli, runPublish, runUpgrade, scheduleListCommand, upgradeCommand };

package/dist/index.js

@@ -4,12 +4,13 @@ function defineCommand(command) {
 }
 
 // src/runner.ts
-import { ensureMetadata } from "@basaltkit/core";
+import { ensureMetadata as ensureMetadata2 } from "@basaltkit/core";
 
 // src/builtins.ts
 import { METADATA } from "@basaltkit/core";
 
 // src/dev.ts
+import { ensureMetadata } from "@basaltkit/core";
 var DEV_ENTRY_CANDIDATES = ["src/main.ts", "src/server.ts", "src/index.ts", "src/main.js", "src/index.js"];
 function resolveDevEntry(candidates, exists) {
   return candidates.find(exists);
@@ -20,10 +21,20 @@ function resolveDevRunner(entry, options = {}) {
   if (isTs) return { command: "node", args: ["--watch", "--experimental-strip-types", entry] };
   return { command: "node", args: ["--watch", entry] };
 }
+function devRouteRows(routes) {
+  return [...routes].sort((a, b) => a.url.localeCompare(b.url) || a.method.localeCompare(b.method)).map((r) => {
+    const flags = [];
+    if (r.meta?.["auth"] === true) flags.push("auth");
+    if (r.meta?.["rateLimit"]) flags.push("rate-limit");
+    const tags = r.meta?.["tags"];
+    if (Array.isArray(tags) && tags.length) flags.push(...tags.map(String));
+    return { method: r.method.toUpperCase(), url: r.url, flags: flags.join(", ") };
+  });
+}
 var devCommand = defineCommand({
   name: "dev",
-  description: "Run the app with file watching and auto-restart",
-  async handle({ io, flags }) {
+  description: "Run the app with watch + restart, print the route table, and (--worker) an embedded queue worker",
+  async handle({ container, io, flags }) {
     const { existsSync } = await import("fs");
     const entry = typeof flags["entry"] === "string" ? flags["entry"] : resolveDevEntry(DEV_ENTRY_CANDIDATES, existsSync);
     if (!entry) {
@@ -32,22 +43,45 @@ var devCommand = defineCommand({
       );
       return 1;
     }
+    if (flags["routes"] !== false) {
+      const routes = ensureMetadata(container).get("http:routes");
+      if (routes.length > 0) {
+        io.log(`Routes (${routes.length}):`);
+        io.table(devRouteRows(routes));
+      }
+    }
     const tsx = await canResolve("tsx");
-    const runner = resolveDevRunner(entry, { tsx });
-    io.log(`Starting: ${runner.command} ${runner.args.join(" ")}`);
+    const server = resolveDevRunner(entry, { tsx });
+    const runners = [{ label: "server", runner: server }];
+    if (flags["worker"] === true || flags["w"] === true) {
+      const bin = process.argv[1] ?? entry;
+      const workerBase = resolveDevRunner(bin, { tsx });
+      const queue = typeof flags["queue"] === "string" ? [`--queue=${flags["queue"]}`] : [];
+      runners.push({ label: "worker", runner: { command: workerBase.command, args: [...workerBase.args, "queue:work", ...queue] } });
+    }
+    for (const { label, runner } of runners) {
+      io.log(`\u25B6 ${label}: ${runner.command} ${runner.args.join(" ")}`);
+    }
     const { spawn } = await import("child_process");
     return await new Promise((resolve) => {
-      const child = spawn(runner.command, runner.args, { stdio: "inherit" });
-      const stop = () => child.kill("SIGINT");
+      const children = runners.map(({ runner }) => spawn(runner.command, runner.args, { stdio: "inherit" }));
+      const stop = () => children.forEach((c) => c.kill("SIGINT"));
       process.once("SIGINT", stop);
-      child.on("exit", (code) => {
+      let done = false;
+      const finish = (code) => {
+        if (done) return;
+        done = true;
         process.removeListener("SIGINT", stop);
-        resolve(code ?? 0);
-      });
-      child.on("error", (error) => {
-        io.error(`Failed to start dev runner: ${error.message}`);
-        resolve(1);
-      });
+        children.forEach((c) => c.kill("SIGINT"));
+        resolve(code);
+      };
+      children[0]?.on("exit", (code) => finish(code ?? 0));
+      children.forEach(
+        (child, i) => child.on("error", (error) => {
+          io.error(`Failed to start ${runners[i]?.label}: ${error.message}`);
+          finish(1);
+        })
+      );
     });
   }
 });
@@ -361,7 +395,7 @@ async function runCli(options) {
   const { command, args, flags } = parseArgv(options.argv ?? process.argv.slice(2));
   if (app.phase === "created") await app.boot();
   try {
-    const registered = ensureMetadata(app.container).get("commands");
+    const registered = ensureMetadata2(app.container).get("commands");
     const commands = [...builtinCommands(), ...registered];
     if (command === void 0 || command === "list") {
       io.log("Available commands:");
@@ -383,12 +417,12 @@ async function runCli(options) {
 }
 
 // src/plugin.ts
-import { definePlugin, ensureMetadata as ensureMetadata2 } from "@basaltkit/core";
+import { definePlugin, ensureMetadata as ensureMetadata3 } from "@basaltkit/core";
 function commandsPlugin(commands) {
   return definePlugin({
     name: "basalt:commands",
     register({ container }) {
-      const metadata = ensureMetadata2(container);
+      const metadata = ensureMetadata3(container);
       for (const command of commands) metadata.add("commands", command);
     }
   });
@@ -402,6 +436,7 @@ export {
   consoleIo,
   defineCommand,
   devCommand,
+  devRouteRows,
   memoryIo,
   nodePublishFs,
   nodeUpgradeFs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basaltkit/cli",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "The 'basalt' command framework for Basalt apps: define commands, run them against a booted app, and inspect routes and schedules.",
   "license": "MIT",
   "type": "module",