@zerotal/core 1.0.0

package/src/command/builtin/ReplCommand.ts

@@ -0,0 +1,174 @@
+/**
+ * The `repl` command: an interactive REPL that boots the application and exposes
+ * it (plus provider-contributed bindings) in the evaluation scope.
+ */
+import { join } from "node:path";
+import { Command } from "../Command.ts";
+
+const isSyntaxError = (error: unknown): boolean =>
+  error != null && typeof error === "object" && (error as { name?: string }).name === "SyntaxError";
+
+/**
+ * `bun zt repl` — starts an interactive REPL with the bootstrapped app (and
+ * provider-contributed bindings) in the evaluation scope.
+ *
+ * @category Diagnostics
+ */
+export class ReplCommand extends Command {
+  static commandName = "repl";
+  static description = "Start an interactive REPL with the bootstrapped app in scope";
+  static needsApp = true;
+
+  async run(): Promise<void> {
+    const { $ } = await import("bun");
+    const app = this.app as import("../../application/Application.ts").Application;
+
+    // Collect all globals BEFORE createContext — properties added after may not be
+    // visible inside the vm in Bun's implementation.
+    const sandbox: Record<string, unknown> = { app, $, console, process };
+
+    // Ask every active provider what it wants available in the REPL.
+    // DatabaseProvider returns { DB }, BroadcastProvider could return { Broadcast }, etc.
+    for (const provider of app._activeProviders) {
+      Object.assign(sandbox, provider.replContext());
+    }
+
+    const { createContext, runInContext } = await import("node:vm");
+    const vmContext = createContext(sandbox);
+
+    const userFacing = ["app", "$", "DB", "Mail", "Cache", "Broadcast"].filter(
+      (key) => key in sandbox,
+    );
+    const contextKeys = userFacing.length
+      ? userFacing
+      : Object.keys(sandbox).filter((key) => !["console", "process"].includes(key));
+    console.log("Zerotal REPL  –  type '.exit' or Ctrl+D to quit");
+    console.log(`  Context: ${contextKeys.join(", ")}\n`);
+
+    // ── Readline ──────────────────────────────────────────────────────────────
+    const { createInterface } = await import("node:readline");
+    const completer = (line: string): [string[], string] => {
+      const matches = contextKeys.filter((key) => key.startsWith(line));
+      return [matches.length ? matches : contextKeys, line];
+    };
+    const readline = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: true,
+      historySize: 1000,
+      prompt: "zerotal> ",
+      completer,
+    });
+
+    // ── Persistent history ────────────────────────────────────────────────────
+    const homeDir = process.env["USERPROFILE"] ?? process.env["HOME"] ?? process.cwd();
+    const historyFile = join(homeDir, ".zerotal_repl_history");
+    try {
+      const rawHistory = await Bun.file(historyFile).text();
+      const lines = rawHistory.split("\n").filter(Boolean).reverse(); // Newest-first for readline.
+      (readline as unknown as { history: string[] }).history = lines.slice(0, 1000);
+    } catch {
+      /* no history file yet */
+    }
+
+    // ── Evaluator ─────────────────────────────────────────────────────────────
+    // Three-stage fallback:
+    //   ① Sync  — handles plain expressions and sync declarations
+    //             (Bun vm keeps const/let in lexical env across calls)
+    //   ② Async expression — strips leading const/let/var so the assignment
+    //             becomes a global-scope write (persists to next line)
+    //   ③ Async statement — same strip, no return value (complex cases)
+    //
+    // NOTE: Bun's vm throws an internal error class whose .name is 'SyntaxError'
+    // but which is NOT instanceof the global SyntaxError. Use isSyntaxError().
+    const evaluate = async (line: string): Promise<void> => {
+      let result: unknown;
+      let firstError: Error | undefined;
+
+      // ① Sync
+      try {
+        result = runInContext(line, vmContext);
+        if (result instanceof Promise) result = await result;
+        if (result !== undefined)
+          process.stdout.write(Bun.inspect(result, { colors: true }) + "\n");
+        return;
+      } catch (error) {
+        if (!isSyntaxError(error)) throw error;
+        firstError = error as Error;
+      }
+
+      // ② Async expression — strip declaration keyword → global assignment persists
+      const asyncLine = line.replace(/^(?:const|let|var)\s+/, "");
+      try {
+        const promise = runInContext(
+          `(async () => { return (${asyncLine}); })()`,
+          vmContext,
+        ) as Promise<unknown>;
+        result = await promise;
+        if (result !== undefined)
+          process.stdout.write(Bun.inspect(result, { colors: true }) + "\n");
+        return;
+      } catch (error) {
+        if (!isSyntaxError(error)) throw error;
+      }
+
+      // ③ Async statement fallback
+      try {
+        const promise = runInContext(
+          `(async () => { ${asyncLine}; })()`,
+          vmContext,
+        ) as Promise<unknown>;
+        await promise;
+        return;
+      } catch (error) {
+        if (!isSyntaxError(error)) throw error;
+      }
+
+      throw firstError;
+    };
+
+    // ── REPL loop ─────────────────────────────────────────────────────────────
+    await new Promise<void>((resolve) => {
+      readline.on("close", () => {
+        const history = (readline as unknown as { history: string[] }).history;
+        if (history?.length) {
+          Bun.write(historyFile, [...history].reverse().join("\n") + "\n").catch(() => {});
+        }
+        console.log("");
+        resolve();
+      });
+
+      readline.on("SIGINT", () => {
+        if (!(readline as unknown as { line: string }).line) {
+          readline.close();
+        } else {
+          process.stdout.write("\n");
+          readline.prompt();
+        }
+      });
+
+      readline.on("line", async (rawLine: string) => {
+        const line = rawLine.trim();
+        if (!line) {
+          readline.prompt();
+          return;
+        }
+        if (line === ".exit" || line === ".quit") {
+          readline.close();
+          return;
+        }
+
+        try {
+          await evaluate(line);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          process.stderr.write("\x1b[31m✖ " + message + "\x1b[0m\n");
+        }
+
+        readline.prompt();
+      });
+
+      readline.prompt();
+    });
+  }
+}

package/src/command/builtin/RouteListCommand.ts

@@ -0,0 +1,188 @@
+import { Command } from "../Command.ts";
+import { Router } from "../../router/Router.ts";
+
+const RESET = "\x1b[0m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+
+const METHOD_COLOR: Record<string, string> = {
+  GET: "\x1b[32m", // green
+  POST: "\x1b[34m", // blue
+  PUT: "\x1b[33m", // yellow
+  PATCH: "\x1b[36m", // cyan
+  DELETE: "\x1b[31m", // red
+};
+
+/**
+ * `bun zt route:list` — lists all registered routes.
+ *
+ * Prints a table of every route registered with the Router, with columns for
+ * HTTP method (colour-coded), path, controller, action, and named route key.
+ *
+ * Requires the app to boot so that providers (e.g. AdminProvider) can register
+ * their routes via Router.group() inside onBooting().
+ *
+ * Flags:
+ *   --method / -m   filter by HTTP verb (case-insensitive)
+ *   --path   / -p   filter by path prefix substring
+ *   --name          only show named routes
+ *   --verbose / -v  add a middleware column
+ *
+ * @category Diagnostics
+ */
+export class RouteListCommand extends Command {
+  static commandName = "route:list";
+  static description = "List all registered routes";
+  static needsApp = true;
+  static args = [];
+  static flags = [
+    {
+      name: "method",
+      short: "m",
+      type: "string" as const,
+      description: "Filter by HTTP method (GET, POST, PUT, PATCH, DELETE)",
+    },
+    {
+      name: "path",
+      short: "p",
+      type: "string" as const,
+      description: "Filter routes whose path contains this string",
+    },
+    {
+      name: "name",
+      short: "n",
+      type: "boolean" as const,
+      description: "Only show named routes",
+      default: false,
+    },
+    {
+      name: "verbose",
+      short: "v",
+      type: "boolean" as const,
+      description: "Show per-route middleware classes",
+      default: false,
+    },
+  ];
+
+  async run(): Promise<void> {
+    const methodFilter = (this.flags["method"] as string | undefined)?.toUpperCase();
+    const pathFilter = this.flags["path"] as string | undefined;
+    const nameOnly = this.flags["name"] as boolean;
+    const verbose = this.flags["verbose"] as boolean;
+
+    // Build path → name lookup from the named-routes map (name → path)
+    const pathToName = new Map<string, string>();
+    for (const [name, path] of Router.namedRoutes) {
+      pathToName.set(path, name);
+    }
+
+    let rows = Array.from(Router.routes.values());
+
+    if (methodFilter) {
+      rows = rows.filter((route) => route.method === methodFilter);
+    }
+    if (pathFilter) {
+      rows = rows.filter((route) => route.path.includes(pathFilter));
+    }
+    if (nameOnly) {
+      rows = rows.filter((route) => pathToName.has(route.path));
+    }
+
+    if (rows.length === 0) {
+      this.warn("No routes match the given filters.");
+      return;
+    }
+
+    // Sort: path asc, then method asc.
+    rows.sort((first, second) => {
+      const pathComparison = first.path.localeCompare(second.path);
+      return pathComparison !== 0 ? pathComparison : first.method.localeCompare(second.method);
+    });
+
+    // Derive display strings
+    type Row = {
+      method: string;
+      path: string;
+      controller: string;
+      action: string;
+      name: string;
+      middleware: string;
+    };
+    const display: Row[] = rows.map((route) => ({
+      method: route.method,
+      path: route.path,
+      controller: _controllerName(route.controller.name),
+      action: route.action,
+      name: pathToName.get(route.path) ?? "",
+      middleware: route.middleware
+        .map((middleware) => middleware.name)
+        .filter(Boolean)
+        .join(", "),
+    }));
+
+    // Column widths.
+    const columnWidths = {
+      method: Math.max(6, ...display.map((row) => row.method.length)),
+      path: Math.max(4, ...display.map((row) => row.path.length)),
+      controller: Math.max(10, ...display.map((row) => row.controller.length)),
+      action: Math.max(6, ...display.map((row) => row.action.length)),
+      name: Math.max(4, ...display.map((row) => row.name.length)),
+    };
+
+    const total = rows.length;
+    const label = total === 1 ? "1 route" : `${total} routes`;
+    this._writer.writeLine(`\n${BOLD}Routes${RESET}  ${DIM}${label}${RESET}\n`);
+
+    // Header.
+    const header = [
+      "  ",
+      "METHOD".padEnd(columnWidths.method + 2),
+      "PATH".padEnd(columnWidths.path + 4),
+      "CONTROLLER".padEnd(columnWidths.controller + 4),
+      "ACTION".padEnd(columnWidths.action + 4),
+      "NAME".padEnd(columnWidths.name + 2),
+      ...(verbose ? ["MIDDLEWARE"] : []),
+    ].join("");
+    this._writer.writeLine(`${DIM}${header}${RESET}`);
+
+    const separator =
+      "  " +
+      "─".repeat(
+        columnWidths.method +
+          columnWidths.path +
+          columnWidths.controller +
+          columnWidths.action +
+          columnWidths.name +
+          (verbose ? 30 : 0) +
+          18,
+      );
+    this._writer.writeLine(`${DIM}${separator}${RESET}`);
+
+    // Rows.
+    for (const row of display) {
+      const color = METHOD_COLOR[row.method] ?? "";
+      const line = [
+        "  ",
+        `${color}${row.method.padEnd(columnWidths.method)}${RESET}`,
+        "  ",
+        row.path.padEnd(columnWidths.path + 2),
+        "  ",
+        `${DIM}${row.controller.padEnd(columnWidths.controller + 2)}${RESET}`,
+        "  ",
+        row.action.padEnd(columnWidths.action + 2),
+        "  ",
+        row.name ? `${DIM}${row.name}${RESET}` : "",
+        ...(verbose && row.middleware ? [`  ${DIM}${row.middleware}${RESET}`] : []),
+      ].join("");
+      this._writer.writeLine(line);
+    }
+
+    this._writer.writeLine("");
+  }
+}
+
+function _controllerName(rawName: string): string {
+  // File-based route controllers are named "FileRoute<METHOD /path>" — shorten to "file".
+  if (rawName.startsWith("FileRoute<")) return "file";
+  return rawName;
+}

package/src/command/builtin/ServeCommand.ts

@@ -0,0 +1,321 @@
+/**
+ * The `serve` command, which starts the HTTP server. Also drives dev mode: the
+ * file-watching orchestrator (process 1) and the managed dev worker (process 2).
+ */
+import { Command } from "../Command.ts";
+import { DevOrchestrator } from "../../dev/DevOrchestrator.ts";
+import { hasDevBuildHooks, runDevBuildHooks } from "../../dev/DevBuildHook.ts";
+import { buildConfiguredAssets, type AssetBuildConfig } from "../../dev/CssPlugins.ts";
+import type { ConfigManager } from "../../config/ConfigManager.ts";
+import type { Application } from "../../application/Application.ts";
+import * as DevWsServer from "../../dev/DevWsServer.ts";
+import { setAssetVersion } from "../../assets/assets.ts";
+import {
+  isPortAvailable,
+  waitForPort,
+  findAvailablePort,
+  findPortOwner,
+  stopProcess,
+  PORT_RESOLVED_ENV_VAR,
+  type PortOwner,
+} from "../../support/port.ts";
+import { localNetworkAddress } from "../../support/network.ts";
+import { createInterface } from "node:readline";
+
+/**
+ * `bun zt serve` — starts the HTTP server (and orchestrates dev mode when
+ * `--dev` is set). Aliased as `start` and `s`.
+ *
+ * @category Serving
+ */
+export class ServeCommand extends Command {
+  static commandName = "serve";
+  static aliases = ["start", "s"];
+  static description = "Start the HTTP server";
+  static needsApp = true;
+
+  static flags = [
+    {
+      name: "port",
+      short: "p",
+      type: "number" as const,
+      description: "Port to listen on",
+      default: 3000,
+    },
+    {
+      name: "dev",
+      type: "boolean" as const,
+      description: "Start in dev mode with file watching, auto-rebuild, and browser reload",
+      default: false,
+    },
+    {
+      name: "force",
+      type: "boolean" as const,
+      description: "If the port is busy, stop the process holding it",
+      default: false,
+    },
+    {
+      name: "auto-port",
+      type: "boolean" as const,
+      description: "If the port is busy, start on the next free port",
+      default: false,
+    },
+    // Internal flag — spawned by DevOrchestrator; not shown in help
+    {
+      name: "dev-worker",
+      type: "boolean" as const,
+      description: "Internal: run as the managed server process under DevOrchestrator",
+      default: false,
+    },
+  ];
+
+  async run(): Promise<void> {
+    const isDev = this.flags["dev"] as boolean;
+    const isWorker = this.flags["dev-worker"] as boolean;
+    const port = await this._resolvePort(this.flags["port"] as number, isWorker);
+    const assets = this._assetsConfig();
+
+    // ── DEV ORCHESTRATOR (Process 1) ────────────────────────────────────────
+    // Spawns and manages the server child process, watches files, drives builds.
+    if (isDev) {
+      this._announce("dev", port);
+
+      // Every view package (Inertia/Flow) that registered a build routine gets
+      // run on each change; otherwise synthesise one from `app.assets` so
+      // configured assets rebuild on change.
+      let buildHook: (() => Promise<{ success: boolean; logs?: unknown[] }>) | undefined =
+        hasDevBuildHooks() ? runDevBuildHooks : undefined;
+      if (!buildHook && assets) {
+        buildHook = (): Promise<{ success: boolean; logs?: unknown[] }> =>
+          buildConfiguredAssets(assets, process.cwd());
+      }
+
+      if (!buildHook) {
+        // No Inertia (or no frontend build configured). Fall back to simple
+        // bun --watch restart so the developer still gets auto-reload.
+        console.warn("  [zerotal:dev] no build hook registered — falling back to bun --watch");
+        const subprocess = Bun.spawn(
+          ["bun", "--watch", Bun.main, "serve", "--port", String(port)],
+          {
+            stdin: "inherit",
+            stdout: "inherit",
+            stderr: "inherit",
+            // The port is already settled here, and each --watch restart races
+            // the socket the previous run is still letting go of. Without this
+            // the child would re-prompt on every save.
+            env: { ...Bun.env, [PORT_RESOLVED_ENV_VAR]: "1" },
+          },
+        );
+        await subprocess.exited;
+        return;
+      }
+
+      const orchestrator = new DevOrchestrator(port, process.cwd(), buildHook);
+      await orchestrator.start();
+      return;
+    }
+
+    // ── DEV WORKER (Process 2) ──────────────────────────────────────────────
+    // Normal server start, but:
+    //   1. Registers GET /__dev/events for browser SSE reload.
+    //   2. Reads stdin: when it sees "reload", broadcasts to SSE clients.
+    if (isWorker) {
+      const app = this.app as import("../../application/Application.ts").Application;
+
+      // Enable the /__dev/ws HMR WebSocket endpoint.
+      app.enableDevWs();
+
+      // Listen on stdin for reload signals from the Orchestrator (Process 1).
+      this._listenForReloadSignals();
+
+      // The application logs "Server listening on …" once it binds; announcing it
+      // here as well printed the same fact twice, in two different formats.
+      await app.start(port);
+      await new Promise<never>(() => {});
+      return;
+    }
+
+    // ── PRODUCTION / normal start ────────────────────────────────────────────
+    // Build configured assets once before serving (dev mode builds via the orchestrator).
+    if (assets) await this._buildAssets(assets);
+
+    // Announced after the bind, not before: booting logs its own progress, and a
+    // banner printed first ends up buried above it — worse, it would promise a
+    // URL that a failed bind never makes good on.
+    await (this.app as Application).start(port);
+    this._announce("serve", port);
+    await new Promise<never>(() => {});
+  }
+
+  // ── Private ────────────────────────────────────────────────────────────────
+
+  /**
+   * The banner a starting server prints: the mode, then one URL per way in.
+   *
+   * The server binds every interface (`Bun.serve()` defaults to `0.0.0.0`), so
+   * the network URL is not an invitation to configure anything — it is the
+   * address a phone on the same Wi-Fi can already open, spared the `ipconfig`.
+   */
+  private _announce(mode: string, port: number): void {
+    const network = localNetworkAddress();
+
+    this.newLine();
+    this.line(`  Zerotal  ›  ${mode}`);
+    this.newLine();
+    this._route("Local", `http://localhost:${port}`);
+    this._route(
+      "Network",
+      network ? `http://${network}:${port}` : "unavailable — this machine is on no network",
+    );
+    this.newLine();
+  }
+
+  /** One `label   url` row of the banner: dim label, cyan value. */
+  private _route(label: string, value: string): void {
+    this._writer.writeLine(`  \x1b[2m${label.padEnd(9)}\x1b[0m\x1b[36m${value}\x1b[0m`);
+  }
+
+  /**
+   * Settle which port to actually bind, dealing with a busy one before the
+   * server tries and fails.
+   *
+   * A supervised process — the dev worker, or the `bun --watch` child — is
+   * handed a port that was already resolved by its parent and has no terminal
+   * of its own, so it waits the port out instead of asking. Everyone else gets
+   * the `--force` / `--auto-port` flags, then an interactive menu, then (with no
+   * TTY, e.g. CI or a container) a hard error.
+   */
+  private async _resolvePort(requested: number, isWorker: boolean): Promise<number> {
+    if (await isPortAvailable(requested)) return requested;
+
+    const supervised = isWorker || Bun.env[PORT_RESOLVED_ENV_VAR] === "1";
+    if (supervised) {
+      // A restart, not a collision: the server being replaced is still letting
+      // go of the socket.
+      if (await waitForPort(requested, 3_000)) return requested;
+      throw new Error(`Port ${requested} is still in use. Stop what is holding it and retry.`);
+    }
+
+    const owner = await findPortOwner(requested);
+    const held = `Port ${requested} is already in use${_describe(owner)}.`;
+
+    if (this.flags["force"]) return this._reclaimPort(requested, owner, held);
+    if (this.flags["auto-port"]) return this._nextPort(requested, held);
+
+    if (!process.stdin.isTTY) {
+      throw new Error(
+        `${held} Free it, or pass --port <n>, --force (stop it), or --auto-port (use the next free port).`,
+      );
+    }
+
+    return this._askAboutPort(requested, owner, held);
+  }
+
+  /**
+   * Offer the two ways out of a busy port. The menu is written by hand rather
+   * than with `choice()` because that helper resolves unrecognised input to the
+   * first option, and no typo should end up killing a process.
+   */
+  private async _askAboutPort(
+    requested: number,
+    owner: PortOwner | undefined,
+    held: string,
+  ): Promise<number> {
+    const next = await findAvailablePort(requested + 1);
+
+    this.newLine();
+    this.warn(`  ${held}`);
+    this.dim(`  [1] Stop it and use port ${requested}`);
+    this.dim(next ? `  [2] Use port ${next} instead` : "  [2] Use another port (none free nearby)");
+    this.dim("  [3] Cancel");
+
+    const answer = await this.ask("  Choose", next ? "2" : "3");
+    this.newLine();
+
+    if (answer === "1") return this._reclaimPort(requested, owner, held);
+    if (answer === "2" && next) return next;
+    throw new Error(`${held} Nothing started.`);
+  }
+
+  /** Stop whatever holds the port, then confirm it actually let go. */
+  private async _reclaimPort(
+    port: number,
+    owner: PortOwner | undefined,
+    held: string,
+  ): Promise<number> {
+    if (!owner) {
+      throw new Error(`${held} The process holding it could not be identified — free it manually.`);
+    }
+    // Never turn "free the port" into "kill the CLI asking about it".
+    if (owner.pid === process.pid) {
+      throw new Error(`${held} This process is holding it.`);
+    }
+
+    this.info(`  Stopping ${owner.name ?? "process"} (pid ${owner.pid})...`);
+    const stopped = await stopProcess(owner.pid);
+
+    // Even a successful kill leaves the socket closing, so wait for the port
+    // itself rather than trusting the exit.
+    if (!stopped || !(await waitForPort(port, 3_000))) {
+      throw new Error(
+        `Could not free port ${port} (pid ${owner.pid}). Stop it manually, or pass --port <n>.`,
+      );
+    }
+    return port;
+  }
+
+  /** The next free port after a busy one, for `--auto-port`. */
+  private async _nextPort(requested: number, held: string): Promise<number> {
+    const next = await findAvailablePort(requested + 1);
+    if (next === undefined) throw new Error(`${held} No free port found nearby.`);
+    this.warn(`  ${held} Using port ${next}.`);
+    return next;
+  }
+
+  /** Read the resolved `app.assets` config block, or undefined when not configured. */
+  private _assetsConfig(): AssetBuildConfig | undefined {
+    try {
+      const config = (this.app as Application).container.makeSync("config") as ConfigManager;
+      return config.get("app.assets") as AssetBuildConfig | undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  /** Bundle the configured assets, reporting any build failure (non-fatal — the server still starts). */
+  private async _buildAssets(assets: AssetBuildConfig): Promise<void> {
+    const entries = Array.isArray(assets.entrypoint)
+      ? assets.entrypoint.join(", ")
+      : assets.entrypoint;
+    this.info(`Building assets: ${entries} → ${assets.outDir}/`);
+    const result = await buildConfiguredAssets(assets, process.cwd());
+    if (!result.success) {
+      this.error("Asset build failed:");
+      for (const log of result.logs ?? []) console.error(log);
+    }
+  }
+
+  private _listenForReloadSignals(): void {
+    const readline = createInterface({ input: process.stdin, terminal: false });
+
+    readline.on("line", (line: string) => {
+      const trimmed = line.trim();
+      // The orchestrator sends `reload` or `reload:<assetVersion>`. Update the
+      // asset version (so `asset()` emits a fresh ?v=) before broadcasting.
+      if (trimmed === "reload" || trimmed.startsWith("reload:")) {
+        const version = trimmed.slice("reload:".length);
+        if (version) setAssetVersion(version);
+        DevWsServer.broadcast("reload");
+      }
+    });
+
+    // If stdin closes (the orchestrator died), exit cleanly.
+    readline.on("close", () => process.exit(0));
+  }
+}
+
+/** `" by bun.exe (pid 1234)"`, or `""` when the holder could not be identified. */
+function _describe(owner: PortOwner | undefined): string {
+  if (!owner) return "";
+  return owner.name ? ` by ${owner.name} (pid ${owner.pid})` : ` by pid ${owner.pid}`;
+}

package/src/command/builtin/StartCommand.ts

@@ -0,0 +1,3 @@
+// StartCommand is superseded by ServeCommand (commandName = 'serve', aliases: ['start', 's']).
+// Re-exported for backwards-compatibility with code that imports this class directly.
+export { ServeCommand as StartCommand } from "./ServeCommand.ts";