create-nexwire 4.3.0 → 4.4.0

package/fastify/src/framework/maker-cli/runtime/core.mjs

@@ -0,0 +1,560 @@
+import { spawn, spawnSync } from "node:child_process";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import http from "node:http";
+import net from "node:net";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { glob } from "glob";
+import { readCliConfig } from "../utils/env-config.mjs";
+import { getOption, hasFlag } from "../utils/flags.mjs";
+import { localBin, packageScript, runCommand, runNodeScript } from "../utils/process.mjs";
+
+/** Parse --with/--view/--viewer flags to determine which dev tools to launch.
+ *  npm swallows --view/--with into its own config and re-exposes them as
+ *  npm_config_viewer/npm_config_with env vars, so read those too. */
+function parseWithOptions(flags = []) {
+  const supported = new Set(["redis", "maildev", "studio"]);
+  const selected = new Set();
+
+  const candidates = [
+    getOption(flags, "--with"),
+    getOption(flags, "--view"),
+    getOption(flags, "--viewer"),
+    process.env.npm_config_with,
+    process.env.npm_config_view,
+    process.env.npm_config_viewer
+  ];
+
+  for (const raw of candidates) {
+    if (!raw) continue;
+    for (const item of raw.split(/[,\s]+/)) {
+      const key = item.trim().toLowerCase();
+      if (!key) continue;
+
+      if (!supported.has(key)) {
+        console.warn(`[dev] Unknown --with option '${key}' (supported: redis, maildev, studio)`);
+        continue;
+      }
+
+      selected.add(key);
+    }
+  }
+
+  return selected;
+}
+
+/** Build a list of dev UI tools to launch based on flags and with-options. */
+function devViewList(flags = [], withOptions = new Set()) {
+  const selected = new Set(withOptions);
+  if (hasFlag(flags, "--with-redis-view")) selected.add("redis");
+  if (hasFlag(flags, "--with-maildev")) selected.add("maildev");
+  if (hasFlag(flags, "--with-db-studio")) selected.add("studio");
+  return Array.from(selected);
+}
+
+/** Resolve the Redis endpoint from REDIS_URL (falls back to local default). */
+function redisEndpoint() {
+  const redisUrl = new URL(process.env.REDIS_URL || "redis://127.0.0.1:6379");
+  return {
+    url: process.env.REDIS_URL || "redis://127.0.0.1:6379",
+    hostname: redisUrl.hostname || "127.0.0.1",
+    port: redisUrl.port || "6379",
+    password: redisUrl.password ? decodeURIComponent(redisUrl.password) : ""
+  };
+}
+
+/** Build redis-commander CLI arguments from REDIS_URL env. */
+function redisConnectionArgs() {
+  const endpoint = redisEndpoint();
+  const result = [
+    "--port",
+    String(readCliConfig().commanderPort || process.env.REDIS_COMMANDER_PORT || "1369"),
+    "--redis-host",
+    endpoint.hostname,
+    "--redis-port",
+    endpoint.port
+  ];
+
+  if (endpoint.password) result.push("--redis-password", endpoint.password);
+  return result;
+}
+
+/** Commander (redis view) port, resolved the same way for every consumer. */
+function commanderPort() {
+  return String(readCliConfig().commanderPort || process.env.REDIS_COMMANDER_PORT || "1369");
+}
+
+/**
+ * Why: redis-commander only serves its own UI once it has a live Redis socket.
+ *      When Redis is down it either exits or renders a raw connection error, and
+ *      when the commander was never spawned the port is simply closed -- the
+ *      browser shows "unable to connect" with no hint about the cause.
+ * When: Before launching the redis view, and when REDIS is disabled in env.
+ * Where: Dev tool bootstrap (`redis:view`).
+ * How: Serves a Redis Commander diagnostic on the commander port. This is
+ *      deliberately NOT the bull-board page from `framework/queue/ui.ts`: that
+ *      one is about queue/job state on `/queues`, this one is the standalone
+ *      Redis key browser, so it names Redis Commander and the key browser
+ *      rather than the queue dashboard.
+ */
+function serveRedisUnavailablePage(port, endpoint) {
+  const body = `<!doctype html>
+<html>
+  <head>
+    <title>Redis Commander Unavailable</title>
+    <style>
+      body { font-family: system-ui, sans-serif; padding: 48px; text-align: center; }
+      h1 { color: #dc2626; }
+      code { background: #f3f4f6; padding: 2px 6px; border-radius: 4px; }
+      .note { color: #6b7280; font-size: 14px; }
+    </style>
+  </head>
+  <body>
+    <h1>Redis Commander Unavailable</h1>
+    <p>Redis is not connected, so the Redis key browser cannot start.</p>
+    <p>Redis URL: <code>${endpoint.url}</code></p>
+    <p>Start Redis, then run <code>npm run maker redis:view</code> again.</p>
+    <p class="note">This port serves Redis Commander (browse Redis keys).<br>Queue and job state lives on the app's own dashboard at <code>/queues</code>.</p>
+  </body>
+</html>
+`;
+
+  return new Promise((_resolve, reject) => {
+    const server = http.createServer((_req, res) => {
+      res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+      res.end(body);
+    });
+    server.once("error", reject);
+    server.listen(Number(port), () => {
+      console.log(`[redis-view] Redis is not reachable — serving the unavailable page on http://localhost:${port}`);
+    });
+  });
+}
+
+/** Poll the API health endpoint until it responds or retries exhausted. */
+async function waitForHealth(url, maxRetries = 240, intervalMs = 500) {
+  let warned = false;
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      const res = await fetch(url);
+      if (res.ok) return;
+    } catch {}
+    if (!warned) {
+      warned = true;
+      console.log(`Waiting for API health (${url})...`);
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  throw new Error(`API health-check failed after ${maxRetries} attempts (${url})`);
+}
+
+/** Wait for the API to be reachable before launching the Vite dev server.
+ *  Why: the UI boots with /api/auth/me and socket.io requests immediately;
+ *  if the backend is not up yet the browser logs ws and API errors. Applies to
+ *  ui:dev/admin:dev started on their own (bun run dev already waits for
+ *  health before spawning the UI). Set SKIP_BACKEND_WAIT=1 to disable. */
+export async function waitForBackendIfNeeded() {
+  if (process.env.SKIP_BACKEND_WAIT === "1") return;
+  const healthUrl = `${process.env.APP_URL || "http://localhost:3000"}/health`;
+  await waitForHealth(healthUrl);
+}
+
+/** Run the full dev stack: API, UI, queue worker, and optional UI tools. */
+async function runDevStack(flags = []) {
+  const cliConfig = readCliConfig();
+  const commands = [{ label: "api", args: ["serve", "--src"], required: true, hint: "http://localhost:3000" }];
+
+  if (process.env.UI !== "false" && process.env.UI !== "0") {
+    commands.push({
+      label: "UI",
+      args: ["ui:dev"],
+      required: true,
+      hint: "http://localhost:5173"
+    });
+  }
+
+  if (process.env.REDIS !== "false" && process.env.REDIS !== "0") {
+    commands.push({
+      label: "queue-worker",
+      args: ["queue:work"],
+      required: false,
+      hint: "BullMQ worker"
+    });
+  }
+
+  const withOptions = parseWithOptions(flags);
+  const views = devViewList(flags, withOptions);
+  // Keep launching the view when it was explicitly asked for, even with Redis
+  // disabled: the view then serves the "Redis is not connected" page instead of
+  // leaving the advertised URL as a dead port.
+  const enableRedisView = hasFlag(flags, "--with-redis-view") || withOptions.has("redis");
+  const enableMaildev = hasFlag(flags, "--with-maildev") || withOptions.has("maildev");
+  const enableDbStudio = hasFlag(flags, "--with-db-studio") || withOptions.has("studio");
+
+  if (enableRedisView) {
+    commands.push({
+      label: "redis-view",
+      args: ["redis:view", "--quiet"],
+      required: false,
+      hint: `http://localhost:${commanderPort()}`
+    });
+  }
+  if (enableMaildev) {
+    commands.push({
+      label: "maildev-view",
+      args: ["maildev:view", "--quiet"],
+      required: false,
+      hint: `http://localhost:${cliConfig.maildev?.webPort || 1080}`
+    });
+  }
+  if (enableDbStudio) {
+    commands.push({
+      label: "db-studio",
+      args: ["db:studio", "--quiet"],
+      required: false,
+      hint: "https://local.drizzle.studio"
+    });
+  }
+
+  const children = [];
+  let shuttingDown = false;
+  let settled = false;
+
+  const killTree = (child) => {
+    if (!child || child.killed) return;
+    try {
+      if (process.platform === "win32" && child.pid) {
+        spawnSync("taskkill", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+      } else {
+        child.kill("SIGTERM");
+      }
+    } catch {}
+  };
+
+  const killAll = () => {
+    for (const child of children) killTree(child);
+  };
+
+  const shutdown = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    killAll();
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  const apiCmd = commands.find((c) => c.label === "api");
+  const rest = commands.filter((c) => c.label !== "api");
+
+  await new Promise((resolve, reject) => {
+    const handleChildExit = (child, command) => {
+      child.on("exit", (code, signal) => {
+        if (settled) return;
+        if (!shuttingDown && (code !== null || signal !== null)) {
+          if (command.required) {
+            settled = true;
+            shutdown();
+            reject(new Error(`${command.label} exited (${signal || code})`));
+            return;
+          }
+          if (code !== 0 || signal) {
+            console.warn(`[dev] Optional process '${command.label}' exited (${signal || code}); continuing`);
+          }
+        }
+
+        const allExited = children.every((item) => item.exitCode !== null || item.signalCode !== null);
+        if (allExited) {
+          settled = true;
+          resolve();
+        }
+      });
+    };
+
+    const run = async () => {
+      const apiChild = spawn(process.execPath, [process.argv[1], ...apiCmd.args], {
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          NEXWIRE_DEV_VIEWS: views.join(","),
+          NEXWIRE_FRONTEND_URL: "http://localhost:5173"
+        }
+      });
+      children.push(apiChild);
+
+      handleChildExit(apiChild, apiCmd);
+      apiChild.on("error", (error) => {
+        if (settled) return;
+        settled = true;
+        shutdown();
+        reject(error);
+      });
+
+      try {
+        await waitForHealth("http://localhost:3000/health");
+      } catch (err) {
+        settled = true;
+        shutdown();
+        reject(err);
+        return;
+      }
+
+      for (const command of rest) {
+        const child = spawn(process.execPath, [process.argv[1], ...command.args], {
+          stdio: command.label === "queue-worker" ? "inherit" : ["ignore", "ignore", "inherit"],
+          env: { ...process.env }
+        });
+        children.push(child);
+
+        handleChildExit(child, command);
+
+        child.on("error", (error) => {
+          if (settled) return;
+          settled = true;
+          shutdown();
+          reject(error);
+        });
+      }
+    };
+
+    run();
+  }).finally(() => {
+    process.off("SIGINT", shutdown);
+    process.off("SIGTERM", shutdown);
+    killAll();
+  });
+}
+
+/** Build the runtime-appropriate command/args for a built dist entrypoint. */
+function runtimeEntryCommand(runtime, entry, runtimeArgs = []) {
+  if (runtime === "bun") return { command: "bun", args: [entry, ...runtimeArgs] };
+  return { command: process.execPath, args: [entry, ...runtimeArgs] };
+}
+
+/** Run a runtime command: dev, serve, queue:work, queue:clear, schedule:work. */
+export async function runRuntime(commandName, rawArgs = []) {
+  const prod = rawArgs.includes("--prod");
+  const forceSrc = rawArgs.includes("--src");
+  const watch = rawArgs.includes("--watch");
+  const runtimeArg = rawArgs.find((arg) => arg.startsWith("--runtime="));
+  const runtime = runtimeArg ? runtimeArg.split("=")[1].trim().toLowerCase() : "node";
+
+  if (!["node", "bun"].includes(runtime)) {
+    throw new Error(`Invalid runtime '${runtime}'. Supported values: node, bun`);
+  }
+
+  const runtimeArgs = rawArgs.filter((arg, i) => i > 0 && !arg.startsWith("--runtime=") && arg !== "--prod" && arg !== "--src");
+  const hasDistServer = fsSync.existsSync(path.resolve(process.cwd(), "dist/src/framework/server.js"));
+  const hasDistWorker = fsSync.existsSync(path.resolve(process.cwd(), "dist/src/framework/queue/worker.js"));
+  const hasDistScheduler = fsSync.existsSync(path.resolve(process.cwd(), "dist/src/framework/scheduler/run.js"));
+
+  if (commandName === "dev") {
+    await runDevStack(rawArgs.slice(1));
+    return;
+  }
+
+  if (commandName === "serve") {
+    if (!forceSrc && (prod || hasDistServer)) {
+      const entry = path.resolve(process.cwd(), "dist/src/framework/server.js");
+      const { command, args } = runtimeEntryCommand(runtime, entry, runtimeArgs);
+      await runCommand(command, args);
+      return;
+    }
+
+    const useWatch = watch || (!prod && forceSrc);
+    const tsxWatchIgnore = [
+      "--include",
+      "src/**/*.ts",
+      "--include",
+      "src/framework/maker-cli/**/*.mjs",
+      "--exclude",
+      "src/storage/**",
+      "--exclude",
+      "src/storage/logs/**",
+      "--exclude",
+      "src/storage/tmp/**",
+      "--exclude",
+      "src/database/migrations/**",
+      "--exclude",
+      "src/database/schema.ts",
+      "--exclude",
+      "public/**",
+      "--exclude",
+      "dist/**",
+      "--exclude",
+      ".git/**",
+      "--exclude",
+      "node_modules/**",
+      "--exclude",
+      "**/.DS_Store",
+      "--exclude",
+      "**/Thumbs.db",
+      "--exclude",
+      "**/*.log"
+    ];
+    const tsxArgs = useWatch
+      ? ["watch", ...tsxWatchIgnore, "src/framework/server.ts", ...runtimeArgs]
+      : ["src/framework/server.ts", ...runtimeArgs];
+    await runCommand(localBin("tsx"), tsxArgs);
+    return;
+  }
+
+  if (commandName === "queue:work") {
+    if (!forceSrc && (prod || hasDistWorker)) {
+      const entry = path.resolve(process.cwd(), "dist/src/framework/queue/worker.js");
+      const { command, args } = runtimeEntryCommand(runtime, entry, runtimeArgs);
+      await runCommand(command, args);
+      return;
+    }
+
+    await runNodeScript(packageScript("tsx", "dist/cli.mjs"), ["src/framework/queue/worker.ts", ...rawArgs.slice(1)]);
+    return;
+  }
+
+  if (commandName === "queue:clear") {
+    await runNodeScript(packageScript("tsx", "dist/cli.mjs"), ["src/framework/queue/clear.ts"]);
+    return;
+  }
+
+  if (commandName === "schedule:work") {
+    if (!forceSrc && (prod || hasDistScheduler)) {
+      const entry = path.resolve(process.cwd(), "dist/src/framework/scheduler/run.js");
+      const { command, args } = runtimeEntryCommand(runtime, entry, runtimeArgs);
+      await runCommand(command, args);
+      return;
+    }
+
+    await runNodeScript(packageScript("tsx", "dist/cli.mjs"), ["src/framework/scheduler/run.ts", ...rawArgs.slice(1)]);
+  }
+}
+
+/**
+ * Why: Deciding whether to launch redis-commander needs to know if Redis is
+ *      actually accepting connections, which REDIS=true does not guarantee.
+ * When: Before spawning the redis view.
+ * Where: Dev tool bootstrap.
+ * How: Opens a short-lived TCP socket to the configured host/port.
+ */
+function isRedisReachable(endpoint, timeoutMs = 1500) {
+  return new Promise((resolve) => {
+    const socket = net.connect({ host: endpoint.hostname, port: Number(endpoint.port) });
+    let settled = false;
+    const done = (ok) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(ok);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => done(true));
+    socket.once("timeout", () => done(false));
+    socket.once("error", () => done(false));
+  });
+}
+
+/** Launch a UI tool: maildev or redis-commander. */
+export async function runUi(commandName) {
+  if (commandName === "maildev:view") {
+    const maildev = readCliConfig().maildev || {};
+    await runCommand(localBin("maildev"), [
+      "--smtp",
+      String(maildev.smtpPort || process.env.MAIL_PORT || process.env.MAILDEV_SMTP_PORT || "1025"),
+      "--web",
+      String(maildev.webPort || process.env.MAILDEV_WEB_PORT || "1080")
+    ]);
+    return;
+  }
+
+  if (commandName === "redis:view") {
+    const endpoint = redisEndpoint();
+
+    if (process.env.REDIS === "false" || process.env.REDIS === "0") {
+      console.log("[redis-view] REDIS is disabled in .env — Redis Commander will not connect.");
+      await serveRedisUnavailablePage(commanderPort(), endpoint);
+      return;
+    }
+
+    if (!(await isRedisReachable(endpoint))) {
+      console.log(`[redis-view] No Redis server responded at ${endpoint.hostname}:${endpoint.port}.`);
+      await serveRedisUnavailablePage(commanderPort(), endpoint);
+      return;
+    }
+
+    const patch = fileURLToPath(new URL("./redis-commander-patch.cjs", import.meta.url));
+    await runCommand(process.execPath, [
+      "--require",
+      patch,
+      packageScript("redis-commander", "bin/redis-commander.js"),
+      ...redisConnectionArgs()
+    ]);
+    return;
+  }
+}
+
+/** Start Vite dev server for a specific config file. */
+export async function runVite(configPath) {
+  await waitForBackendIfNeeded();
+  await runCommand(localBin("vite"), ["--config", configPath]);
+}
+
+/**
+ * Strip the argument separator npm inserts.
+ *
+ * `npm run maker test -- posts` reaches us as `test posts`, but
+ * `npm run maker test -- -- posts` reaches us as `test -- posts`, because npm
+ * eats one separator and forwards the other. Vitest reads a bare `--` as a
+ * positional filter that matches no test file, which silently runs the whole
+ * suite instead of the one you asked for - so the command appears to work while
+ * doing something else. Dropping a leading `--` makes both spellings behave the
+ * same, and makes the passthrough behave identically across package managers.
+ */
+function vitestArgs(rawArgs) {
+  return rawArgs[0] === "--" ? rawArgs.slice(1) : rawArgs;
+}
+
+/** Run Vitest tests once (backend). */
+export async function runTest(rawArgs = []) {
+  // "run" is required. Bare `vitest` is watch mode, which never exits - so
+  // without this, `maker test` hung in any interactive terminal while CI and
+  // piped runs exited normally, and the two looked identical from a log.
+  await runCommand(localBin("vitest"), ["run", ...vitestArgs(rawArgs)]);
+}
+
+/** Run Vitest in watch mode (backend). */
+export async function runTestWatch(rawArgs = []) {
+  await runCommand(localBin("vitest"), vitestArgs(rawArgs));
+}
+
+/** Run Vitest once with coverage (backend). */
+export async function runTestCoverage(rawArgs = []) {
+  await runCommand(localBin("vitest"), ["run", "--coverage", ...vitestArgs(rawArgs)]);
+}
+
+/** Run Vitest in UI mode (backend). */
+export async function runTestUI(rawArgs = []) {
+  await runCommand(localBin("vitest"), ["--ui", ...vitestArgs(rawArgs)]);
+}
+
+/** Clear Vite cache directories. */
+export async function clearViteCache() {
+  const dirs = [path.resolve(process.cwd(), "node_modules/.vite"), path.resolve(process.cwd(), "src/resources/node_modules/.vite")];
+
+  for (const dir of dirs) {
+    await fs.rm(dir, { recursive: true, force: true }).catch(() => {});
+  }
+
+  const strayCaches = await glob("**/.vite", {
+    cwd: process.cwd(),
+    nodir: false,
+    ignore: ["**/node_modules/**/.vite/**", "**/.git/**"],
+    windowsPathsNoEscape: true
+  });
+
+  for (const rel of strayCaches) {
+    const fullPath = path.resolve(process.cwd(), rel);
+    await fs.rm(fullPath, { recursive: true, force: true }).catch(() => {});
+  }
+
+  console.log("Vite cache cleared.");
+}

package/fastify/src/framework/maker-cli/runtime/index.mjs

@@ -0,0 +1,120 @@
+import { clearViteCache, runRuntime, runTest, runTestCoverage, runTestUI, runTestWatch, runUi, runVite } from "./core.mjs";
+import { initProjectCommands, PROJECT_COMMANDS_PATH } from "../utils/project-commands.mjs";
+
+/** Register runtime commands (dev, serve, queue, schedule, UI tools) on the CLI program. */
+export function registerRuntimeCommands(program, rawArgs) {
+  program
+    .command("dev")
+    .description("Start API + Vue 3 UI plus optional workers/tools")
+    .option("--view <tools>", "Comma-separated UI tools to launch (redis,maildev,studio)")
+    .option("--viewer <tools>", "Alias for --view (npm expands --view to --viewer)")
+    .option("--with <tools>", "Alias for --view")
+    .option("--with-redis-view", "Launch Redis Commander")
+    .option("--with-maildev", "Launch MailDev")
+    .option("--with-db-studio", "Launch Drizzle Studio")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("dev", rawArgs));
+  program
+    .command("serve")
+    .description("Start HTTP server (dist first if built, else src)")
+    .option("--prod", "Run production build")
+    .option("--runtime <name>", "Runtime: node or bun", "node")
+    .option("--watch", "Watch for file changes (src mode)")
+    .option("--src", "Force source mode even if dist exists")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("serve", rawArgs));
+  program
+    .command("queue:work")
+    .description("Start queue worker (dist first if built, else src)")
+    .option("--queue <name>", "Queue name", "default")
+    .option("--prod", "Run production build")
+    .option("--runtime <name>", "Runtime: node or bun", "node")
+    .option("--src", "Force source mode even if dist exists")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("queue:work", rawArgs));
+  program
+    .command("queue:clear")
+    .description("Clear all queue keys")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("queue:clear", rawArgs));
+  program
+    .command("schedule:work")
+    .description("Start scheduler worker (dist first if built, else src)")
+    .option("--prod", "Run production build")
+    .option("--runtime <name>", "Runtime: node or bun", "node")
+    .option("--src", "Force source mode even if dist exists")
+    .allowUnknownOption(true)
+    .action(async () => runRuntime("schedule:work", rawArgs));
+  program
+    .command("maildev:view")
+    .description("Start MailDev SMTP and web UI")
+    .allowUnknownOption(true)
+    .action(async () => runUi("maildev:view"));
+  program
+    .command("redis:view")
+    .description("Start Redis Commander UI")
+    .allowUnknownOption(true)
+    .action(async () => runUi("redis:view"));
+  program
+    .command("ui:dev")
+    .description("Start Vue 3 UI from src/resources")
+    .allowUnknownOption(true)
+    .action(async () => runVite("src/resources/vite.config.ts"));
+  program
+    .command("admin:dev")
+    .description("Start admin UI dev server")
+    .allowUnknownOption(true)
+    .action(async () => runVite("src/resources/vite.config.ts"));
+  program
+    .command("vite:cache:clear")
+    .description("Clear Vite cache folders (cross-platform)")
+    .allowUnknownOption(true)
+    .action(async () => clearViteCache());
+  program
+    .command("maker:init")
+    .description(`Create ${PROJECT_COMMANDS_PATH} for your own commands`)
+    .option("--force", "Overwrite an existing file")
+    .allowUnknownOption(true)
+    .action(async (options) => {
+      const { created, overwritten } = await initProjectCommands(process.cwd(), { force: Boolean(options?.force) });
+      // created = written into a new file; overwritten = replaced under --force.
+      // Neither means the file was already there and was left alone.
+      console.log(
+        created || overwritten
+          ? `Add your commands to ${PROJECT_COMMANDS_PATH}, then run: maker --help`
+          : `${PROJECT_COMMANDS_PATH} already exists and was left alone. Edit it to add commands, or re-run with --force to replace it.`
+      );
+    });
+  program
+    .command("test")
+    .description("Run Vitest backend tests")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTest(args);
+    });
+  program
+    .command("test:watch")
+    .description("Run Vitest backend tests in watch mode")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTestWatch(args);
+    });
+  program
+    .command("test:coverage")
+    .description("Run Vitest backend tests with code coverage")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTestCoverage(args);
+    });
+  program
+    .command("test:ui")
+    .description("Run Vitest backend tests in UI mode")
+    .allowUnknownOption(true)
+    .action(async () => {
+      const args = process.argv.slice(3);
+      await runTestUI(args);
+    });
+}

package/fastify/src/framework/maker-cli/runtime/redis-commander-patch.cjs

@@ -0,0 +1,20 @@
+// Why: Redis Commander 0.4.5 bundles legacy `connect`/`serve-static`/`send`
+//      whose `SendStream#isFresh` reads `http.ServerResponse#_headers`, which
+//      Node removed in v15. Without this shim it crashes with:
+//        TypeError: Cannot read properties of undefined (reading 'last-modified')
+// When: Loaded via `node --require` before Redis Commander starts.
+// Where: maker-cli redis:view launcher.
+// How: Re-exposes `_headers` on the ServerResponse prototype, backed by the
+//      modern `getHeaders()` API. Safe on older Node too (getHeaders is the
+//      same data `_headers` used to return).
+const http = require("node:http");
+
+if (!("_headers" in http.ServerResponse.prototype)) {
+  Object.defineProperty(http.ServerResponse.prototype, "_headers", {
+    configurable: true,
+    enumerable: false,
+    get() {
+      return this.getHeaders();
+    }
+  });
+}