@dnax/serve 0.0.0-stage → 0.0.1

package/src/cli.ts

@@ -0,0 +1,594 @@
+#!/usr/bin/env bun
+
+import { statSync } from "node:fs";
+import { networkInterfaces } from "node:os";
+import { startStaticServer, type ServeOptions } from "./server.ts";
+
+type Value = string | boolean | string[];
+
+interface ParsedArgs {
+  values: Map<string, Value>;
+  positionals: string[];
+  unknown: string[];
+}
+
+const SHORT: Readonly<Record<string, string>> = {
+  p: "port",
+  a: "address",
+  d: "showDir",
+  i: "autoIndex",
+  g: "gzip",
+  b: "brotli",
+  e: "ext",
+  s: "silent",
+  o: "open",
+  c: "cache",
+  t: "timeout",
+  T: "title",
+  U: "utc",
+  P: "proxy",
+  S: "tls",
+  C: "cert",
+  K: "key",
+  r: "robots",
+  H: "header",
+  v: "version",
+  h: "help",
+};
+
+const ALIASES: Readonly<Record<string, string>> = {
+  dir: "showDir",
+  "auto-index": "autoIndex",
+  "base-dir": "baseDir",
+  "dir-overrides-404": "dirOverrides404",
+  "private-network-access": "privateNetworkAccess",
+  "log-ip": "logIp",
+  "hide-permissions": "hidePermissions",
+  "proxy-all": "proxyAll",
+  ssl: "tls",
+  user: "username",
+  "allowed-hosts": "allowedHosts",
+};
+
+const BOOLEAN_KEYS = new Set([
+  "showDir",
+  "autoIndex",
+  "gzip",
+  "brotli",
+  "silent",
+  "coop",
+  "privateNetworkAccess",
+  "utc",
+  "logIp",
+  "robots",
+  "dotfiles",
+  "dirOverrides404",
+  "hidePermissions",
+  "proxyAll",
+  "tls",
+  "help",
+  "version",
+  "panic",
+]);
+
+const OPTIONAL_VALUE_KEYS = new Set(["cors", "open"]);
+
+const VALUE_KEYS = new Set([
+  "port",
+  "address",
+  "baseDir",
+  "ext",
+  "cache",
+  "timeout",
+  "title",
+  "proxy",
+  "username",
+  "password",
+  "cert",
+  "key",
+  "header",
+  "mimetypes",
+  "allowedHosts",
+]);
+
+function normalizeKey(key: string): string {
+  return ALIASES[key] ?? key;
+}
+
+function parseBoolean(value: string): boolean {
+  return value !== "false";
+}
+
+function parseArgv(argv: string[]): ParsedArgs {
+  const values = new Map<string, Value>();
+  const positionals: string[] = [];
+  const unknown: string[] = [];
+
+  const setValue = (key: string, value: Value): void => {
+    if (key === "header" && typeof value === "string") {
+      const existing = values.get("header");
+      if (Array.isArray(existing)) existing.push(value);
+      else if (typeof existing === "string") values.set("header", [existing, value]);
+      else values.set("header", [value]);
+      return;
+    }
+    values.set(key, value);
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === undefined) continue;
+
+    if (arg === "--") {
+      positionals.push(...argv.slice(index + 1));
+      break;
+    }
+
+    if (arg.startsWith("--")) {
+      let name = arg.slice(2);
+      let inline: string | undefined;
+      const equals = name.indexOf("=");
+      if (equals !== -1) {
+        inline = name.slice(equals + 1);
+        name = name.slice(0, equals);
+      }
+
+      let negated = false;
+      if (name.startsWith("no-")) {
+        negated = true;
+        name = name.slice(3);
+      }
+
+      const key = normalizeKey(name);
+
+      if (negated) {
+        values.set(key, false);
+        continue;
+      }
+
+      if (BOOLEAN_KEYS.has(key)) {
+        const next = argv[index + 1];
+        if (inline !== undefined) values.set(key, parseBoolean(inline));
+        else if (next === "true" || next === "false") {
+          values.set(key, parseBoolean(next));
+          index += 1;
+        } else values.set(key, true);
+        continue;
+      }
+
+      if (OPTIONAL_VALUE_KEYS.has(key)) {
+        values.set(key, inline ?? true);
+        continue;
+      }
+
+      if (VALUE_KEYS.has(key)) {
+        if (inline !== undefined) {
+          setValue(key, inline);
+        } else {
+          const next = argv[index + 1];
+          if (next !== undefined) {
+            setValue(key, next);
+            index += 1;
+          } else {
+            setValue(key, true);
+          }
+        }
+        continue;
+      }
+
+      unknown.push(arg);
+      const next = argv[index + 1];
+      if (inline === undefined && next !== undefined && !next.startsWith("-")) index += 1;
+      continue;
+    }
+
+    if (arg.startsWith("-") && arg.length > 1) {
+      let offset = 1;
+      while (offset < arg.length) {
+        const character = arg[offset] ?? "";
+        const key = normalizeKey(SHORT[character] ?? character);
+        const known = BOOLEAN_KEYS.has(key) || OPTIONAL_VALUE_KEYS.has(key) || VALUE_KEYS.has(key);
+
+        if (!known) {
+          unknown.push(`-${character}`);
+          offset += 1;
+          continue;
+        }
+
+        if (BOOLEAN_KEYS.has(key)) {
+          const next = argv[index + 1];
+          if (next === "true" || next === "false") {
+            values.set(key, parseBoolean(next));
+            index += 1;
+          } else {
+            values.set(key, true);
+          }
+          offset += 1;
+          continue;
+        }
+
+        if (OPTIONAL_VALUE_KEYS.has(key)) {
+          const rest = arg.slice(offset + 1).replace(/^=/, "");
+          if (rest) {
+            setValue(key, rest);
+          } else {
+            const next = argv[index + 1];
+            if (
+              key === "open" &&
+              next !== undefined &&
+              !next.startsWith("-") &&
+              (next.startsWith("/") || /^https?:\/\//i.test(next))
+            ) {
+              setValue(key, next);
+              index += 1;
+            } else {
+              values.set(key, true);
+            }
+          }
+          offset = arg.length;
+          continue;
+        }
+
+        let rest = arg.slice(offset + 1);
+        if (rest.startsWith("=")) rest = rest.slice(1);
+        if (rest) {
+          setValue(key, rest);
+        } else {
+          const next = argv[index + 1];
+          if (next !== undefined) {
+            setValue(key, next);
+            index += 1;
+          } else {
+            setValue(key, true);
+          }
+        }
+        offset = arg.length;
+      }
+      continue;
+    }
+
+    positionals.push(arg);
+  }
+
+  return { values, positionals, unknown };
+}
+
+function boolValue(values: Map<string, Value>, key: string, fallback: boolean): boolean {
+  const value = values.get(key);
+  if (value === undefined) return fallback;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") return value !== "false";
+  return true;
+}
+
+function stringValue(values: Map<string, Value>, key: string): string | undefined {
+  const value = values.get(key);
+  if (value === undefined) return undefined;
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.at(-1);
+  return undefined;
+}
+
+function numberValue(
+  values: Map<string, Value>,
+  key: string,
+  label: string,
+): number | undefined {
+  const value = values.get(key);
+  if (value === undefined || value === true) return undefined;
+  const raw = Array.isArray(value) ? value.at(-1) : value;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) throw new Error(`Invalid ${label}: ${String(raw)}`);
+  return parsed;
+}
+
+function headersValue(values: Map<string, Value>): Record<string, string> {
+  const value = values.get("header");
+  const entries = Array.isArray(value) ? value : typeof value === "string" ? [value] : [];
+  const headers: Record<string, string> = {};
+  for (const entry of entries) {
+    const separator = entry.indexOf(":");
+    if (separator === -1) {
+      process.stderr.write(`Warning: ignoring malformed header "${entry}" (expected "Name: value")\n`);
+      continue;
+    }
+    headers[entry.slice(0, separator).trim()] = entry.slice(separator + 1).trim();
+  }
+  return headers;
+}
+
+function directoryExists(path: string): boolean {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function displayRoot(root: string): string {
+  return root;
+}
+
+function formatTimeout(timeout: number): string {
+  return timeout === 0 ? "disabled" : `${timeout} seconds`;
+}
+
+function formatCache(cache: number | undefined): string {
+  if (cache === undefined) return "3600 seconds";
+  return cache === -1 ? "disabled" : `${cache} seconds`;
+}
+
+function colorize(): (code: number, text: string) => string {
+  const enabled = process.stdout.isTTY === true && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+  return (code, text) => (enabled ? `\u001b[${code}m${text}\u001b[0m` : text);
+}
+
+function availableUrls(address: string, port: number, protocol: string): string[] {
+  if (address !== "0.0.0.0" && address !== "::" && address !== "") {
+    return [`${protocol}://${address}:${port}`];
+  }
+  const urls = new Set<string>([`${protocol}://127.0.0.1:${port}`]);
+  const interfaces = networkInterfaces();
+  for (const entries of Object.values(interfaces)) {
+    for (const entry of entries ?? []) {
+      if (entry.family === "IPv4" && !entry.internal) {
+        urls.add(`${protocol}://${entry.address}:${port}`);
+      }
+    }
+  }
+  return [...urls];
+}
+
+function openBrowser(url: string): void {
+  const command =
+    process.platform === "darwin"
+      ? ["open", url]
+      : process.platform === "win32"
+        ? ["cmd", "/c", "start", "", url]
+        : ["xdg-open", url];
+  try {
+    Bun.spawn(command, { stdio: ["ignore", "ignore", "ignore"] });
+  } catch {
+    // Opening the browser is best-effort.
+  }
+}
+
+const HELP = `usage: dnx serve [path] [options]
+
+A Bun static file server compatible with the http-server CLI.
+
+The "serve" subcommand is optional: "dnx [path] [options]" also works.
+
+options:
+  -p --port         Port to use. If 0, look for an open port starting at 8080. [8080]
+  -a --address      Address to use [0.0.0.0]
+  --base-dir        Base path to serve files from [/]
+  -d --dir          Show directory listings [true]
+  -i --autoIndex    Display index.html for directories [true]
+  --dir-overrides-404  Let -d override the magic 404.html file [false]
+  -g --gzip         Serve precompressed .gz files when accepted [false]
+  -b --brotli       Serve precompressed .br files when accepted [false]
+                    If both are enabled, brotli takes precedence.
+  -e --ext          Default file extension if none supplied [html]
+  -s --silent       Suppress log messages from output
+  --cors[=headers]  Enable CORS via the Access-Control-Allow-Origin header.
+                    Optionally provide extra allowed headers, comma separated.
+  --coop            Enable Cross-Origin-Opener-Policy: same-origin
+  --private-network-access  Enable Private Network Access
+  -H --header       Add an extra response header (may be repeated), e.g. -H "X-Foo: bar"
+  -o [path]         Open the browser after starting the server.
+  -c --cache        Cache time (max-age) in seconds [3600], e.g. -c10 or -c-1 to disable
+  -t --timeout      Connection idle timeout in seconds [120], 0 to disable
+  -T --title        Extra text for the terminal title
+  -U --utc          Use UTC time format in log messages
+  --log-ip          Include the client IP in log messages
+  -P --proxy        Fallback proxy for requests that cannot be resolved, e.g. http://localhost:3000
+  --proxy-all       Forward every request to the proxy
+  --username        Username for basic authentication (env: NODE_HTTP_SERVER_USERNAME)
+  --password        Password for basic authentication (env: NODE_HTTP_SERVER_PASSWORD)
+  -S --tls --ssl    Enable secure request serving with TLS/SSL (HTTPS)
+  -C --cert         Path to the TLS certificate file [cert.pem]
+  -K --key          Path to the TLS key file [key.pem]
+  -r --robots       Respond to /robots.txt with "User-agent: *\\nDisallow: /"
+  --no-dotfiles     Do not serve dotfiles
+  --hide-permissions  Hide permissions in directory listings
+  --mimetypes       Path to a .types file (or inline JSON) for custom MIME types
+  --allowed-hosts   Comma separated hosts allowed to access the server
+  -h --help         Print this list and exit
+  -v --version      Print the version and exit
+
+Magic files: index.<ext> is served for directories and 404.<ext> for not found.
+`;
+
+async function readVersion(): Promise<string> {
+  try {
+    const pkg = (await Bun.file(new URL("../package.json", import.meta.url)).json()) as { version?: string };
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+async function main(): Promise<void> {
+  const rawArgs = process.argv.slice(2);
+  const argv = rawArgs[0] === "serve" ? rawArgs.slice(1) : rawArgs;
+  const parsed = parseArgv(argv);
+  const paint = colorize();
+  const yellow = (text: string) => paint(33, text);
+  const cyan = (text: string) => paint(36, text);
+  const green = (text: string) => paint(32, text);
+  const red = (text: string) => paint(31, text);
+
+  for (const flag of parsed.unknown) {
+    process.stderr.write(`Warning: ignoring unknown option ${flag}\n`);
+  }
+
+  if (boolValue(parsed.values, "help", false)) {
+    process.stdout.write(HELP);
+    return;
+  }
+
+  const version = await readVersion();
+  if (boolValue(parsed.values, "version", false)) {
+    process.stdout.write(`v${version}\n`);
+    return;
+  }
+
+  const portValue = parsed.values.get("port");
+  let port: number;
+  if (portValue === undefined) {
+    const envPort = process.env.PORT ? Number(process.env.PORT) : NaN;
+    port = Number.isInteger(envPort) ? envPort : 8080;
+  } else if (portValue === true) {
+    port = 8080;
+  } else {
+    port = Number(Array.isArray(portValue) ? portValue.at(-1) : portValue);
+  }
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error(`Invalid port: ${String(portValue)}`);
+  }
+
+  const address = stringValue(parsed.values, "address") ?? "0.0.0.0";
+  const cache = numberValue(parsed.values, "cache", "cache time");
+  const timeout = numberValue(parsed.values, "timeout", "connection timeout");
+  const extValue = parsed.values.get("ext");
+  const ext = typeof extValue === "string" ? extValue : undefined;
+
+  const rootArgument = parsed.positionals[0];
+  const root = rootArgument ?? (directoryExists("public") ? "./public" : "./");
+
+  const tls = boolValue(parsed.values, "tls", false);
+  const username = stringValue(parsed.values, "username") ?? process.env.NODE_HTTP_SERVER_USERNAME;
+  const password = stringValue(parsed.values, "password") ?? process.env.NODE_HTTP_SERVER_PASSWORD;
+  const proxy = stringValue(parsed.values, "proxy");
+  const robotsValue = parsed.values.get("robots");
+  const robots: boolean | string =
+    robotsValue === true
+      ? true
+      : typeof robotsValue === "string"
+        ? robotsValue === "true"
+          ? true
+          : robotsValue === "false"
+            ? false
+            : robotsValue
+        : false;
+
+  const corsValue = parsed.values.get("cors");
+  const cors: boolean | string = typeof corsValue === "string" ? corsValue : corsValue === true;
+
+  const allowedHosts = (stringValue(parsed.values, "allowedHosts") ?? "")
+    .split(",")
+    .map((host) => host.trim())
+    .filter(Boolean);
+
+  const options: ServeOptions = {
+    root,
+    port,
+    address,
+    baseDir: stringValue(parsed.values, "baseDir"),
+    showDir: boolValue(parsed.values, "showDir", true),
+    autoIndex: boolValue(parsed.values, "autoIndex", true),
+    dirOverrides404: boolValue(parsed.values, "dirOverrides404", false),
+    gzip: boolValue(parsed.values, "gzip", false),
+    brotli: boolValue(parsed.values, "brotli", false),
+    ext,
+    silent: boolValue(parsed.values, "silent", false),
+    cors,
+    coop: boolValue(parsed.values, "coop", false),
+    privateNetworkAccess: boolValue(parsed.values, "privateNetworkAccess", false),
+    headers: headersValue(parsed.values),
+    cache,
+    timeout,
+    utc: boolValue(parsed.values, "utc", false),
+    logIp: boolValue(parsed.values, "logIp", false),
+    proxy,
+    proxyAll: boolValue(parsed.values, "proxyAll", false),
+    username,
+    password,
+    ssl: tls,
+    cert: stringValue(parsed.values, "cert"),
+    key: stringValue(parsed.values, "key"),
+    robots,
+    dotfiles: boolValue(parsed.values, "dotfiles", true),
+    mimetypes: stringValue(parsed.values, "mimetypes"),
+    hidePermissions: boolValue(parsed.values, "hidePermissions", false),
+    allowedHosts,
+  };
+
+  const title = stringValue(parsed.values, "title");
+  const openValue = parsed.values.get("open");
+
+  let started: Awaited<ReturnType<typeof startStaticServer>>;
+  try {
+    started = await startStaticServer(options);
+  } catch (error) {
+    process.stderr.write(`${red("Error:")} ${(error as Error).message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const resolved = started.options;
+  const protocol = resolved.ssl ? "https" : "http";
+  const silent = resolved.silent;
+
+  process.title = `dnx ${started.port}${title ? ` ${title}` : ""}`;
+  if (title && process.stdout.isTTY) {
+    process.stdout.write(`\u001b]0;dnx ${started.port} ${title}\u0007`);
+  }
+
+  if (!silent) {
+    const lines: string[] = [];
+    lines.push(
+      `${yellow("Starting up dnx, serving")} ${cyan(displayRoot(root))}${
+        resolved.ssl ? ` ${yellow("through")} ${cyan("https")}` : ""
+      }`,
+    );
+    lines.push("");
+    lines.push(`${yellow("dnx version:")} ${cyan(version)}`);
+    lines.push("");
+    lines.push(yellow("dnx settings:"));
+    lines.push(`CORS: ${resolved.cors ? cyan(resolved.corsHeaders ?? "enabled") : red("disabled")}`);
+    lines.push(`Cache: ${resolved.cache === -1 ? red("disabled") : cyan(formatCache(resolved.cache))}`);
+    lines.push(`Connection Timeout: ${resolved.timeout === 0 ? red("disabled") : cyan(formatTimeout(resolved.timeout))}`);
+    lines.push(`Directory Listings: ${resolved.showDir ? cyan("visible") : red("not visible")}`);
+    lines.push(`AutoIndex: ${resolved.autoIndex ? cyan("visible") : red("not visible")}`);
+    lines.push(`Serve GZIP Files: ${resolved.gzip ? cyan("true") : red("false")}`);
+    lines.push(`Serve Brotli Files: ${resolved.brotli ? cyan("true") : red("false")}`);
+    lines.push(`Default File Extension: ${cyan(resolved.ext)}`);
+    if (resolved.ssl) lines.push(`TLS: ${cyan("enabled")} (${resolved.cert})`);
+    if (resolved.username !== undefined || resolved.password !== undefined) {
+      lines.push(`Basic Authentication: ${cyan("enabled")}`);
+    }
+    if (resolved.proxy) {
+      lines.push(`Proxy fallback: ${cyan(resolved.proxy)}${resolved.proxyAll ? " (all requests)" : ""}`);
+    }
+    lines.push("");
+    lines.push(yellow("Available on:"));
+    for (const url of availableUrls(resolved.address, started.port, protocol)) {
+      lines.push(`  ${green(url)}`);
+    }
+    lines.push("Hit CTRL-C to stop the server");
+    process.stdout.write(`${lines.join("\n")}\n\n`);
+
+    if (openValue !== undefined && openValue !== false) {
+      const openHost = resolved.address === "0.0.0.0" || resolved.address === "::" ? "127.0.0.1" : resolved.address;
+      let openUrl = `${protocol}://${openHost}:${started.port}`;
+      if (typeof openValue === "string") {
+        openUrl += openValue.startsWith("/") ? openValue : `/${openValue}`;
+      }
+      process.stdout.write(`Open: ${openUrl}\n`);
+      openBrowser(openUrl);
+    }
+  }
+
+  const shutdown = (): void => {
+    if (!silent) process.stdout.write(`${red("dnx stopped.")}\n`);
+    started.stop();
+    process.exit(0);
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+
+await main();