@hawkeyexl/manni 4.8.1 → 4.10.0

package/dist/cli-LWST5FQH.js

@@ -0,0 +1,839 @@
+#!/usr/bin/env node
+import {
+  launcherCommandLine
+} from "./chunk-ZMECS2IJ.js";
+import {
+  fail
+} from "./chunk-YEUYKR62.js";
+import {
+  FAMILY_CONFIG_NAMES,
+  findConfigFileSync,
+  readConfigFileSync,
+  searchPath
+} from "./chunk-6M5VJOC2.js";
+import {
+  notice,
+  warn
+} from "./chunk-HX44GB4Z.js";
+import "./chunk-QCHVR4ZM.js";
+import {
+  package_default
+} from "./chunk-2BV4FBC7.js";
+import "./chunk-OWBRDNRZ.js";
+import {
+  ToolError,
+  errorMessage
+} from "./chunk-G3T47CFV.js";
+import "./chunk-2H7UOFLK.js";
+
+// src/site/cli.ts
+import { Command } from "commander";
+
+// src/site/core/detect.ts
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join, posix, relative, resolve as resolve2 } from "node:path";
+
+// src/site/errors.ts
+var SiteError = class extends ToolError {
+  constructor(message) {
+    super(message);
+    this.name = "SiteError";
+  }
+};
+
+// src/site/core/config.ts
+import { resolve } from "node:path";
+var SECTION = "site";
+var CONFIG_KEYS = ["dir", "commands"];
+var COMMAND_KEYS = ["start", "build", "preview"];
+var CONFIG_FILE = {
+  section: SECTION,
+  legacyNames: [],
+  toError: (message) => new SiteError(message)
+};
+function loadSiteConfig(cwd, configPath) {
+  const file = configPath === void 0 ? findConfigFileSync(cwd, CONFIG_FILE) : readConfigFileSync(configPath, cwd, CONFIG_FILE);
+  if (file === null) return { commands: {}, collections: [], configDir: null };
+  return {
+    ...parseSiteConfig(file.value, file.source, file.dir),
+    collections: file.collections,
+    configDir: file.dir
+  };
+}
+function parseSiteConfig(value, source, configDir) {
+  const obj = asMapping(value, SECTION, CONFIG_KEYS, source);
+  const config = { commands: {} };
+  if (obj.dir !== void 0) {
+    config.dir = resolve(configDir, asString(obj.dir, "dir", source));
+  }
+  const commands = asMapping(obj.commands, `${SECTION}.commands`, COMMAND_KEYS, source);
+  for (const verb of COMMAND_KEYS) {
+    const command = commands[verb];
+    if (command !== void 0) {
+      const line = asString(command, `commands.${verb}`, source);
+      if (line.trim() === "") {
+        throw new SiteError(`${source}: ${SECTION}.commands.${verb} must not be empty.`);
+      }
+      config.commands[verb] = line;
+    }
+  }
+  return config;
+}
+function asMapping(value, name, keys, source) {
+  if (value == null) return {};
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new SiteError(`${source}: \`${name}:\` must be a mapping.`);
+  }
+  const obj = value;
+  for (const key of Object.keys(obj)) {
+    if (!keys.includes(key)) {
+      throw new SiteError(
+        `${source}: \`${name}:\` has unknown key "${key}". Supported keys: ${keys.join(", ")}.`
+      );
+    }
+  }
+  return obj;
+}
+function asString(value, key, source) {
+  if (typeof value !== "string") {
+    throw new SiteError(`${source}: ${SECTION}.${key} must be a string.`);
+  }
+  return value;
+}
+
+// src/site/core/detect.ts
+var has = (dir, ...parts) => existsSync(join(dir, ...parts));
+var read = (path) => {
+  try {
+    return readFileSync(path, "utf8");
+  } catch {
+    return "";
+  }
+};
+var dep = (name) => (s) => s.deps.has(name) ? name : null;
+var node = (bin, start, build, preview, args = []) => ({
+  start: { script: start, argv: [bin, "dev", ...args] },
+  build: { script: build, argv: [bin, "build", ...args] },
+  preview: { script: preview, argv: [bin, "preview", ...args] }
+});
+var next = () => ({
+  start: { script: "dev", argv: ["next", "dev"] },
+  build: { script: "build", argv: ["next", "build"] },
+  preview: { script: "start", argv: ["next", "start"] }
+});
+function mintlify(s) {
+  if (has(s.dir, "mint.json")) return "mint.json";
+  try {
+    const doc = JSON.parse(read(join(s.dir, "docs.json")));
+    const schema = doc.$schema;
+    const shaped = typeof doc.theme === "string" && typeof doc.navigation === "object" && doc.navigation !== null;
+    if (typeof schema === "string" && schema.includes("mintlify") || shaped) {
+      return "docs.json";
+    }
+  } catch {
+  }
+  return null;
+}
+var zensicalSeen = /* @__PURE__ */ new WeakMap();
+function zensical(s) {
+  const seen = zensicalSeen.get(s);
+  if (seen !== void 0) return seen;
+  const found = zensicalMarker(s);
+  zensicalSeen.set(s, found);
+  return found;
+}
+function zensicalMarker(s) {
+  if (has(s.dir, "zensical.toml")) return "zensical.toml";
+  if (!has(s.dir, "mkdocs.yml")) return null;
+  let files;
+  try {
+    files = readdirSync(s.dir).filter((f) => /^requirements.*\.txt$/.test(f) || f === "pyproject.toml");
+  } catch {
+    return null;
+  }
+  return files.some((f) => /\bzensical\b/.test(read(join(s.dir, f)))) ? "mkdocs.yml" : null;
+}
+var sphinxSource = (s) => has(s.dir, "conf.py") ? "." : "source";
+var FRAMEWORKS = [
+  {
+    name: "Mintlify",
+    marker: mintlify,
+    runner: "path",
+    commands: () => ({ start: { argv: ["mint", "dev"] } }),
+    hostFlag: null,
+    defaultPort: 3e3
+  },
+  {
+    name: "Fern",
+    marker: (s) => has(s.dir, "fern", "fern.config.json") ? "fern/fern.config.json" : null,
+    runner: "path",
+    commands: () => ({ start: { argv: ["fern", "docs", "dev"] } }),
+    hostFlag: null,
+    defaultPort: 3e3
+  },
+  {
+    name: "Starlight",
+    marker: dep("@astrojs/starlight"),
+    runner: "node",
+    pkg: () => "astro",
+    commands: () => node("astro", "dev", "build", "preview"),
+    hostFlag: "--host",
+    defaultPort: 4321
+  },
+  {
+    name: "Docusaurus",
+    marker: dep("@docusaurus/core"),
+    runner: "node",
+    pkg: () => "@docusaurus/core",
+    commands: () => ({
+      start: { script: "start", argv: ["docusaurus", "start"] },
+      build: { script: "build", argv: ["docusaurus", "build"] },
+      preview: { script: "serve", argv: ["docusaurus", "serve"] }
+    }),
+    hostFlag: "--host",
+    defaultPort: 3e3
+  },
+  {
+    name: "VitePress",
+    marker: dep("vitepress"),
+    runner: "node",
+    pkg: () => "vitepress",
+    commands: (s) => node("vitepress", "docs:dev", "docs:build", "docs:preview", has(s.dir, ".vitepress") || !has(s.dir, "docs", ".vitepress") ? [] : ["docs"]),
+    hostFlag: "--host",
+    defaultPort: 5173
+  },
+  {
+    name: "Nextra",
+    marker: dep("nextra"),
+    runner: "node",
+    pkg: () => "next",
+    commands: next,
+    hostFlag: "--hostname",
+    defaultPort: 3e3
+  },
+  {
+    name: "Fumadocs",
+    marker: dep("fumadocs-core"),
+    runner: "node",
+    pkg: () => "next",
+    commands: next,
+    hostFlag: "--hostname",
+    defaultPort: 3e3
+  },
+  {
+    name: "Rspress",
+    marker: (s) => dep("rspress")(s) ?? dep("@rspress/core")(s),
+    runner: "node",
+    pkg: (s) => s.deps.has("rspress") ? "rspress" : "@rspress/core",
+    commands: () => node("rspress", "dev", "build", "preview"),
+    hostFlag: "--host",
+    defaultPort: 3e3
+  },
+  {
+    name: "MkDocs",
+    marker: (s) => has(s.dir, "mkdocs.yml") && zensical(s) === null ? "mkdocs.yml" : null,
+    runner: "python",
+    commands: () => ({ start: { argv: ["mkdocs", "serve"] }, build: { argv: ["mkdocs", "build"] }, out: "site" }),
+    hostFlag: "-a",
+    defaultPort: 8e3
+  },
+  {
+    name: "Zensical",
+    marker: zensical,
+    runner: "python",
+    commands: () => ({ start: { argv: ["zensical", "serve"] }, build: { argv: ["zensical", "build"] }, out: "site" }),
+    hostFlag: "-a",
+    defaultPort: 8e3
+  },
+  {
+    name: "Sphinx",
+    marker: (s) => has(s.dir, "conf.py") ? "conf.py" : has(s.dir, "source", "conf.py") ? "source/conf.py" : null,
+    runner: "python",
+    commands: (s) => {
+      const src = sphinxSource(s);
+      return {
+        start: { argv: ["sphinx-autobuild", src, posix.join(src, "_build", "html")] },
+        build: { argv: ["sphinx-build", "-M", "html", src, posix.join(src, "_build")] },
+        out: posix.join(src, "_build", "html")
+      };
+    },
+    hostFlag: "--host",
+    defaultPort: 8e3
+  },
+  {
+    name: "Hugo",
+    marker: (s) => ["hugo.toml", "hugo.yaml", "hugo.json"].find((f) => has(s.dir, f)) ?? null,
+    runner: "path",
+    commands: () => ({ start: { argv: ["hugo", "server"] }, build: { argv: ["hugo"] }, out: "public" }),
+    hostFlag: "--bind",
+    defaultPort: 1313
+  },
+  {
+    name: "Jekyll",
+    marker: (s) => has(s.dir, "_config.yml") && /\b(jekyll|github-pages)\b/.test(read(join(s.dir, "Gemfile"))) ? "_config.yml" : null,
+    runner: "ruby",
+    commands: () => ({ start: { argv: ["jekyll", "serve"] }, build: { argv: ["jekyll", "build"] }, out: "_site" }),
+    hostFlag: "--host",
+    defaultPort: 4e3
+  }
+];
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+var STATIC_HOST = "127.0.0.1";
+var CONFIG_NAME = FAMILY_CONFIG_NAMES[0] ?? "manni.config.yaml";
+var LOCKFILES = [
+  ["package-lock.json", "npm"],
+  ["npm-shrinkwrap.json", "npm"],
+  ["pnpm-lock.yaml", "pnpm"],
+  ["yarn.lock", "yarn"],
+  ["bun.lock", "bun"],
+  ["bun.lockb", "bun"]
+];
+var EXEC = {
+  npm: ["npx"],
+  pnpm: ["pnpm", "exec"],
+  yarn: ["yarn"],
+  bun: ["bun", "x"]
+};
+function readPackageJson(dir) {
+  const text = read(join(dir, "package.json"));
+  if (text === "") return null;
+  try {
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null ? value : null;
+  } catch {
+    return null;
+  }
+}
+var record = (value) => typeof value === "object" && value !== null ? value : {};
+function siteAt(dir) {
+  const pkg = readPackageJson(dir);
+  return {
+    dir,
+    scripts: record(pkg?.scripts),
+    deps: /* @__PURE__ */ new Set([...Object.keys(record(pkg?.dependencies)), ...Object.keys(record(pkg?.devDependencies))])
+  };
+}
+function packageManager(dir) {
+  const chain = searchPath(dir);
+  for (const d of chain) {
+    const field = readPackageJson(d)?.packageManager;
+    const name = typeof field === "string" ? field.split("@")[0] : void 0;
+    if (name !== void 0 && Object.hasOwn(EXEC, name)) return name;
+  }
+  for (const d of chain) {
+    const hit = LOCKFILES.find(([file]) => has(d, file));
+    if (hit) return hit[1];
+  }
+  return "npm";
+}
+function pythonPrefix(dir) {
+  for (const d of searchPath(dir)) {
+    if (has(d, "uv.lock")) return ["uv", "run"];
+    if (has(d, "poetry.lock")) return ["poetry", "run"];
+  }
+  return [];
+}
+function isDirectory(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function parsePort(raw) {
+  const port = /^\d+$/.test(raw) ? Number(raw) : NaN;
+  if (!(port >= 1 && port <= 65535)) {
+    throw new SiteError(`--port must be an integer from 1 to 65535, got "${raw}".`);
+  }
+  return port;
+}
+function shellQuote(arg) {
+  if (/^[\w@%+=:,./-]+$/.test(arg)) return arg;
+  return process.platform === "win32" ? `"${arg.replace(/"/g, '""')}"` : `'${arg.replace(/'/g, "'\\''")}'`;
+}
+var andList = (items) => items.length <= 1 ? items.join("") : `${items.slice(0, -1).join(", ")} and ${items.at(-1) ?? ""}`;
+function collectionAddress(collections, framework, portFlag) {
+  const local = collections.flatMap((c) => {
+    if (c.url === void 0) return [];
+    const url = new URL(c.url);
+    if (!LOCAL_HOSTS.has(url.hostname)) return [];
+    const port = url.port === "" ? url.protocol === "https:" ? 443 : 80 : Number(url.port);
+    return [{ name: c.name, host: url.hostname.replace(/^\[|\]$/g, ""), port, base: url.pathname }];
+  });
+  const [first] = local;
+  if (first === void 0) return { base: "/" };
+  if (local.some((l) => l.host !== first.host || l.port !== first.port)) {
+    if (!portFlag) {
+      warn(
+        `collections ${andList(local.map((l) => l.name))} name different local URLs. Using ${framework}'s default port; pass --port to pick one.`
+      );
+    }
+    return { base: "/" };
+  }
+  return { ...first, base: sharedPath(local.map((l) => l.base)) };
+}
+function sharedPath(paths) {
+  const split = paths.map((p) => p.split("/").filter((s) => s !== ""));
+  const [head = [], ...rest] = split;
+  const shared = [];
+  for (const [i, segment] of head.entries()) {
+    if (!rest.every((p) => p[i] === segment)) break;
+    shared.push(segment);
+  }
+  return shared.length === 0 ? "/" : `/${shared.join("/")}/`;
+}
+function addressArgs(fw, host, port) {
+  if (fw.hostFlag === "-a") {
+    if (host === void 0 && port === void 0) return [];
+    const h = host ?? STATIC_HOST;
+    return ["-a", `${h.includes(":") ? `[${h}]` : h}:${String(port ?? fw.defaultPort)}`];
+  }
+  return [
+    ...host !== void 0 && fw.hostFlag !== null ? [fw.hostFlag, host] : [],
+    ...port !== void 0 ? ["--port", String(port)] : []
+  ];
+}
+function resolvePlan(verb, opts) {
+  const config = loadSiteConfig(opts.cwd, opts.configPath);
+  const shown = (dir) => {
+    const rel = relative(opts.cwd, dir).replace(/\\/g, "/");
+    return rel === "" ? "./" : `${rel}/`;
+  };
+  const serving = verb === "build" ? null : verb;
+  const flagPort = serving !== null && opts.port !== void 0 ? parsePort(opts.port) : void 0;
+  const flagHost = serving !== null ? opts.host : void 0;
+  if (serving !== null && config.commands[serving] !== void 0) {
+    if (flagPort !== void 0) {
+      throw new SiteError(`--port does not apply to site.commands.${serving}. Put the port in that command.`);
+    }
+    if (flagHost !== void 0) {
+      throw new SiteError(`--host does not apply to site.commands.${serving}. Put the host in that command.`);
+    }
+  }
+  const needed = verb === "preview" ? ["build", "preview"] : [verb];
+  const missing = needed.find((v) => config.commands[v] === void 0);
+  const key = `site.commands.${missing ?? verb} in ${CONFIG_NAME}`;
+  const setIt = `Set ${key}.`;
+  let site;
+  const explicit = opts.dir !== void 0 ? resolve2(opts.cwd, opts.dir) : config.dir;
+  if (explicit !== void 0) {
+    if (!isDirectory(explicit)) throw new SiteError(`${shown(explicit)} does not exist.`);
+    const dir = has(explicit, "fern.config.json") && !has(explicit, "fern", "fern.config.json") ? dirname(explicit) : explicit;
+    site = siteAt(dir);
+  } else {
+    const base = config.configDir ?? resolve2(opts.cwd);
+    const candidates = [base, join(base, "docs"), join(base, "website"), join(base, "site")];
+    for (const dir of candidates) {
+      if (!isDirectory(dir)) continue;
+      const candidate = siteAt(dir);
+      if (FRAMEWORKS.some((fw2) => fw2.marker(candidate) !== null)) {
+        site = candidate;
+        break;
+      }
+    }
+    if (site === void 0) {
+      if (missing !== void 0) {
+        const names = candidates.map(shown);
+        throw new SiteError(
+          `no docs site found in ${names.slice(0, -1).join(", ")} or ${names.at(-1) ?? ""}. Pass the site's directory, or set ${key}.`
+        );
+      }
+      site = siteAt(base);
+    }
+  }
+  const where = shown(site.dir);
+  const found = site;
+  const matches = FRAMEWORKS.flatMap((fw2) => {
+    const marker = fw2.marker(found);
+    return marker === null ? [] : [{ fw: fw2, marker }];
+  });
+  let fw;
+  if (missing !== void 0) {
+    if (matches.length === 0) throw new SiteError(`no docs framework detected in ${where}. ${setIt}`);
+    if (matches.length > 1) {
+      const list = matches.map((m) => `${m.fw.name} (${m.marker})`).join(", ");
+      throw new SiteError(`${where} holds more than one docs site: ${list}. ${setIt}`);
+    }
+    fw = matches[0]?.fw;
+  }
+  const steps = needed.map((v) => {
+    const override = config.commands[v];
+    const isServe = v === serving;
+    const extra = v === verb ? opts.passthrough : [];
+    if (override !== void 0) {
+      const command = [override, ...extra.map(shellQuote)].join(" ");
+      return {
+        announce: `Running site.commands.${v} in ${where}: ${command}`,
+        display: command,
+        notFound: "",
+        step: { kind: "shell", command, cwd: found.dir }
+      };
+    }
+    if (fw === void 0) throw new SiteError(`no docs framework detected in ${where}. ${setIt}`);
+    const cmds = fw.commands(found);
+    const cmd = cmds[v];
+    if (v === "build" && cmd === void 0) {
+      throw new SiteError(`${fw.name} has no local build. Run manni site start, or set site.commands.build.`);
+    }
+    let address = { base: "/" };
+    if (isServe) {
+      if (flagHost !== void 0 && fw.hostFlag === null) {
+        throw new SiteError(`${fw.name}'s dev server takes no host option. Drop --host.`);
+      }
+      const url = collectionAddress(config.collections, fw.name, flagPort !== void 0);
+      address = { host: flagHost ?? url.host, port: flagPort ?? url.port, base: url.base };
+    }
+    if (cmd === void 0) {
+      if (cmds.out === void 0) {
+        throw new SiteError(`${fw.name} has no local preview. Run manni site start, or set site.commands.preview.`);
+      }
+      if (extra.length > 0) {
+        throw new SiteError(`${fw.name} previews through manni's built-in server, which takes no extra arguments. Drop the arguments after --.`);
+      }
+      return {
+        announce: "",
+        display: "",
+        notFound: "",
+        step: {
+          kind: "static",
+          root: join(found.dir, cmds.out),
+          host: address.host ?? STATIC_HOST,
+          port: address.port ?? fw.defaultPort,
+          base: address.base
+        }
+      };
+    }
+    const flags = [...isServe ? addressArgs(fw, address.host, address.port) : [], ...extra];
+    let argv;
+    if (fw.runner === "node") {
+      const pm = packageManager(found.dir);
+      requireInstalled(fw, found, pm, where);
+      argv = cmd.script !== void 0 && cmd.script in found.scripts ? [pm, "run", cmd.script, ...pm === "npm" && flags.length > 0 ? ["--"] : [], ...flags] : [...EXEC[pm], ...cmd.argv, ...flags];
+    } else {
+      const prefix = fw.runner === "python" ? pythonPrefix(found.dir) : fw.runner === "ruby" ? ["bundle", "exec"] : [];
+      argv = [...prefix, ...cmd.argv, ...flags];
+    }
+    const display = argv.join(" ");
+    const bin = argv[0] ?? "";
+    const install = bin === cmd.argv[0] ? `${fw.name}'s CLI` : bin;
+    return {
+      announce: `${fw.name} in ${where}. Running ${display}`,
+      display,
+      notFound: `${bin} not found on PATH. Install ${install}, or set site.commands.${v}.`,
+      step: { kind: "exec", argv, cwd: found.dir }
+    };
+  });
+  return { steps };
+}
+function requireInstalled(fw, site, pm, where) {
+  const pkg = fw.pkg?.(site);
+  if (pkg === void 0) return;
+  const chain = searchPath(site.dir);
+  if (chain.some((d) => has(d, "node_modules", pkg, "package.json"))) return;
+  if (chain.some((d) => has(d, ".pnp.cjs") || has(d, ".pnp.js"))) return;
+  const npmLock = chain.some((d) => has(d, "package-lock.json") || has(d, "npm-shrinkwrap.json"));
+  const install = pm === "npm" ? npmLock ? "npm ci" : "npm install" : `${pm} install`;
+  throw new SiteError(`${pkg} is not installed for ${where}. Run ${install} in ${where} first.`);
+}
+
+// src/site/core/run.ts
+import { spawn } from "node:child_process";
+import { accessSync, constants, statSync as statSync2 } from "node:fs";
+import { delimiter, resolve as resolve4 } from "node:path";
+
+// src/site/core/static-server.ts
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { createServer } from "node:http";
+import { extname, join as join2, relative as relative2, resolve as resolve3, sep } from "node:path";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".wasm": "application/wasm",
+  ".pdf": "application/pdf",
+  ".webmanifest": "application/manifest+json"
+};
+function normalizeBase(base) {
+  const trimmed = base.replace(/^\/+|\/+$/g, "");
+  return trimmed === "" ? "/" : `/${trimmed}/`;
+}
+async function kindOf(path) {
+  try {
+    const s = await stat(path);
+    if (s.isDirectory()) return "dir";
+    return s.isFile() ? "file" : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function sendFile(req, res, path, status = 200) {
+  res.writeHead(status, {
+    "content-type": MIME[extname(path).toLowerCase()] ?? "application/octet-stream"
+  });
+  if (req.method === "HEAD") {
+    res.end();
+    return;
+  }
+  createReadStream(path).on("error", () => res.destroy()).pipe(res);
+}
+function redirect(res, status, location) {
+  res.writeHead(status, { location });
+  res.end();
+}
+function inside(root, rest) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(rest);
+  } catch {
+    return void 0;
+  }
+  if (decoded.includes("\0") || decoded.split(/[\\/]/).includes("..")) return void 0;
+  const path = resolve3(root, `.${sep}${decoded}`);
+  return path === root || path.startsWith(root + sep) ? path : void 0;
+}
+function handler(root, base) {
+  const notFound = join2(root, "404.html");
+  return async (req, res) => {
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      res.writeHead(405, { allow: "GET, HEAD" });
+      res.end();
+      return;
+    }
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const { pathname } = url;
+    if (base !== "/" && (pathname === "/" || pathname === base.slice(0, -1))) {
+      redirect(res, pathname === "/" ? 302 : 301, `${base}${url.search}`);
+      return;
+    }
+    const path = pathname.startsWith(base) ? inside(root, pathname.slice(base.length)) : void 0;
+    const kind = path === void 0 ? void 0 : await kindOf(path);
+    if (path !== void 0 && kind === "dir" && !pathname.endsWith("/")) {
+      redirect(res, 301, `${pathname}/${url.search}`);
+      return;
+    }
+    const file = path !== void 0 && kind === "dir" ? join2(path, "index.html") : path;
+    if (file !== void 0 && await kindOf(file) === "file") {
+      sendFile(req, res, file);
+    } else if (await kindOf(notFound) === "file") {
+      sendFile(req, res, notFound, 404);
+    } else {
+      res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
+      res.end("Not found\n");
+    }
+  };
+}
+function urlOf(host, port, base) {
+  const shown = host.includes(":") ? `[${host}]` : host;
+  return `http://${shown}:${String(port)}${base}`;
+}
+async function startStaticServer(opts) {
+  const root = resolve3(opts.root);
+  if (await kindOf(root) !== "dir") {
+    const shown = relative2(process.cwd(), root).split(sep).join("/") || ".";
+    throw new SiteError(`${shown}/ does not exist.`);
+  }
+  const base = normalizeBase(opts.base);
+  const handle = handler(root, base);
+  const server = createServer((req, res) => {
+    handle(req, res).catch(() => res.destroy());
+  });
+  await new Promise((settle, reject) => {
+    server.once("error", (err) => {
+      reject(
+        new SiteError(
+          err.code === "EADDRINUSE" ? `port ${String(opts.port)} is in use. Pass --port, or stop the process holding it.` : `cannot listen on ${urlOf(opts.host, opts.port, "")}: ${errorMessage(err)}`
+        )
+      );
+    });
+    server.listen(opts.port, opts.host, settle);
+  });
+  const { port } = server.address();
+  process.stdout.write(`${urlOf(opts.host, port, base)}
+`);
+  return server;
+}
+async function serveStatic(opts) {
+  const server = await startStaticServer(opts);
+  await new Promise((settle) => {
+    const stop = () => {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+      server.close(() => {
+        settle();
+      });
+      server.closeAllConnections();
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+  });
+}
+
+// src/site/core/run.ts
+function isExecutable(path) {
+  try {
+    if (!statSync2(path).isFile()) return false;
+    if (process.platform !== "win32") accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findOnPath(name, cwd) {
+  const win = process.platform === "win32";
+  const exts = win ? (process.env["PATHEXT"] ?? ".COM;.EXE;.BAT;.CMD").split(";").filter((e) => e !== "") : [];
+  const lower = name.toLowerCase();
+  const names = win && !exts.some((e) => lower.endsWith(e.toLowerCase())) ? exts.map((e) => name + e) : [name];
+  const dirs = /[\\/]/.test(name) ? [cwd] : (process.env["PATH"] ?? "").split(delimiter).filter((d) => d !== "");
+  for (const dir of dirs) {
+    for (const candidate of names) {
+      const path = resolve4(dir, candidate);
+      if (isExecutable(path)) return path;
+    }
+  }
+  return void 0;
+}
+function startExec(planned, step) {
+  const [name, ...args] = step.argv;
+  const binary = name === void 0 ? void 0 : findOnPath(name, step.cwd);
+  if (binary === void 0) throw new SiteError(planned.notFound);
+  const line = launcherCommandLine(
+    binary,
+    args,
+    (value) => new SiteError(`${planned.display} cannot be given an argument containing a quote: ${value}`)
+  );
+  return spawn(line.command, line.argv, {
+    cwd: step.cwd,
+    stdio: "inherit",
+    windowsVerbatimArguments: line.verbatim
+  });
+}
+function exitOf(planned, child) {
+  return new Promise((settle, reject) => {
+    child.once("error", (err) => {
+      reject(
+        err.code === "ENOENT" ? new SiteError(planned.notFound) : new SiteError(`${planned.display} could not start: ${err.message}`)
+      );
+    });
+    child.once("exit", (code, signal) => {
+      settle({ code, signal });
+    });
+  });
+}
+async function runStep(planned) {
+  const { step } = planned;
+  if (step.kind === "static") {
+    await serveStatic(step);
+    return true;
+  }
+  const child = step.kind === "exec" ? startExec(planned, step) : spawn(step.command, { cwd: step.cwd, stdio: "inherit", shell: true });
+  const signal = { received: false };
+  const onInt = () => {
+    signal.received = true;
+  };
+  const onTerm = () => {
+    signal.received = true;
+    child.kill("SIGTERM");
+  };
+  process.on("SIGINT", onInt);
+  process.on("SIGTERM", onTerm);
+  try {
+    const exit = await exitOf(planned, child);
+    if (signal.received) return true;
+    if (exit.code === 0) return false;
+    throw new SiteError(
+      exit.code === null ? `${planned.display} was stopped by ${String(exit.signal)}.` : `${planned.display} exited with code ${String(exit.code)}.`
+    );
+  } finally {
+    process.off("SIGINT", onInt);
+    process.off("SIGTERM", onTerm);
+  }
+}
+async function runPlan(plan) {
+  for (const planned of plan.steps) {
+    if (planned.announce !== "") notice(planned.announce);
+    if (await runStep(planned)) break;
+  }
+  return 0;
+}
+
+// src/site/commands/run.ts
+async function runSite(verb, opts) {
+  return runPlan(resolvePlan(verb, opts));
+}
+
+// src/site/cli.ts
+function splitOperands(args) {
+  const at = process.argv.indexOf("--");
+  const tail = at === -1 ? [] : process.argv.slice(at + 1);
+  const start = args.length - tail.length;
+  const passthrough = start >= 0 && tail.every((arg, i) => args[start + i] === arg) ? tail : [];
+  const before = args.slice(0, args.length - passthrough.length);
+  return { dir: before[0], passthrough, extra: before.length };
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("site").description("Start, build and preview the docs site").version(package_default.version, "-V, --version").showHelpAfterError("(add --help for usage)").exitOverride();
+  const verb = (name, description, serves) => {
+    const cmd = program.command(name).description(description).argument("[dir]", "the site's directory (default: site.dir, else found by search)").allowExcessArguments();
+    if (serves) {
+      cmd.option("--port <n>", "port, an integer from 1 to 65535 (default: a local collection url, else the framework's)").option("--host <host>", "host to bind (default: a local collection url, else the framework's)");
+    }
+    cmd.option("-c, --config <file>", "path to a manni config file").action(async (_dir, options, self) => {
+      const { dir, passthrough, extra } = splitOperands(self.args);
+      if (extra > 1) {
+        self.error(
+          `error: too many arguments for '${name}'. Expected 1 argument but got ${String(extra)}.`,
+          { code: "commander.excessArguments" }
+        );
+      }
+      try {
+        process.exitCode = await runSite(name, {
+          cwd: process.cwd(),
+          dir,
+          configPath: options.config,
+          port: options.port,
+          host: options.host,
+          passthrough
+        });
+      } catch (err) {
+        fail(err);
+      }
+    });
+  };
+  verb("start", "Run the docs framework's dev server", true);
+  verb("build", "Build the docs site", false);
+  verb("preview", "Build the docs site, then serve the output", true);
+  program.addHelpText(
+    "after",
+    [
+      "",
+      "Examples:",
+      "  manni site start                      # detect the framework, run its dev server",
+      "  manni site build",
+      "  manni site preview --port 4000        # build, then serve the output",
+      "  manni site start website -- --open    # arguments after -- go to the framework"
+    ].join("\n")
+  );
+  return program;
+}
+export {
+  buildProgram
+};
+//# sourceMappingURL=cli-LWST5FQH.js.map