comarkserv 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,894 @@
+#!/usr/bin/env node
+import { O as relative, T as dirname, k as resolve, r as createThemeStore, t as OMARCHY_CURRENT, u as findReadme, w as basename } from "./themes-mEufQ_3e.mjs";
+import { o as CLOUDFLARE_LINKS, r as startServer, s as isCloudflaredInstalled, t as DEFAULT_PORT } from "./server-Dkjk_D1Y.mjs";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { networkInterfaces } from "node:os";
+import { parseArgs, styleText } from "node:util";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+//#region node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/_chunks/libs/scule.mjs
+const NUMBER_CHAR_RE = /\d/;
+const STR_SPLITTERS = [
+	"-",
+	"_",
+	"/",
+	"."
+];
+function isUppercase(char = "") {
+	if (NUMBER_CHAR_RE.test(char)) return;
+	return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+	const splitters = separators ?? STR_SPLITTERS;
+	const parts = [];
+	if (!str || typeof str !== "string") return parts;
+	let buff = "";
+	let previousUpper;
+	let previousSplitter;
+	for (const char of str) {
+		const isSplitter = splitters.includes(char);
+		if (isSplitter === true) {
+			parts.push(buff);
+			buff = "";
+			previousUpper = void 0;
+			continue;
+		}
+		const isUpper = isUppercase(char);
+		if (previousSplitter === false) {
+			if (previousUpper === false && isUpper === true) {
+				parts.push(buff);
+				buff = char;
+				previousUpper = isUpper;
+				continue;
+			}
+			if (previousUpper === true && isUpper === false && buff.length > 1) {
+				const lastChar = buff.at(-1);
+				parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+				buff = lastChar + char;
+				previousUpper = isUpper;
+				continue;
+			}
+		}
+		buff += char;
+		previousUpper = isUpper;
+		previousSplitter = isSplitter;
+	}
+	parts.push(buff);
+	return parts;
+}
+function upperFirst(str) {
+	return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+	return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function pascalCase(str, opts) {
+	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
+}
+function camelCase(str, opts) {
+	return lowerFirst(pascalCase(str || "", opts));
+}
+function kebabCase(str, joiner) {
+	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+}
+function snakeCase(str) {
+	return kebabCase(str || "", "_");
+}
+//#endregion
+//#region node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/index.mjs
+function toArray(val) {
+	if (Array.isArray(val)) return val;
+	return val === void 0 ? [] : [val];
+}
+function formatLineColumns(lines, linePrefix = "") {
+	const maxLength = [];
+	for (const line of lines) for (const [i, element] of line.entries()) maxLength[i] = Math.max(maxLength[i] || 0, element.length);
+	return lines.map((l) => l.map((c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLength[i])).join("  ")).join("\n");
+}
+function resolveValue(input) {
+	return typeof input === "function" ? input() : input;
+}
+var CLIError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.name = "CLIError";
+		this.code = code;
+	}
+};
+function parseRawArgs(args = [], opts = {}) {
+	const booleans = new Set(opts.boolean || []);
+	const strings = new Set(opts.string || []);
+	const aliasMap = opts.alias || {};
+	const defaults = opts.default || {};
+	const aliasToMain = /* @__PURE__ */ new Map();
+	const mainToAliases = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(aliasMap)) {
+		const targets = value;
+		for (const target of targets) {
+			aliasToMain.set(key, target);
+			if (!mainToAliases.has(target)) mainToAliases.set(target, []);
+			mainToAliases.get(target).push(key);
+			aliasToMain.set(target, key);
+			if (!mainToAliases.has(key)) mainToAliases.set(key, []);
+			mainToAliases.get(key).push(target);
+		}
+	}
+	const options = {};
+	function getType(name) {
+		if (booleans.has(name)) return "boolean";
+		const aliases = mainToAliases.get(name) || [];
+		for (const alias of aliases) if (booleans.has(alias)) return "boolean";
+		return "string";
+	}
+	function isStringType(name) {
+		if (strings.has(name)) return true;
+		const aliases = mainToAliases.get(name) || [];
+		for (const alias of aliases) if (strings.has(alias)) return true;
+		return false;
+	}
+	const allOptions = /* @__PURE__ */ new Set([
+		...booleans,
+		...strings,
+		...Object.keys(aliasMap),
+		...Object.values(aliasMap).flat(),
+		...Object.keys(defaults)
+	]);
+	for (const name of allOptions) if (!options[name]) options[name] = {
+		type: getType(name),
+		default: defaults[name]
+	};
+	for (const [alias, main] of aliasToMain.entries()) if (alias.length === 1 && options[main] && !options[main].short) options[main].short = alias;
+	const processedArgs = [];
+	const negatedFlags = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--") {
+			processedArgs.push(...args.slice(i));
+			break;
+		}
+		if (arg.startsWith("--no-")) {
+			const flagName = arg.slice(5);
+			negatedFlags[flagName] = true;
+			continue;
+		}
+		processedArgs.push(arg);
+	}
+	let parsed;
+	try {
+		parsed = parseArgs({
+			args: processedArgs,
+			options: Object.keys(options).length > 0 ? options : void 0,
+			allowPositionals: true,
+			strict: false
+		});
+	} catch {
+		parsed = {
+			values: {},
+			positionals: processedArgs
+		};
+	}
+	const out = { _: [] };
+	out._ = parsed.positionals;
+	for (const [key, value] of Object.entries(parsed.values)) {
+		let coerced = value;
+		if (getType(key) === "boolean" && typeof value === "string") coerced = value !== "false";
+		else if (isStringType(key) && typeof value === "boolean") coerced = "";
+		out[key] = coerced;
+	}
+	for (const [name] of Object.entries(negatedFlags)) {
+		out[name] = false;
+		const mainName = aliasToMain.get(name);
+		if (mainName) out[mainName] = false;
+		const aliases = mainToAliases.get(name);
+		if (aliases) for (const alias of aliases) out[alias] = false;
+	}
+	for (const [alias, main] of aliasToMain.entries()) {
+		if (out[alias] !== void 0 && out[main] === void 0) out[main] = out[alias];
+		if (out[main] !== void 0 && out[alias] === void 0) out[alias] = out[main];
+		if (out[alias] !== out[main] && defaults[main] === out[main]) out[main] = out[alias];
+	}
+	return out;
+}
+const noColor = /* @__PURE__ */ (() => {
+	const env = globalThis.process?.env ?? {};
+	return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
+})();
+const _c = (c, r = 39) => (t) => noColor ? t : `\u001B[${c}m${t}\u001B[${r}m`;
+const bold = /* @__PURE__ */ _c(1, 22);
+const cyan = /* @__PURE__ */ _c(36);
+const gray = /* @__PURE__ */ _c(90);
+const underline = /* @__PURE__ */ _c(4, 24);
+function parseArgs$1(rawArgs, argsDef) {
+	const parseOptions = {
+		boolean: [],
+		string: [],
+		alias: {},
+		default: {}
+	};
+	const args = resolveArgs(argsDef);
+	for (const arg of args) {
+		if (arg.type === "positional") continue;
+		if (arg.type === "string" || arg.type === "enum") parseOptions.string.push(arg.name);
+		else if (arg.type === "boolean") parseOptions.boolean.push(arg.name);
+		if (arg.default !== void 0) parseOptions.default[arg.name] = arg.default;
+		if (arg.alias) parseOptions.alias[arg.name] = arg.alias;
+		const camelName = camelCase(arg.name);
+		const kebabName = kebabCase(arg.name);
+		if (camelName !== arg.name || kebabName !== arg.name) {
+			const existingAliases = toArray(parseOptions.alias[arg.name] || []);
+			if (camelName !== arg.name && !existingAliases.includes(camelName)) existingAliases.push(camelName);
+			if (kebabName !== arg.name && !existingAliases.includes(kebabName)) existingAliases.push(kebabName);
+			if (existingAliases.length > 0) parseOptions.alias[arg.name] = existingAliases;
+		}
+	}
+	const parsed = parseRawArgs(rawArgs, parseOptions);
+	const [ ...positionalArguments] = parsed._;
+	const parsedArgsProxy = new Proxy(parsed, { get(target, prop) {
+		return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+	} });
+	for (const [, arg] of args.entries()) if (arg.type === "positional") {
+		const nextPositionalArgument = positionalArguments.shift();
+		if (nextPositionalArgument !== void 0) parsedArgsProxy[arg.name] = nextPositionalArgument;
+		else if (arg.default === void 0 && arg.required !== false) throw new CLIError(`Missing required positional argument: ${arg.name.toUpperCase()}`, "EARG");
+		else parsedArgsProxy[arg.name] = arg.default;
+	} else if (arg.type === "enum") {
+		const argument = parsedArgsProxy[arg.name];
+		const options = arg.options || [];
+		if (argument !== void 0 && options.length > 0 && !options.includes(argument)) throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o) => cyan(o)).join(", ")}.`, "EARG");
+	} else if (arg.required && parsedArgsProxy[arg.name] === void 0) throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+	return parsedArgsProxy;
+}
+function resolveArgs(argsDef) {
+	const args = [];
+	for (const [name, argDef] of Object.entries(argsDef || {})) args.push({
+		...argDef,
+		name,
+		alias: toArray(argDef.alias)
+	});
+	return args;
+}
+async function resolvePlugins(plugins) {
+	return Promise.all(plugins.map((p) => resolveValue(p)));
+}
+function defineCommand(def) {
+	return def;
+}
+async function runCommand(cmd, opts) {
+	const cmdArgs = await resolveValue(cmd.args || {});
+	const parsedArgs = parseArgs$1(opts.rawArgs, cmdArgs);
+	const context = {
+		rawArgs: opts.rawArgs,
+		args: parsedArgs,
+		data: opts.data,
+		cmd
+	};
+	const plugins = await resolvePlugins(cmd.plugins ?? []);
+	let result;
+	let runError;
+	try {
+		for (const plugin of plugins) await plugin.setup?.(context);
+		if (typeof cmd.setup === "function") await cmd.setup(context);
+		const subCommands = await resolveValue(cmd.subCommands);
+		if (subCommands && Object.keys(subCommands).length > 0) {
+			const subCommandArgIndex = findSubCommandIndex(opts.rawArgs, cmdArgs);
+			const explicitName = opts.rawArgs[subCommandArgIndex];
+			if (explicitName) {
+				const subCommand = await _findSubCommand(subCommands, explicitName);
+				if (!subCommand) throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
+				await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+			} else {
+				const defaultSubCommand = await resolveValue(cmd.default);
+				if (defaultSubCommand) {
+					if (cmd.run) throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
+					const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
+					if (!subCommand) throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
+					await runCommand(subCommand, { rawArgs: opts.rawArgs });
+				} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+			}
+		}
+		if (typeof cmd.run === "function") result = await cmd.run(context);
+	} catch (error) {
+		runError = error;
+	}
+	const cleanupErrors = [];
+	if (typeof cmd.cleanup === "function") try {
+		await cmd.cleanup(context);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	for (const plugin of [...plugins].reverse()) try {
+		await plugin.cleanup?.(context);
+	} catch (error) {
+		cleanupErrors.push(error);
+	}
+	if (runError) throw runError;
+	if (cleanupErrors.length === 1) throw cleanupErrors[0];
+	if (cleanupErrors.length > 1) throw new Error("Multiple cleanup errors", { cause: cleanupErrors });
+	return { result };
+}
+async function resolveSubCommand(cmd, rawArgs, parent) {
+	const subCommands = await resolveValue(cmd.subCommands);
+	if (subCommands && Object.keys(subCommands).length > 0) {
+		const subCommandArgIndex = findSubCommandIndex(rawArgs, await resolveValue(cmd.args || {}));
+		const subCommandName = rawArgs[subCommandArgIndex];
+		const subCommand = await _findSubCommand(subCommands, subCommandName);
+		if (subCommand) return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
+	}
+	return [cmd, parent];
+}
+async function _findSubCommand(subCommands, name) {
+	if (name in subCommands) return resolveValue(subCommands[name]);
+	for (const sub of Object.values(subCommands)) {
+		const resolved = await resolveValue(sub);
+		const meta = await resolveValue(resolved?.meta);
+		if (meta?.alias) {
+			if (toArray(meta.alias).includes(name)) return resolved;
+		}
+	}
+}
+function findSubCommandIndex(rawArgs, argsDef) {
+	for (let i = 0; i < rawArgs.length; i++) {
+		const arg = rawArgs[i];
+		if (arg === "--") return -1;
+		if (arg.startsWith("-")) {
+			if (!arg.includes("=") && _isValueFlag(arg, argsDef)) i++;
+			continue;
+		}
+		return i;
+	}
+	return -1;
+}
+function _isValueFlag(flag, argsDef) {
+	const name = flag.replace(/^-{1,2}/, "");
+	const normalized = camelCase(name);
+	for (const [key, def] of Object.entries(argsDef)) {
+		if (def.type !== "string" && def.type !== "enum") continue;
+		if (normalized === camelCase(key)) return true;
+		if ((Array.isArray(def.alias) ? def.alias : def.alias ? [def.alias] : []).includes(name)) return true;
+	}
+	return false;
+}
+async function showUsage(cmd, parent) {
+	try {
+		console.log(await renderUsage(cmd, parent) + "\n");
+	} catch (error) {
+		console.error(error);
+	}
+}
+const negativePrefixRe = /^no[-A-Z]/;
+async function renderUsage(cmd, parent) {
+	const cmdMeta = await resolveValue(cmd.meta || {});
+	const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
+	const parentMeta = await resolveValue(parent?.meta || {});
+	const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
+	const argLines = [];
+	const posLines = [];
+	const commandsLines = [];
+	const usageLine = [];
+	for (const arg of cmdArgs) if (arg.type === "positional") {
+		const name = arg.name.toUpperCase();
+		const isRequired = arg.required !== false && arg.default === void 0;
+		posLines.push([cyan(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
+		usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
+	} else {
+		const isRequired = arg.required === true && arg.default === void 0;
+		const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + renderValueHint(arg);
+		argLines.push([cyan(argStr), renderDescription(arg, isRequired)]);
+		/**
+		* print negative boolean arg variant usage when
+		* - enabled by default or has `negativeDescription`
+		* - not prefixed with `no-` or `no[A-Z]`
+		*/
+		if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
+			const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
+			argLines.push([cyan(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
+		}
+		if (isRequired) usageLine.push(`--${arg.name}` + renderValueHint(arg));
+	}
+	if (cmd.subCommands) {
+		const commandNames = [];
+		const subCommands = await resolveValue(cmd.subCommands);
+		for (const [name, sub] of Object.entries(subCommands)) {
+			const meta = await resolveValue((await resolveValue(sub))?.meta);
+			if (meta?.hidden) continue;
+			const aliases = toArray(meta?.alias);
+			const label = [name, ...aliases].join(", ");
+			commandsLines.push([cyan(label), meta?.description || ""]);
+			commandNames.push(name, ...aliases);
+		}
+		usageLine.push(commandNames.join("|"));
+	}
+	const usageLines = [];
+	const version = cmdMeta.version || parentMeta.version;
+	usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
+	const hasOptions = argLines.length > 0 || posLines.length > 0;
+	usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
+	if (posLines.length > 0) {
+		usageLines.push(underline(bold("ARGUMENTS")), "");
+		usageLines.push(formatLineColumns(posLines, "  "));
+		usageLines.push("");
+	}
+	if (argLines.length > 0) {
+		usageLines.push(underline(bold("OPTIONS")), "");
+		usageLines.push(formatLineColumns(argLines, "  "));
+		usageLines.push("");
+	}
+	if (commandsLines.length > 0) {
+		usageLines.push(underline(bold("COMMANDS")), "");
+		usageLines.push(formatLineColumns(commandsLines, "  "));
+		usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
+	}
+	return usageLines.filter((l) => typeof l === "string").join("\n");
+}
+function renderValueHint(arg) {
+	const valueHint = arg.valueHint ? `=<${arg.valueHint}>` : "";
+	const fallbackValueHint = valueHint || `=<${snakeCase(arg.name)}>`;
+	if (!arg.type || arg.type === "positional" || arg.type === "boolean") return valueHint;
+	if (arg.type === "enum" && arg.options?.length) return `=<${arg.options.join("|")}>`;
+	return fallbackValueHint;
+}
+function renderDescription(arg, required) {
+	const requiredHint = required ? gray("(Required)") : "";
+	const defaultHint = arg.default === void 0 ? "" : gray(`(Default: ${arg.default})`);
+	return [
+		arg.description,
+		requiredHint,
+		defaultHint
+	].filter(Boolean).join(" ");
+}
+async function runMain(cmd, opts = {}) {
+	const rawArgs = opts.rawArgs || process.argv.slice(2);
+	const showUsage$1 = opts.showUsage || showUsage;
+	try {
+		const builtinFlags = await _resolveBuiltinFlags(cmd);
+		if (builtinFlags.help.length > 0 && rawArgs.some((arg) => builtinFlags.help.includes(arg))) {
+			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+			process.exit(0);
+		} else if (rawArgs.length === 1 && builtinFlags.version.includes(rawArgs[0])) {
+			const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
+			if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
+			console.log(meta.version);
+		} else await runCommand(cmd, { rawArgs });
+	} catch (error) {
+		if (error instanceof CLIError) {
+			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+			console.error(error.message);
+		} else console.error(error, "\n");
+		process.exit(1);
+	}
+}
+async function _resolveBuiltinFlags(cmd) {
+	const argsDef = await resolveValue(cmd.args || {});
+	const userNames = /* @__PURE__ */ new Set();
+	const userAliases = /* @__PURE__ */ new Set();
+	for (const [name, def] of Object.entries(argsDef)) {
+		userNames.add(name);
+		for (const alias of toArray(def.alias)) userAliases.add(alias);
+	}
+	return {
+		help: _getBuiltinFlags("help", "h", userNames, userAliases),
+		version: _getBuiltinFlags("version", "v", userNames, userAliases)
+	};
+}
+function _getBuiltinFlags(long, short, userNames, userAliases) {
+	if (userNames.has(long) || userAliases.has(long)) return [];
+	if (userNames.has(short) || userAliases.has(short)) return [`--${long}`];
+	return [`--${long}`, `-${short}`];
+}
+//#endregion
+//#region src/cli.ts
+const { version } = createRequire(import.meta.url)("../package.json");
+function fail(message) {
+	console.error(styleText("red", `✖ ${message}`));
+	process.exit(1);
+}
+function plural(count, noun) {
+	return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function display(path) {
+	const local = relative(process.cwd(), path);
+	return local === "" ? "." : local.startsWith("..") ? path : `./${local}`;
+}
+function networkUrls(port) {
+	return Object.values(networkInterfaces()).flat().filter((address) => address?.family === "IPv4" && !address.internal).map((address) => `http://${address?.address}:${port}/`);
+}
+function openBrowser(url) {
+	const [command, ...args] = process.platform === "darwin" ? ["open", url] : process.platform === "win32" ? [
+		"cmd",
+		"/c",
+		"start",
+		"",
+		url
+	] : ["xdg-open", url];
+	spawn(command ?? "open", args, {
+		stdio: "ignore",
+		detached: true
+	}).on("error", () => console.error(styleText("yellow", `Could not open a browser. Open ${url}`))).unref();
+}
+const commonArgs = {
+	"line-numbers": {
+		type: "boolean",
+		description: "Show line numbers on all code blocks"
+	},
+	dotfiles: {
+		type: "boolean",
+		description: "Include dotfiles, such as .github/"
+	},
+	theme: {
+		type: "string",
+		description: "The default theme: github, base16:<id>, base24:<id>, omarchy:<id>, omarchy (live), a .yaml or .toml file, or a URL. Run `comarkserv themes` for the list",
+		default: "github",
+		valueHint: "name"
+	}
+};
+const serverArgs = {
+	port: {
+		type: "string",
+		alias: "p",
+		description: "The port. When it is in use, comarkserv uses the next free port",
+		default: String(DEFAULT_PORT)
+	},
+	host: {
+		type: "string",
+		alias: "H",
+		description: "The host. Use 0.0.0.0 to accept connections from the network",
+		default: "localhost"
+	},
+	livereload: {
+		type: "boolean",
+		default: true,
+		description: "Update open pages when files change",
+		negativeDescription: "Do not watch the files"
+	},
+	"strict-port": {
+		type: "boolean",
+		description: "Stop when the port is in use"
+	},
+	share: {
+		type: "boolean",
+		description: "Share the pages at a public URL, through a Cloudflare tunnel. Anyone with the URL can read the files"
+	},
+	silent: {
+		type: "boolean",
+		alias: "s",
+		description: "Do not print the requests"
+	},
+	...commonArgs
+};
+const LOCAL_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"::1"
+]);
+async function qrCode(url) {
+	const { renderUnicodeCompact } = await import("./dist-CfsjQ0o8.mjs");
+	return renderUnicodeCompact(url).split("\n").map((line) => `  ${line}`).join("\n");
+}
+/**
+* Gets the consent for the Cloudflare license before cloudflared is installed, and
+* returns it for the tunnel. untun answers its own prompt with yes when there is no
+* terminal, so comarkserv asks the question itself, or stops.
+*/
+async function tunnelConsent() {
+	if (isCloudflaredInstalled()) return false;
+	if (process.env.UNTUN_ACCEPT_CLOUDFLARE_NOTICE) return true;
+	if (!process.stdin.isTTY) fail("The first --share installs cloudflared, and you must accept the Cloudflare license first. Run the command in a terminal, or set UNTUN_ACCEPT_CLOUDFLARE_NOTICE=1 to accept the license.");
+	console.log([
+		"",
+		"  --share installs cloudflared from GitHub. Before that, accept the Cloudflare documents:",
+		`  License  ${CLOUDFLARE_LINKS.license}`,
+		`  Terms    ${CLOUDFLARE_LINKS.terms}`,
+		`  Privacy  ${CLOUDFLARE_LINKS.privacy}`,
+		""
+	].join("\n"));
+	const prompt = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	const answer = await prompt.question("  Do you accept them and install cloudflared? (y/N) ");
+	prompt.close();
+	if (!/^y(es)?$/i.test(answer.trim())) fail("comarkserv did not share the pages.");
+	return true;
+}
+/** Starts the tunnel of the server and prints its public URL. */
+async function share(server, accept, open) {
+	const service = server.handler.share;
+	if (!service) fail("Sharing is off for this server.");
+	console.log(styleText("dim", "  Starting a public tunnel. This can take some seconds..."));
+	const url = await service.start({
+		origin: `http://127.0.0.1:${server.port}`,
+		accept
+	}).catch((error) => fail(`The tunnel did not start: ${error instanceof Error ? error.message : String(error)}`));
+	console.log([
+		"",
+		`  ${styleText("dim", "Public".padEnd(9))}${styleText("cyan", url)}`,
+		"",
+		await qrCode(url),
+		"",
+		styleText("yellow", `  Anyone with this URL can read the files in ${display(server.handler.root)}. Visitors cannot edit.`),
+		styleText("dim", "  Press Ctrl+C to stop the server and the tunnel."),
+		""
+	].join("\n"));
+	if (open) openBrowser(url);
+}
+/** Serves a directory, or the directory of a markdown file, and prints the banner. */
+async function serve(target, args, open) {
+	if (!existsSync(target)) fail(`There is no file or directory at ${target}.`);
+	const accept = args.share ? await tunnelConsent() : false;
+	const isFile = statSync(target).isFile();
+	const port = Number(args.port);
+	if (!Number.isInteger(port) || port < 0 || port > 65535) fail("--port must be a number from 0 to 65535.");
+	const theme = await createThemeStore().load(args.theme).catch((error) => fail(error instanceof Error ? error.message : String(error)));
+	const host = args.share && args.host === "localhost" ? "127.0.0.1" : args.host;
+	const server = await startServer({
+		root: isFile ? dirname(target) : target,
+		theme: args.theme,
+		port,
+		host,
+		editor: LOCAL_HOSTS.has(host),
+		share: LOCAL_HOSTS.has(host),
+		strictPort: args["strict-port"],
+		livereload: args.livereload,
+		lineNumbers: args["line-numbers"],
+		dotfiles: args.dotfiles,
+		log: !args.silent
+	}).catch((error) => fail(error instanceof Error ? error.message : String(error)));
+	const url = isFile ? new URL(encodeURIComponent(basename(target)), server.url).href : server.url;
+	const label = (name) => styleText("dim", name.padEnd(9));
+	const lines = [
+		"",
+		`  ${styleText("bold", styleText("magenta", "comarkserv"))} ${styleText("dim", `v${version}`)}  ` + styleText("dim", `ready in ${Math.round(performance.now())} ms`),
+		"",
+		`  ${label("Local")}${styleText("cyan", url)}`,
+		...args.host === "0.0.0.0" || args.host === "::" ? networkUrls(server.port).map((address) => `  ${label("Network")}${styleText("cyan", address)}`) : [],
+		`  ${label("Root")}${display(server.handler.root)}`,
+		`  ${label("Reload")}${args.livereload ? "on" : "off"}`,
+		`  ${label("Theme")}${theme ? `${theme.name} ${styleText("dim", `(${args.theme})`)}` : "GitHub"}`,
+		"",
+		styleText("dim", "  Press Ctrl+C to stop."),
+		""
+	];
+	console.log(lines.join("\n"));
+	if (server.port !== port && port !== 0) console.log(styleText("yellow", `  Port ${port} is in use, so comarkserv uses port ${server.port}.\n`));
+	if (args.host === "0.0.0.0" || args.host === "::") {
+		const [address] = networkUrls(server.port);
+		if (address) console.log(`${await qrCode(address)}\n`);
+	}
+	if (args.share) await share(server, accept, open);
+	else if (open) openBrowser(url);
+	const stop = () => {
+		server.close().finally(() => process.exit(0));
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+}
+const serveCommand = defineCommand({
+	meta: {
+		name: "comarkserv",
+		version,
+		description: "Serve markdown as HTML, with live reload. Other commands: `comarkserv readme`, `comarkserv cat`, `comarkserv build`, `comarkserv themes`."
+	},
+	args: {
+		path: {
+			type: "positional",
+			description: "The directory or markdown file to serve",
+			default: "."
+		},
+		open: {
+			type: "boolean",
+			alias: "o",
+			description: "Open the page in the browser"
+		},
+		...serverArgs
+	},
+	run: ({ args }) => serve(resolve(args.path), args, args.open === true)
+});
+const readmeCommand = defineCommand({
+	meta: {
+		name: "comarkserv readme",
+		version,
+		description: "Serve the closest README: in the directory, or in the first parent directory that has one"
+	},
+	args: {
+		from: {
+			type: "positional",
+			description: "The directory to search from",
+			default: "."
+		},
+		open: {
+			type: "boolean",
+			alias: "o",
+			default: true,
+			description: "Open the README in the browser",
+			negativeDescription: "Do not open the browser"
+		},
+		...serverArgs
+	},
+	async run({ args }) {
+		const start = resolve(args.from);
+		const readme = await findReadme(start);
+		if (!readme) fail(`There is no README in ${start} or in a parent directory.`);
+		await serve(readme, args, args.open);
+	}
+});
+const buildCommand = defineCommand({
+	meta: {
+		name: "comarkserv build",
+		version,
+		description: "Build a static HTML site from a directory of markdown"
+	},
+	args: {
+		path: {
+			type: "positional",
+			description: "The directory to build",
+			default: "."
+		},
+		out: {
+			type: "string",
+			alias: "o",
+			description: "The output directory. comarkserv deletes an earlier build in it",
+			default: "dist"
+		},
+		...commonArgs
+	},
+	async run({ args }) {
+		const root = resolve(args.path);
+		if (!existsSync(root) || !statSync(root).isDirectory()) fail(`There is no directory at ${root}.`);
+		const { build } = await import("./build-CsToYJrU.mjs");
+		const result = await build({
+			root,
+			outDir: resolve(args.out),
+			lineNumbers: args["line-numbers"],
+			dotfiles: args.dotfiles,
+			theme: args.theme
+		}).catch((error) => fail(error instanceof Error ? error.message : String(error)));
+		for (const warning of result.warnings) console.warn(styleText("yellow", `! ${warning}`));
+		console.log(`${styleText("green", "✓")} Built ${plural(result.pages, "page")} and copied ${plural(result.files, "file")} to ${display(result.outDir)} in ${Math.round(result.ms)} ms`);
+	}
+});
+function page(text, pager) {
+	if (!pager || !process.stdout.isTTY) {
+		process.stdout.write(text);
+		return;
+	}
+	const less = spawn("less", [
+		"-R",
+		"-F",
+		"-X"
+	], { stdio: [
+		"pipe",
+		"inherit",
+		"inherit"
+	] });
+	less.on("error", () => process.stdout.write(text));
+	less.stdin.on("error", () => {});
+	less.stdin.end(text);
+}
+const catCommand = defineCommand({
+	meta: {
+		name: "comarkserv cat",
+		version,
+		description: "Show a markdown file in the terminal"
+	},
+	args: {
+		file: {
+			type: "positional",
+			description: "The markdown file",
+			required: true
+		},
+		color: {
+			type: "boolean",
+			description: "Use colors. The default is on in a terminal, unless NO_COLOR is set",
+			negativeDescription: "Do not use colors"
+		},
+		pager: {
+			type: "boolean",
+			default: true,
+			description: "Show a long file in less",
+			negativeDescription: "Print the whole file"
+		}
+	},
+	async run({ args }) {
+		const path = resolve(args.file);
+		if (!existsSync(path) || !statSync(path).isFile()) fail(`There is no file at ${path}.`);
+		const source = readFileSync(path, "utf8");
+		const colors = args.color ?? (process.stdout.isTTY === true && !process.env.NO_COLOR);
+		const { createTerminalRenderer } = await import("./terminal-aKr5Xlp3.mjs");
+		page(await createTerminalRenderer({
+			colors,
+			width: Math.min(process.stdout.columns || 80, 100)
+		})(source), args.pager);
+	}
+});
+const themesCommand = defineCommand({
+	meta: {
+		name: "comarkserv themes",
+		version,
+		description: "List the themes for --theme"
+	},
+	args: {
+		filter: {
+			type: "positional",
+			description: "Show only the themes with this text",
+			default: ""
+		},
+		json: {
+			type: "boolean",
+			description: "Print the list as JSON, for other tools"
+		}
+	},
+	async run({ args }) {
+		const entries = await createThemeStore().catalog().catch((error) => fail(`The theme list is not available: ${error instanceof Error ? error.message : String(error)}`));
+		const rows = [
+			{
+				id: "github",
+				name: "GitHub, built in (the default)"
+			},
+			...existsSync(OMARCHY_CURRENT) ? [{
+				id: "omarchy",
+				name: "The current Omarchy theme, live"
+			}] : [],
+			...entries
+		];
+		const filter = args.filter.toLowerCase();
+		const shown = rows.filter((row) => `${row.id} ${row.name}`.toLowerCase().includes(filter));
+		if (args.json) {
+			console.log(JSON.stringify(shown.map(({ id, name }) => ({
+				id,
+				name
+			}))));
+			return;
+		}
+		const width = Math.max(0, ...shown.map((row) => row.id.length));
+		for (const row of shown) console.log(`${row.id.padEnd(width)}  ${styleText("dim", row.name)}`);
+		console.log(styleText("dim", `\n${plural(shown.length, "theme")}. Use one with --theme <id>, or give a .yaml or .toml file.`));
+	}
+});
+const themeCommand = defineCommand({
+	meta: {
+		name: "comarkserv theme",
+		version,
+		description: "Show the name, the variant and the 16 colors of a theme"
+	},
+	args: {
+		id: {
+			type: "positional",
+			description: "The theme, as for --theme",
+			required: true
+		},
+		json: {
+			type: "boolean",
+			description: "Print the theme as JSON, for other tools"
+		}
+	},
+	async run({ args }) {
+		const theme = await createThemeStore().load(args.id).catch((error) => fail(error instanceof Error ? error.message : String(error)));
+		if (!theme) fail("github is the built-in theme. It has no base16 colors.");
+		if (args.json) {
+			console.log(JSON.stringify(theme));
+			return;
+		}
+		console.log(`${styleText("bold", theme.name)} ${styleText("dim", `(${theme.variant})`)}`);
+		theme.colors.forEach((color, index) => {
+			const slot = `base0${index.toString(16).toUpperCase()}`;
+			const [r, g, b] = [
+				1,
+				3,
+				5
+			].map((start) => Number.parseInt(color.slice(start, start + 2), 16));
+			const swatch = process.stdout.isTTY ? `\x1b[48;2;${r};${g};${b}m    \x1b[0m ` : "";
+			console.log(`${swatch}${slot}  ${color}`);
+		});
+	}
+});
+const argv = process.argv.slice(2);
+if (argv[0] === "build") await runMain(buildCommand, { rawArgs: argv.slice(1) });
+else if (argv[0] === "themes") await runMain(themesCommand, { rawArgs: argv.slice(1) });
+else if (argv[0] === "readme") await runMain(readmeCommand, { rawArgs: argv.slice(1) });
+else if (argv[0] === "cat") await runMain(catCommand, { rawArgs: argv.slice(1) });
+else if (argv[0] === "theme") await runMain(themeCommand, { rawArgs: argv.slice(1) });
+else await runMain(serveCommand, { rawArgs: argv });
+//#endregion
+export {};