sevok 0.0.2

package/dist/cli.mjs

@@ -0,0 +1,461 @@
+import { u as loadServerAdapter } from "./core-CmUugTW7.mjs";
+import { t as _color_default } from "./_color-B42q-MpL.mjs";
+import { existsSync, statSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { fork } from "node:child_process";
+import { dirname, relative, resolve } from "node:path";
+//#endregion
+//#region src/_meta.ts
+const pkgMeta = {
+	name: "sevok",
+	version: "0.0.2",
+	description: "Composable Server Primitives Across Runtimes"
+};
+//#endregion
+//#region src/cli.ts
+const defaultExts = [
+	".mjs",
+	".js",
+	".mts",
+	".ts"
+];
+const defaultEntries = [
+	"server",
+	"server/index",
+	"src/server",
+	"server/server"
+];
+/**
+* Resolve and import a user server entry module.
+*
+* The loader can work with an explicit `entry` path or fall back to a list of
+* conventional filenames such as `server.ts` and `src/server.ts`. After the
+* module is imported, plain object default exports are unwrapped, a fetch
+* handler is extracted, and a runtime adapter is selected for the current
+* process.
+*/
+async function loadServerEntry(opts) {
+	let entry = opts.entry;
+	if (entry) {
+		entry = resolve(opts.dir || ".", entry);
+		if (!existsSync(entry)) return {
+			notFound: true,
+			adapter: await loadServerAdapter()
+		};
+	} else {
+		for (const defEntry of defaultEntries) {
+			for (const defExt of defaultExts) {
+				const entryPath = resolve(opts.dir || ".", `${defEntry}${defExt}`);
+				if (existsSync(entryPath)) {
+					entry = entryPath;
+					break;
+				}
+			}
+			if (entry) break;
+		}
+		if (!entry) return {
+			notFound: true,
+			adapter: await loadServerAdapter()
+		};
+	}
+	const url = entry.startsWith("file://") ? entry : pathToFileURL(resolve(entry)).href;
+	let mod;
+	try {
+		mod = await import(url);
+		if (mod?.default != null && typeof mod.default === "object" && !Array.isArray(mod.default)) mod = mod.default;
+	} catch (error) {
+		if (error?.code === "ERR_UNKNOWN_FILE_EXTENSION") {
+			const message = String(error);
+			if (/"\.(m|c)?ts"/g.test(message)) throw new Error(`Make sure you're using Node.js v22.18+ or v24+ for TypeScript support (current version: ${process.versions.node})`, { cause: error });
+			else if (/"\.(m|c)?tsx"/g.test(message)) throw new Error(`You need a compatible loader for JSX support (Deno, Bun, or sevok --import jiti/register)`, { cause: error });
+		}
+		throw error;
+	}
+	mod = await opts?.onLoad?.(mod) || mod;
+	return {
+		module: mod,
+		url,
+		fetch: mod.fetch,
+		adapter: await loadServerAdapter()
+	};
+}
+/**
+* Main CLI entrypoint.
+*
+* Handles top-level flags, resolves environment files, and decides whether the
+* current process should serve directly or fork a watched child process.
+*/
+async function main(mainOpts) {
+	const args = mainOpts.args ?? [];
+	const cliOpts = parseArgs$1(args);
+	if (cliOpts.version) {
+		process.stdout.write(versions(mainOpts).join("\n") + "\n");
+		process.exit(0);
+	}
+	if (cliOpts.help) {
+		console.log(usage(mainOpts));
+		process.exit(cliOpts.help ? 0 : 1);
+	}
+	if (process.send) return startServer(cliOpts);
+	console.log(_color_default.gray([...versions(mainOpts), cliOpts.prod ? "prod" : "dev"].join(" · ")));
+	const envFiles = [
+		".env",
+		".env.local",
+		cliOpts.prod ? ".env.production" : ".env.development"
+	].filter((f) => existsSync(f));
+	if (envFiles.length > 0) console.log(`${_color_default.gray(`Loading environment variables from ${_color_default.magenta(envFiles.join(", "))}`)}`);
+	if (cliOpts.prod && !cliOpts.import) {
+		for (const envFile of [...envFiles].reverse()) process.loadEnvFile?.(envFile);
+		await startServer(cliOpts);
+		return;
+	}
+	const isBun = !!process.versions.bun;
+	const isDeno = !!process.versions.deno;
+	const isNode = !isBun && !isDeno;
+	const runtimeArgs = [];
+	runtimeArgs.push(...envFiles.map((f) => `--env-file=${f}`));
+	if (!cliOpts.prod) runtimeArgs.push("--watch");
+	if (cliOpts.import && (isNode || isBun)) runtimeArgs.push(`--import=${cliOpts.import}`);
+	await forkCLI(args, runtimeArgs);
+}
+/**
+* Parse command-line arguments for the `serve` command.
+*/
+function parseArgs$1(args) {
+	const { values, positionals } = parseArgs({
+		args,
+		allowPositionals: true,
+		options: {
+			help: {
+				type: "boolean",
+				short: "h"
+			},
+			version: {
+				type: "boolean",
+				short: "v"
+			},
+			dir: { type: "string" },
+			entry: { type: "string" },
+			host: { type: "string" },
+			hostname: { type: "string" },
+			tls: { type: "boolean" },
+			url: { type: "string" },
+			prod: { type: "boolean" },
+			port: {
+				type: "string",
+				short: "p"
+			},
+			static: {
+				type: "string",
+				short: "s"
+			},
+			import: { type: "string" },
+			cert: { type: "string" },
+			key: { type: "string" }
+		}
+	});
+	const maybeEntryOrDir = positionals[0];
+	if (maybeEntryOrDir) {
+		if (values.entry || values.dir) throw new Error("Cannot specify entry or dir as positional argument when --entry or --dir is used!");
+		if (statSync(maybeEntryOrDir).isDirectory()) values.dir = maybeEntryOrDir;
+		else values.entry = maybeEntryOrDir;
+	}
+	return values;
+}
+/**
+* Prepare process-level error handlers and start serving.
+*/
+async function startServer(cliOpts) {
+	setupProcessErrorHandlers();
+	await cliServe(cliOpts);
+}
+/**
+* Spawn a child CLI process for watch mode or runtime-preload scenarios.
+*
+* The parent process supervises the child and forwards selected termination
+* paths so the child does not outlive the CLI session.
+*/
+async function forkCLI(args, runtimeArgs) {
+	const child = fork(fileURLToPath(globalThis.__SEVOK_BIN__ || new URL("../bin/sevok.mjs", import.meta.url)), [...args], { execArgv: [...process.execArgv, ...runtimeArgs].filter(Boolean) });
+	child.on("error", (error) => {
+		console.error("Error in child process:", error);
+		process.exit(1);
+	});
+	child.on("exit", (code) => {
+		if (code !== 0) {
+			console.error(`Child process exited with code ${code}`);
+			process.exit(code);
+		}
+	});
+	child.on("message", (msg) => {
+		if (msg && msg.error === "no-entry") {
+			console.error("\n" + _color_default.red(NO_ENTRY_ERROR) + "\n");
+			process.exit(3);
+		}
+	});
+	let cleanupCalled = false;
+	const cleanup = (signal, exitCode) => {
+		if (cleanupCalled) return;
+		cleanupCalled = true;
+		try {
+			child.kill(signal || "SIGTERM");
+		} catch (error) {
+			console.error("Error killing child process:", error);
+		}
+		if (exitCode !== void 0) process.exit(exitCode);
+	};
+	process.on("exit", () => cleanup("SIGTERM"));
+	process.on("SIGTERM", () => cleanup("SIGTERM", 143));
+	if (args.includes("--watch")) process.on("SIGINT", () => cleanup("SIGINT", 130));
+}
+/**
+* Convert uncaught process-level failures into a clear non-zero exit.
+*/
+function setupProcessErrorHandlers() {
+	process.on("uncaughtException", (error) => {
+		console.error("Uncaught exception:", error);
+		process.exit(1);
+	});
+	process.on("unhandledRejection", (reason) => {
+		console.error("Unhandled rejection:", reason);
+		process.exit(1);
+	});
+}
+/**
+* Build the version banner printed by the CLI.
+*/
+function versions(mainOpts) {
+	const versions = [];
+	if (mainOpts.meta?.name) versions.push(`${mainOpts.meta.name} ${mainOpts.meta.version || ""}`.trim());
+	versions.push(`${pkgMeta.name} ${pkgMeta.version}`);
+	versions.push(runtime());
+	return versions;
+}
+/**
+* Detect the current JavaScript runtime for display purposes.
+*/
+function runtime() {
+	if (process.versions.bun) return `bun ${process.versions.bun}`;
+	else if (process.versions.deno) return `deno ${process.versions.deno}`;
+	else return `node ${process.versions.node}`;
+}
+/**
+* Render the CLI help output.
+*/
+function usage(mainOpts) {
+	const name = mainOpts.meta?.name || pkgMeta.name.split("/").pop();
+	const ver = mainOpts.meta?.version || pkgMeta.version;
+	const desc = mainOpts.meta?.description || pkgMeta.description;
+	const formatSection = (rows) => {
+		const labelWidth = rows.reduce((width, row) => Math.max(width, row.label.length), 0);
+		return rows.map((row) => `  ${row.renderLabel().padEnd(labelWidth + (row.renderLabel().length - row.label.length))}  ${row.description}`).join("\n");
+	};
+	const usageRows = [{
+		label: `${name} <file>`,
+		renderLabel: () => `${_color_default.green(name)} ${_color_default.yellow("<file>")}`,
+		description: "Use a server entry file as a positional alias for --entry"
+	}, {
+		label: `${name} <dir>`,
+		renderLabel: () => `${_color_default.green(name)} ${_color_default.yellow("<dir>")}`,
+		description: "Use a working directory as a positional alias for --dir"
+	}];
+	const optionRows = [
+		{
+			label: "--entry <file>",
+			renderLabel: () => `${_color_default.green("--entry")} ${_color_default.yellow("<file>")}`,
+			description: "Server entry file to use"
+		},
+		{
+			label: "--dir <dir>",
+			renderLabel: () => `${_color_default.green("--dir")} ${_color_default.yellow("<dir>")}`,
+			description: "Working directory for resolving entry file"
+		},
+		{
+			label: "-h, --help",
+			renderLabel: () => _color_default.green("-h, --help"),
+			description: "Show this help message"
+		},
+		{
+			label: "-v, --version",
+			renderLabel: () => _color_default.green("-v, --version"),
+			description: "Show server and runtime versions"
+		},
+		{
+			label: "-p, --port <port>",
+			renderLabel: () => `${_color_default.green("-p, --port")} ${_color_default.yellow("<port>")}`,
+			description: `Port to listen on (default: ${_color_default.yellow("3000")})`
+		},
+		{
+			label: "--host, --hostname <host>",
+			renderLabel: () => `${_color_default.green("--host, --hostname")} ${_color_default.yellow("<host>")}`,
+			description: "Host to bind to (default: all interfaces)"
+		},
+		{
+			label: "-s, --static <dir>",
+			renderLabel: () => `${_color_default.green("-s, --static")} ${_color_default.yellow("<dir>")}`,
+			description: `Serve static files from the specified directory (default: ${_color_default.yellow("public")})`
+		},
+		{
+			label: "--prod",
+			renderLabel: () => _color_default.green("--prod"),
+			description: "Disable watch mode and use production env defaults"
+		},
+		{
+			label: "--import <loader>",
+			renderLabel: () => `${_color_default.green("--import")} ${_color_default.yellow("<loader>")}`,
+			description: "ES module to preload (Node.js / Bun only)"
+		},
+		{
+			label: "--tls",
+			renderLabel: () => _color_default.green("--tls"),
+			description: "Enable TLS (HTTPS/HTTP2)"
+		},
+		{
+			label: "--cert <file>",
+			renderLabel: () => `${_color_default.green("--cert")} ${_color_default.yellow("<file>")}`,
+			description: "TLS certificate file"
+		},
+		{
+			label: "--key <file>",
+			renderLabel: () => `${_color_default.green("--key")} ${_color_default.yellow("<file>")}`,
+			description: "TLS private key file"
+		}
+	];
+	const environmentRows = [
+		{
+			label: "PORT",
+			renderLabel: () => _color_default.green("PORT"),
+			description: "Override port"
+		},
+		{
+			label: "HOST",
+			renderLabel: () => _color_default.green("HOST"),
+			description: "Override host"
+		},
+		{
+			label: "NODE_ENV",
+			renderLabel: () => _color_default.green("NODE_ENV"),
+			description: `Defaults to ${_color_default.yellow("development")} or ${_color_default.yellow("production")} based on --prod.`
+		}
+	];
+	return `
+${_color_default.cyan(name)}${_color_default.gray(`${ver ? ` ${ver}` : ""} ${desc ? `- ${desc}` : ""}`)}
+
+${_color_default.bold("USAGE")}
+
+${formatSection(usageRows)}
+
+${_color_default.bold("OPTIONS")}
+
+${formatSection(optionRows)}
+
+${_color_default.bold("ENVIRONMENT")}
+
+${formatSection(environmentRows)}
+
+${mainOpts.usage?.docs ? `➤ ${_color_default.url("Documentation", mainOpts.usage.docs)}` : ""}
+${mainOpts.usage?.issues ? `➤ ${_color_default.url("Report issues", mainOpts.usage.issues)}` : ""}
+`.trim();
+}
+const NO_ENTRY_ERROR = "No server entry or public directory found";
+/**
+* Resolve the user entry module, attach default middleware, and start the
+* runtime adapter-backed server instance.
+*/
+async function cliServe(cliOpts) {
+	try {
+		if (!process.env.NODE_ENV) process.env.NODE_ENV = cliOpts.prod ? "production" : "development";
+		let server;
+		const loaded = await loadServerEntry({
+			entry: cliOpts.entry,
+			dir: cliOpts.dir
+		});
+		const { serve } = await import("./core-CmUugTW7.mjs").then((n) => n.o);
+		const { serveStatic } = await import("./static.mjs");
+		const { log } = await import("./log.mjs");
+		const staticDir = resolve(cliOpts.dir || (loaded.url ? dirname(fileURLToPath(loaded.url)) : "."), cliOpts.static || "public");
+		const staticExplicitlySet = !!cliOpts.static;
+		const staticExists = existsSync(staticDir);
+		if (staticExplicitlySet && !staticExists) console.warn(_color_default.yellow(`Warning: Static directory not found: ${staticDir}`));
+		cliOpts.static = staticExists ? staticDir : "";
+		if (loaded.notFound && !cliOpts.static) {
+			process.send?.({ error: "no-entry" });
+			throw new Error(NO_ENTRY_ERROR, { cause: cliOpts });
+		}
+		const serverOptions = {
+			...loaded.module?.default,
+			default: void 0,
+			...loaded.module
+		};
+		printInfo(cliOpts, loaded);
+		server = serve({
+			...serverOptions,
+			gracefulShutdown: !!cliOpts.prod,
+			port: cliOpts.port ?? serverOptions.port,
+			hostname: cliOpts.hostname ?? cliOpts.host ?? serverOptions.hostname,
+			tls: cliOpts.tls ? {
+				cert: cliOpts.cert,
+				key: cliOpts.key
+			} : void 0,
+			error: (error) => {
+				console.error(error);
+				return renderError(cliOpts, error);
+			},
+			fetch: loaded.fetch || (() => renderError(cliOpts, loaded.notFound ? "Server Entry Not Found" : "No Fetch Handler Exported", 501)),
+			middleware: [
+				log(),
+				cliOpts.static ? serveStatic({ dir: cliOpts.static }) : void 0,
+				...serverOptions.middleware || []
+			].filter(Boolean),
+			adapter: loaded.adapter
+		});
+		await server?.ready();
+	} catch (error) {
+		console.error(error);
+		process.exit(1);
+	}
+}
+/**
+* Render an HTML error page for CLI-served requests.
+*
+* Production mode returns a minimal message while development mode includes the
+* full error details for debugging.
+*/
+function renderError(cliOpts, error, status = 500, title = "Server Error") {
+	let html = `<!DOCTYPE html><html><head><title>${title}</title></head><body>`;
+	if (cliOpts.prod) html += `<h1>${title}</h1><p>Something went wrong while processing your request.</p>`;
+	else html += `
+    <style>
+      body { font-family: Arial, sans-serif; margin: 0; padding: 20px; background: #f8f9fa; color: #333; }
+      h1 { color: #dc3545; }
+      pre { background: #fff; padding: 10px; border-radius: 5px; overflow: auto; }
+      code { font-family: monospace; }
+      #error { display: flex; flex-direction: column; justify-content: center; align-items: center; height: 100vh; }
+    </style>
+    <div id="error"><h1>${title}</h1><pre>${error instanceof Error ? error.stack || error.message : String(error)}</pre></div>
+    `;
+	return new Response(html, {
+		status,
+		headers: { "Content-Type": "text/html; charset=utf-8" }
+	});
+}
+/**
+* Print resolved entry and static directory information before the server
+* starts listening.
+*/
+function printInfo(cliOpts, loaded) {
+	let entryInfo;
+	if (loaded.notFound) entryInfo = _color_default.gray(`(create ${_color_default.bold(`server.ts`)})`);
+	else entryInfo = loaded.fetch ? _color_default.cyan("./" + relative(".", fileURLToPath(loaded.url))) : _color_default.red(`No fetch handler exported from ${loaded.url}`);
+	console.log(_color_default.gray(`${_color_default.bold(_color_default.gray("◆"))} Server handler: ${entryInfo}`));
+	let staticInfo;
+	if (cliOpts.static) {
+		const relPath = relative(".", cliOpts.static);
+		staticInfo = _color_default.cyan(relPath ? "./" + relPath + "/" : "./");
+	} else staticInfo = _color_default.gray(`(create ${_color_default.bold("public/")} dir)`);
+	console.log(_color_default.gray(`${_color_default.bold(_color_default.gray("◇"))} Static files:   ${staticInfo}`));
+	console.log("");
+}
+//#endregion
+export { NO_ENTRY_ERROR, cliServe, defaultEntries, defaultExts, loadServerEntry, main, usage };