@monimesl/dot-cli 0.1.0-alpha.10

package/dist/cli.js

@@ -0,0 +1,942 @@
+import { createRequire } from "node:module";
+import { spawn, spawnSync } from "node:child_process";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { parseArgs, styleText } from "node:util";
+import { CompileError, PAGES_DIR, build, installedRuntime, loadProject } from "@monimesl/dot-compiler";
+import { DEFAULT_PORT, startSimulator } from "@monimesl/dot-simulator";
+import { existsSync, readFileSync, readdirSync, watch } from "node:fs";
+import { cp, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { DmlParseError } from "@monimesl/dot-dml-parser";
+import { ScriptParseError, parseDotModule } from "@monimesl/dot-script-parser";
+import { isPageId } from "@monimesl/dot-core";
+import { renderUnicodeCompact } from "uqr";
+import { createHash, createHmac, createPrivateKey, createPublicKey, randomBytes, sign, timingSafeEqual } from "node:crypto";
+import { homedir, networkInterfaces } from "node:os";
+import { createServer } from "node:http";
+import { emitKeypressEvents } from "node:readline";
+import { createInterface } from "node:readline/promises";
+//#region src/report.ts
+var CommandError = class extends Error {
+	name = "CommandError";
+};
+function describeError(error) {
+	if (error instanceof CommandError || error instanceof CompileError || error instanceof DmlParseError || error instanceof ScriptParseError) return error.message;
+	if (error.code?.startsWith("ERR_PARSE_ARGS")) {
+		const [firstSentence] = error.message.split(". ");
+		return `${firstSentence}. See dotctl --help.`;
+	}
+	return error instanceof Error ? error.stack ?? error.message : String(error);
+}
+function printWarnings({ warnings }) {
+	for (const warning of warnings) console.warn(`warning: ${warning.message}`);
+}
+function printBuildTime(startedAt) {
+	console.log(`Built in ${Math.round(performance.now() - startedAt)}ms`);
+}
+//#endregion
+//#region src/create/template.ts
+const TEMPLATES = ["starter", "showcase"];
+const TEMPLATE_HINTS = {
+	starter: "one page to build on",
+	showcase: "a page for each feature, to learn from"
+};
+function isTemplate(name) {
+	return TEMPLATES.includes(name);
+}
+const PAGE_FILES = {
+	"view.dml": "<View>\n	<Text>My new page</Text>\n</View>\n",
+	"state.ts": "export default {};\n",
+	"controller.ts": `import state from './state';
+
+export default definePage({
+  initialState: state,
+});
+`
+};
+const TEMPLATE_FILES = [
+	"dot.ts",
+	"pages",
+	"statics",
+	".env"
+];
+const DOT_JSON_SCHEMA = "./node_modules/@monimesl/dot-runtime/dot.schema.json";
+const json = (value) => `${JSON.stringify(value, null, 2)}\n`;
+function projectFiles(options) {
+	return {
+		"package.json": packageJson(options),
+		"tsconfig.json": tsconfig(options),
+		".gitignore": "node_modules/\ndist/\n# Types generated by dotctl\n.dot/\n",
+		"dot.json": dotJson(options),
+		"README.md": readme(options)
+	};
+}
+function packageJson({ packageName, dotVersion, workspace }) {
+	const conditions = workspace ? " --conditions @monimesl/dot-source" : "";
+	return json({
+		name: packageName,
+		private: true,
+		type: "module",
+		scripts: {
+			dev: `dotctl dev${conditions}`,
+			build: `dotctl build${conditions}`,
+			preview: `dotctl preview${conditions}`,
+			typecheck: "tsc --noEmit"
+		},
+		dependencies: { "@monimesl/dot-runtime": dotVersion },
+		devDependencies: {
+			"@monimesl/dot-cli": dotVersion,
+			typescript: "^5.9.3"
+		}
+	});
+}
+function tsconfig({ workspace }) {
+	const compilerOptions = {
+		target: "ES2022",
+		module: "ESNext",
+		moduleResolution: "bundler",
+		lib: ["ES2022"],
+		types: ["@monimesl/dot-runtime/globals"],
+		strict: true,
+		noEmit: true,
+		skipLibCheck: true,
+		verbatimModuleSyntax: true
+	};
+	if (workspace) compilerOptions.customConditions = ["@monimesl/dot-source"];
+	return json({
+		compilerOptions,
+		include: [
+			"dot.ts",
+			"pages",
+			".dot/pages.d.ts",
+			".dot/env.d.ts"
+		]
+	});
+}
+function dotJson({ name, packageName, template }) {
+	const dot = {
+		$schema: DOT_JSON_SCHEMA,
+		id: `com.example.${idWord(packageName)}`,
+		name,
+		version: "0.1.0"
+	};
+	if (template === "showcase") dot.network = { hosts: [
+		"itunes.apple.com",
+		"*.mzstatic.com",
+		"httpbin.org"
+	] };
+	return json(dot);
+}
+const TEMPLATE_READMES = {
+	starter: `It starts with one page, \`index\`. It shows a greeting from \`.env\` and a counter you
+can tap. Change it, and add pages as the dot grows. To see how each feature works, make a showcase
+dot with \`npx dotctl create my-tour --template showcase\`.`,
+	showcase: `It starts as a showcase. The \`index\` page links to a page for each feature: layout,
+text, images and inputs, then state, navigation, and Dash's alerts, network and files. Read a page
+to see how it works. Then delete the pages you don't need, both from \`pages/\` and from
+\`dot.ts\`.`
+};
+function readme({ name, template }) {
+	return `# ${name}
+
+A dot: a mini app that runs inside Dash.
+
+\`\`\`sh
+npm install
+npm run dev     # run it in the simulator; it reloads on every change
+npm run build   # build it for Dash
+\`\`\`
+
+${TEMPLATE_READMES[template]}
+
+## Pages
+
+Each page is a folder under \`pages/\` with three files:
+
+- \`view.dml\`: what the page shows. It has one root \`<View>\`, with everything else inside it.
+- \`state.ts\`: the data the page starts with.
+- \`controller.ts\`: how the data changes.
+
+\`npx dotctl create page <path>\` adds a page, such as \`cart/checkout\`, with these three files. It
+also lists the page in \`dot.ts\`. The dot opens on the first page in that list.
+
+## dot.json
+
+\`dot.json\` describes the dot to Dash. Before you publish, change its \`id\` from
+\`com.example.…\` to a reverse domain name you own. You can't change the id after publishing.
+\`network.hosts\` lists every host the dot sends requests to with \`dash.network\`. Requests to any
+other host fail. Your editor can complete the other fields from the schema the file points to.
+
+## .env
+
+\`.env\` holds public configuration. Code in the dot reads each variable from \`env\`, such as
+\`env.GREETING\`. Every variable is built into the dot, so anyone who has the dot can read it.
+Never put a secret there. \`.env.development\` and \`.env.production\` override it for \`dev\` and
+\`build\`.
+`;
+}
+function idWord(packageName) {
+	return packageName.slice(0, 63).replace(/-+$/, "");
+}
+//#endregion
+//#region src/create/create.ts
+async function create({ name, dir, template = "starter" }) {
+	const root = resolve(dir);
+	if (existsSync(root) && readdirSync(root).length > 0) throw new CommandError(`${dir} already exists and is not empty. Choose another folder`);
+	const packageName = toPackageName(name);
+	if (!packageName) throw new CommandError(`The name "${name}" needs at least one letter or digit`);
+	const workspace = isInDotWorkspace(root);
+	const source = templateDir(template);
+	await mkdir(root, { recursive: true });
+	for (const path of TEMPLATE_FILES) await cp(join(source, path), join(root, path), { recursive: true });
+	const generated = projectFiles({
+		name,
+		packageName,
+		dotVersion: workspace ? "workspace:*" : `^${cliVersion()}`,
+		workspace,
+		template
+	});
+	for (const [path, content] of Object.entries(generated)) await writeFile(join(root, path), content);
+	return {
+		root,
+		workspace
+	};
+}
+function toPackageName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function toDisplayName(dir) {
+	return basename(resolve(dir)).split(/[-_\s]+/).filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function isInDotWorkspace(dir) {
+	let current = dirname(dir);
+	while (true) {
+		if (existsSync(join(current, "pnpm-workspace.yaml"))) {
+			const runtimeManifest = join(current, "packages/runtime/package.json");
+			if (!existsSync(runtimeManifest)) return false;
+			return readPackageJson(runtimeManifest).name === "@monimesl/dot-runtime";
+		}
+		const parent = dirname(current);
+		if (parent === current) return false;
+		current = parent;
+	}
+}
+function templateDir(template) {
+	const example = join(cliRoot(), "../../examples", template);
+	return existsSync(example) ? example : join(cliRoot(), "dist/templates", template);
+}
+function cliVersion() {
+	return readPackageJson(join(cliRoot(), "package.json")).version;
+}
+function readPackageJson(path) {
+	return JSON.parse(readFileSync(path, "utf8"));
+}
+function cliRoot() {
+	return dirname(createRequire(import.meta.url).resolve("@monimesl/dot-cli/package.json"));
+}
+//#endregion
+//#region src/dot-root.ts
+function findDotRoot(dir) {
+	while (true) {
+		if (existsSync(join(dir, "dot.json"))) return dir;
+		const parent = dirname(dir);
+		if (parent === dir) return;
+		dir = parent;
+	}
+}
+//#endregion
+//#region src/create/page.ts
+async function createPage(path, cwd) {
+	if (!isPageId(path)) throw new CommandError(`"${path}" is not a page path. Use letters, digits, "-" and "_", with "/" between folders, such as "cart/checkout"`);
+	const root = findDotRoot(resolve(cwd));
+	if (root === void 0) throw new CommandError("There is no dot.json in this folder or any folder above it. Run this command inside a dot");
+	const dir = join(root, "pages", path);
+	if (existsSync(dir)) throw new CommandError(`pages/${path} already exists. Choose another path`);
+	await mkdir(dir, { recursive: true });
+	const files = [];
+	for (const [name, content] of Object.entries(PAGE_FILES)) {
+		const file = join(dir, name);
+		await writeFile(file, content);
+		files.push(file);
+	}
+	return {
+		dir,
+		files,
+		listing: await listPage(join(root, "dot.ts"), path)
+	};
+}
+async function listPage(dotFile, path) {
+	if (!existsSync(dotFile)) return "manual";
+	const source = await readFile(dotFile, "utf8");
+	let dot;
+	try {
+		dot = parseDotModule(source, dotFile);
+	} catch {
+		return "manual";
+	}
+	if (dot.pages.includes(path)) return "already";
+	const updated = withPage(source, dot.lastPage, path);
+	if (!listsPage(updated, dotFile, path)) return "manual";
+	await writeFile(dotFile, updated);
+	return "added";
+}
+function withPage(source, lastPage, path) {
+	const quote = source[lastPage.start] === "\"" ? "\"" : "'";
+	const page = `${quote}${path}${quote}`;
+	const lineStart = source.lastIndexOf("\n", lastPage.start - 1) + 1;
+	const indent = source.slice(lineStart, lastPage.start);
+	if (!/^\s*$/.test(indent)) return `${source.slice(0, lastPage.end)}, ${page}${source.slice(lastPage.end)}`;
+	const trailingComma = /^\s*,/.exec(source.slice(lastPage.end));
+	if (trailingComma) {
+		const end = lastPage.end + trailingComma[0].length;
+		return `${source.slice(0, end)}\n${indent}${page},${source.slice(end)}`;
+	}
+	return `${source.slice(0, lastPage.end)},\n${indent}${page}${source.slice(lastPage.end)}`;
+}
+function listsPage(source, dotFile, path) {
+	try {
+		return parseDotModule(source, dotFile).pages.includes(path);
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/create/package-manager.ts
+const PACKAGE_MANAGERS = [
+	"npm",
+	"pnpm",
+	"yarn",
+	"bun"
+];
+function isPackageManager(name) {
+	return PACKAGE_MANAGERS.includes(name);
+}
+function launchedBy(userAgent = process.env.npm_config_user_agent ?? "") {
+	return PACKAGE_MANAGERS.find((name) => userAgent.startsWith(`${name}/`)) ?? "npm";
+}
+function installedManagers(isInstalled = onPath) {
+	return PACKAGE_MANAGERS.filter(isInstalled);
+}
+function onPath(name) {
+	return spawnSync(name, ["--version"], {
+		stdio: "ignore",
+		shell: process.platform === "win32"
+	}).status === 0;
+}
+//#endregion
+//#region src/device/developer-key.ts
+function defaultDeveloperKeyPath() {
+	return process.env.DOT_DEVELOPER_KEY ?? join(homedir(), ".dot", "developer-key.pem");
+}
+function missingDeveloperKeyHint(path = defaultDeveloperKeyPath()) {
+	return `  There is no developer key at ${path}. Dash only opens signed links.\n  Make one with OpenSSL 3. macOS's built-in openssl can't, so first run brew install openssl:
+
+    mkdir -p ${dirname(path)} && openssl genpkey -algorithm ed25519 -out ${path}\n\n  Then run \`dotctl keys show\` and add the public key it prints to your Monime account.`;
+}
+async function loadDeveloperKey(path = defaultDeveloperKeyPath()) {
+	let pem;
+	try {
+		pem = await readFile(path, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+	const privateKey = createPrivateKey(pem);
+	if (privateKey.asymmetricKeyType !== "ed25519") throw new Error(`${path} is not an Ed25519 key. Make one with: openssl genpkey -algorithm ed25519 -out ${path}`);
+	return toDeveloperKey(privateKey);
+}
+function toDeveloperKey(privateKey) {
+	const raw = Buffer.from(createPublicKey(privateKey).export({ format: "jwk" }).x, "base64url");
+	return {
+		publicKey: raw.toString("base64"),
+		keyId: raw.subarray(0, 8).toString("hex"),
+		sign: (bytes) => sign(null, bytes, privateKey).toString("base64")
+	};
+}
+//#endregion
+//#region src/device/server.ts
+const DEVICE_SCHEME = "dotdev";
+const WAIT_MS = 25e3;
+const MAX_LOG_BYTES = 1048576;
+const LINK_LIFETIME_SECONDS = 43200;
+const BUILD_MAC_HEADER = "dot-build-mac";
+function signedLinkMessage(server, secret, expires, keyId) {
+	return [
+		"dotdev-connect",
+		server,
+		secret,
+		String(expires),
+		keyId
+	].join("\n");
+}
+function deviceToken(secret) {
+	return createHmac("sha256", Buffer.from(secret, "base64url")).update("dotdev-token", "utf8").digest("base64url");
+}
+function buildMac(secret, body) {
+	return createHmac("sha256", Buffer.from(secret, "base64url")).update(`dotdev-build\n${body}`, "utf8").digest("base64url");
+}
+async function startDeviceServer({ address = localNetworkAddress(), port = 0, onLog = () => {}, onConnect = () => {}, developerKey } = {}) {
+	if (address === void 0) throw new Error("This computer has no local network address, so devices can't reach it. Connect to a network and try again");
+	const secret = randomBytes(16).toString("base64url");
+	const token = deviceToken(secret);
+	let signature = null;
+	let build = { files: /* @__PURE__ */ new Map() };
+	let generation = 0;
+	let hotSince = 0;
+	let error = null;
+	const waiting = /* @__PURE__ */ new Set();
+	const connected = /* @__PURE__ */ new Set();
+	const announce = () => {
+		generation += 1;
+		for (const wake of waiting) wake();
+	};
+	const server = createServer((request, response) => {
+		const from = request.socket.remoteAddress ?? "a device";
+		if (request.method === "GET" && request.url === "/dev/link") {
+			if (signature) sendJson(response, signature);
+			else response.writeHead(404).end();
+			return;
+		}
+		if (!isAuthorized(request, token)) {
+			response.writeHead(401).end();
+			return;
+		}
+		const url = new URL(request.url ?? "/", "http://device");
+		const path = url.pathname;
+		if (request.method === "GET" && path === "/dev/build") {
+			if (!connected.has(from)) {
+				connected.add(from);
+				onConnect(from);
+			}
+			const files = Object.fromEntries([...build.files].map(([name, file]) => [name, file.hash]));
+			const body = JSON.stringify({
+				generation,
+				hotSince,
+				files,
+				error
+			});
+			response.writeHead(200, {
+				"content-type": "application/json",
+				[BUILD_MAC_HEADER]: buildMac(secret, body)
+			}).end(body);
+		} else if (request.method === "GET" && path.startsWith("/dev/files/")) {
+			if (url.searchParams.get("generation") !== String(generation)) {
+				response.writeHead(409).end();
+				return;
+			}
+			const name = path.slice(11).split("/").map(decodeURIComponent).join("/");
+			const file = build.files.get(name);
+			if (!file) {
+				response.writeHead(404).end();
+				return;
+			}
+			response.writeHead(200, { "content-type": "application/octet-stream" }).end(file.bytes);
+		} else if (request.method === "GET" && path === "/dev/changes") waitForChange(response, Number(url.searchParams.get("after")));
+		else if (request.method === "POST" && path === "/dev/log") readText(request).then((text) => {
+			for (const line of text.split("\n")) onLog(line, from);
+			response.writeHead(204).end();
+		}).catch(() => response.writeHead(413).end());
+		else response.writeHead(404).end();
+	});
+	const waitForChange = (response, after) => {
+		if (generation > after) {
+			sendJson(response, { generation });
+			return;
+		}
+		const wake = () => {
+			clearTimeout(timer);
+			waiting.delete(wake);
+			sendJson(response, { generation });
+		};
+		const timer = setTimeout(() => {
+			waiting.delete(wake);
+			response.writeHead(204).end();
+		}, WAIT_MS);
+		waiting.add(wake);
+		response.on("close", () => {
+			clearTimeout(timer);
+			waiting.delete(wake);
+		});
+	};
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(port, address, () => resolve());
+	});
+	const { port: listening } = server.address();
+	const origin = `http://${address}:${listening}`;
+	if (developerKey) {
+		const expires = Math.floor(Date.now() / 1e3) + LINK_LIFETIME_SECONDS;
+		const keyId = developerKey.keyId;
+		const message = signedLinkMessage(origin, secret, expires, keyId);
+		signature = {
+			expires,
+			keyId,
+			sig: developerKey.sign(Buffer.from(message, "utf8"))
+		};
+	}
+	return {
+		link: `${DEVICE_SCHEME}://connect?server=${encodeURIComponent(origin)}&secret=${secret}`,
+		async publish(dir, { hot = false } = {}) {
+			build = await readBuild(dir);
+			error = null;
+			announce();
+			if (!hot) hotSince = generation;
+		},
+		fail(message) {
+			error = message;
+			announce();
+		},
+		close() {
+			for (const wake of waiting) wake();
+			return new Promise((resolve) => {
+				server.close(() => resolve());
+				server.closeAllConnections();
+			});
+		}
+	};
+}
+function localNetworkAddress() {
+	for (const addresses of Object.values(networkInterfaces())) for (const candidate of addresses ?? []) if (candidate.family === "IPv4" && !candidate.internal) return candidate.address;
+}
+async function readBuild(dir) {
+	const files = /* @__PURE__ */ new Map();
+	const entries = await readdir(dir, {
+		recursive: true,
+		withFileTypes: true
+	});
+	for (const entry of entries) {
+		if (!entry.isFile() || entry.name.endsWith(".map") || entry.name.endsWith(".zip")) continue;
+		const path = join(entry.parentPath, entry.name);
+		const bytes = await readFile(path);
+		const hash = createHash("sha256").update(bytes).digest("base64url");
+		files.set(relative(dir, path).split(sep).join("/"), {
+			bytes,
+			hash
+		});
+	}
+	return { files };
+}
+function isAuthorized(request, token) {
+	const given = Buffer.from(request.headers.authorization ?? "");
+	const expected = Buffer.from(`Bearer ${token}`);
+	return given.length === expected.length && timingSafeEqual(given, expected);
+}
+function sendJson(response, body) {
+	response.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(body));
+}
+async function readText(request) {
+	const chunks = [];
+	let size = 0;
+	for await (const chunk of request) {
+		size += chunk.length;
+		if (size > MAX_LOG_BYTES) throw new Error(`A device sent more than ${MAX_LOG_BYTES} bytes of log at once`);
+		chunks.push(chunk);
+	}
+	return Buffer.concat(chunks).toString("utf8");
+}
+//#endregion
+//#region src/simulator.ts
+function startDotSimulator(project, outDir, port) {
+	return startSimulator({
+		dotDir: outDir,
+		reactHostDir: installedRuntime(project.root).react.dir,
+		name: project.dotJson.name,
+		port,
+		storageDir: join(project.root, ".dot", "files")
+	});
+}
+//#endregion
+//#region src/dev.ts
+const CHANGE_DEBOUNCE_MS = 50;
+async function dev({ port, device, ...options }) {
+	const project = await loadProject(options.root);
+	const outDir = resolve(project.root, options.outDir ?? "dist");
+	const buildOptions = {
+		mode: "development",
+		...options,
+		outDir
+	};
+	const buildApp = async () => {
+		const started = performance.now();
+		try {
+			printWarnings(await build(buildOptions));
+			printBuildTime(started);
+			return null;
+		} catch (error) {
+			const message = describeError(error).replaceAll(project.root + sep, "");
+			console.error(`error: ${message}`);
+			return message;
+		}
+	};
+	const firstError = await buildApp();
+	const simulator = await startDotSimulator(project, outDir, port);
+	if (firstError) simulator.error(firstError);
+	console.log(`\n  Simulator running at: ${simulator.url}\n`);
+	let devices;
+	if (device) {
+		const developerKey = await loadDeveloperKey();
+		devices = await startDeviceServer({
+			developerKey,
+			onConnect: (from) => console.log(`A device connected from ${from}`),
+			onLog: (line) => console.log(`device ${line}`)
+		});
+		if (firstError) devices.fail(firstError);
+		else await devices.publish(outDir);
+		printDeviceLink(devices.link);
+		if (developerKey) console.log(`  Signed with developer key ${developerKey.keyId}\n`);
+		else console.log(`${missingDeveloperKeyHint()}\n`);
+	}
+	const changed = /* @__PURE__ */ new Set();
+	const pagesDir = join(project.root, PAGES_DIR) + sep;
+	const rebuilds = new RebuildQueue(async () => {
+		const building = [...changed];
+		const error = await buildApp();
+		if (error) {
+			simulator.error(error);
+			devices?.fail(error);
+			return;
+		}
+		for (const path of building) changed.delete(path);
+		const hot = building.every((path) => path.startsWith(pagesDir));
+		if (hot) simulator.hotReload();
+		else simulator.reload();
+		await devices?.publish(outDir, { hot });
+	});
+	let debounceTimer;
+	const watcher = watch(project.root, { recursive: true }, (_event, file) => {
+		if (!file || isIgnored(file)) return;
+		const path = resolve(project.root, file);
+		if (path === outDir || path.startsWith(outDir + sep)) return;
+		changed.add(path);
+		clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(() => {
+			console.log(`Changed ${relative(project.root, path)}`);
+			rebuilds.request();
+		}, CHANGE_DEBOUNCE_MS);
+	});
+	return async () => {
+		clearTimeout(debounceTimer);
+		watcher.close();
+		await Promise.all([simulator.close(), devices?.close()]);
+	};
+}
+function printDeviceLink(link) {
+	console.log("  To open it in Dash, turn on Enable Dot Debugging in Developer Settings.\n  Then tap Live Test on the Dots tab and scan this code.\n");
+	console.log(renderUnicodeCompact(link, { border: 1 }).replace(/^/gm, "  "));
+	console.log(`\n  ${link}\n`);
+}
+var RebuildQueue = class {
+	#rebuild;
+	#building = false;
+	#changedWhileBuilding = false;
+	constructor(rebuild) {
+		this.#rebuild = rebuild;
+	}
+	request() {
+		if (this.#building) {
+			this.#changedWhileBuilding = true;
+			return;
+		}
+		this.#build();
+	}
+	async #build() {
+		this.#building = true;
+		this.#changedWhileBuilding = false;
+		try {
+			await this.#rebuild();
+		} finally {
+			this.#building = false;
+		}
+		if (this.#changedWhileBuilding) this.request();
+	}
+};
+function isIgnored(file) {
+	return file.split(/[\\/]/).some((segment) => {
+		if (segment === ".env" || segment.startsWith(".env.")) return false;
+		return segment === "node_modules" || segment.startsWith(".");
+	});
+}
+//#endregion
+//#region src/preview.ts
+async function preview({ port, ...options }) {
+	const project = await loadProject(options.root);
+	const outDir = resolve(project.root, options.outDir ?? "dist");
+	const started = performance.now();
+	printWarnings(await build({
+		...options,
+		outDir,
+		mode: "production"
+	}));
+	printBuildTime(started);
+	const simulator = await startDotSimulator(project, outDir, port);
+	console.log(`\n  Simulator running at: ${simulator.url}\n`);
+	return simulator;
+}
+//#endregion
+//#region src/prompts.ts
+const TERMINAL = {
+	input: process.stdin,
+	output: process.stdout
+};
+const ERASE_BELOW = "\x1B[0J";
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+const cursorUp = (lines) => `\x1b[${lines}A`;
+async function select(question, choices, fallback, { input, output } = TERMINAL) {
+	if (!input.isTTY) return fallback;
+	let current = Math.max(0, choices.findIndex((choice) => choice.value === fallback));
+	const width = choices.some((choice) => choice.hint) ? Math.max(...choices.map((choice) => choice.value.length)) : 0;
+	const row = (choice, index) => {
+		const name = choice.value.padEnd(width);
+		const hint = choice.hint ? styleText("dim", `  ${choice.hint}`) : "";
+		const defaultMark = choice.value === fallback ? styleText("green", " (default)") : "";
+		if (index === current) return `${styleText("cyan", "❯")} ${styleText(["cyan", "bold"], name)}${hint}${defaultMark}`;
+		return `  ${name}${hint}${defaultMark}`;
+	};
+	let drawnLines = 0;
+	const draw = (lines) => {
+		output.write(`${drawnLines ? cursorUp(drawnLines) : ""}${ERASE_BELOW}${lines.join("\n")}\n`);
+		drawnLines = lines.length;
+	};
+	const drawList = () => draw([`${styleText("bold", question)} ${styleText("dim", "↑/↓ to move, Enter to choose")}`, ...choices.map(row)]);
+	emitKeypressEvents(input);
+	input.setRawMode(true);
+	input.resume();
+	output.write(HIDE_CURSOR);
+	drawList();
+	return new Promise((resolve) => {
+		const onKeypress = (_text, key) => {
+			if (key.ctrl && key.name === "c") {
+				output.write(`${SHOW_CURSOR}\n`);
+				process.exit(130);
+			}
+			if (key.name === "up" || key.name === "k") {
+				current = (current - 1 + choices.length) % choices.length;
+				drawList();
+			} else if (key.name === "down" || key.name === "j") {
+				current = (current + 1) % choices.length;
+				drawList();
+			} else if (key.name === "return" || key.name === "enter") {
+				const { value } = choices[current];
+				input.off("keypress", onKeypress);
+				input.setRawMode(false);
+				input.pause();
+				draw([`${styleText("bold", question)} ${styleText("cyan", value)}`]);
+				output.write(SHOW_CURSOR);
+				resolve(value);
+			}
+		};
+		input.on("keypress", onKeypress);
+	});
+}
+async function confirm(question, fallback, terminal = TERMINAL) {
+	if (!terminal.input.isTTY) return false;
+	return await select(question, [{ value: "Yes" }, { value: "No" }], fallback ? "Yes" : "No", terminal) === "Yes";
+}
+async function ask(question, fallback, { input, output } = TERMINAL) {
+	if (!input.isTTY) return fallback;
+	const hint = fallback ? styleText("dim", ` (default: ${fallback})`) : "";
+	const readline = createInterface({
+		input,
+		output
+	});
+	try {
+		return (await readline.question(`${styleText("bold", question)}${hint}: `)).trim() || fallback;
+	} catch (error) {
+		if (error.name === "AbortError") return;
+		throw error;
+	} finally {
+		readline.close();
+	}
+}
+//#endregion
+//#region src/cli.ts
+const USAGE = `Usage:
+  dotctl create [dir] [--name <name>] [--template <starter|showcase>]
+                [--pm <npm|pnpm|yarn|bun>]
+                                        Create a dot. Asks for its name and template:
+                                        starter is one page to build on, showcase has a
+                                        page for each feature
+  dotctl create page <path>             Add a page to the dot you are in. Writes
+                                        pages/<path>/ with view.dml, state.ts and controller.ts
+  dotctl build [root] [options]         Build the minified bundles the host app runs
+  dotctl dev [root] [options]           Run the dot in the browser simulator and rebuild on
+                                        every change
+  dotctl preview [root] [options]       Build as \`build\` does, then run that build in the
+                                        browser simulator, exactly as the host app gets it
+  dotctl keys show                      Show this computer's developer key: its public key
+                                        and key ID. The key signs the links that
+                                        \`dev --device\` shows, so Dash will open them
+  dotctl lsp [--stdio]                  Start the .dml language server for editors. It talks
+                                        over stdin and stdout
+
+Options:
+  --out-dir <dir>       Output directory (default: <root>/dist)
+  --conditions <list>   Extra export conditions, separated by commas
+  --port <port>         Simulator port for \`dev\` and \`preview\`. If it is taken, the
+                        next free port is used (default: ${DEFAULT_PORT})
+  --device              With \`dev\`, also serve the dot to the Dot example apps on phones
+                        on your local network, through a link and QR code. The apps
+                        reload after each build
+  -h, --help            Show this message`;
+async function main(argv) {
+	const { values, positionals } = parseArgs({
+		args: argv,
+		allowPositionals: true,
+		options: {
+			"out-dir": { type: "string" },
+			conditions: { type: "string" },
+			port: { type: "string" },
+			device: { type: "boolean" },
+			name: { type: "string" },
+			template: { type: "string" },
+			pm: { type: "string" },
+			help: {
+				type: "boolean",
+				short: "h"
+			},
+			stdio: { type: "boolean" }
+		}
+	});
+	const [command, target, pagePath] = positionals;
+	if (command === "lsp" && !values.help) {
+		const { serveStdio } = await import("./server-Dbrgkelo.js");
+		serveStdio();
+		return new Promise(() => {});
+	}
+	if (command === "keys" && !values.help) return keys(target);
+	if (command === "create" && target === "page" && !values.help) return addPage(pagePath);
+	if (command === "create" && !values.help) return createApp(target, values.name, values.template, values.pm);
+	if (values.help || command !== "build" && command !== "dev" && command !== "preview") {
+		console.log(USAGE);
+		return values.help ? 0 : 1;
+	}
+	const port = values.port === void 0 ? void 0 : Number(values.port);
+	if (port !== void 0 && !Number.isInteger(port)) {
+		console.error(`--port must be a whole number, not "${values.port}"`);
+		return 1;
+	}
+	const options = { root: target ?? "." };
+	if (values["out-dir"] !== void 0) options.outDir = values["out-dir"];
+	if (values.conditions !== void 0) options.conditions = values.conditions.split(",");
+	if (command === "dev") {
+		const stop = await dev({
+			...options,
+			port,
+			device: values.device
+		});
+		await new Promise((resolve) => process.once("SIGINT", resolve));
+		await stop();
+		return 0;
+	}
+	if (command === "preview") {
+		if (values.device) {
+			console.error("--device only works with dotctl dev");
+			return 1;
+		}
+		const simulator = await preview({
+			...options,
+			port
+		});
+		await new Promise((resolve) => process.once("SIGINT", resolve));
+		await simulator.close();
+		return 0;
+	}
+	const started = performance.now();
+	const result = await build(options);
+	for (const file of result.files.filter((file) => !file.endsWith(".map"))) console.log(`  ${relative(process.cwd(), file)}`);
+	printWarnings(result);
+	printBuildTime(started);
+	return 0;
+}
+async function keys(action) {
+	if (action !== "show") {
+		console.error("Usage: dotctl keys show");
+		return 1;
+	}
+	const path = defaultDeveloperKeyPath();
+	const key = await loadDeveloperKey(path);
+	if (!key) {
+		console.error(missingDeveloperKeyHint(path));
+		return 1;
+	}
+	console.log(`\n  Public key: ${key.publicKey}\n  Key ID:     ${key.keyId}\n`);
+	return 0;
+}
+async function addPage(path) {
+	if (path === void 0) {
+		console.error("Give the page a path, such as: dotctl create page cart/checkout");
+		return 1;
+	}
+	if (path.startsWith("/")) path = path.substring(1);
+	if (path.endsWith("/")) path = path.substring(0, path.length - 1);
+	const { files, listing } = await createPage(path, process.cwd());
+	for (const file of files) console.log(`  ${relative(process.cwd(), file)}`);
+	if (listing === "added") console.log(`\nListed '${path}' in dot.ts.`);
+	else if (listing === "manual") console.log(`\nAdd it to the pages in dot.ts so it gets built: defineDot({ pages: [..., '${path}'] })`);
+	return 0;
+}
+async function createApp(dir, name, templateFlag, packageManagerFlag) {
+	if (templateFlag !== void 0 && !isTemplate(templateFlag)) {
+		console.error(`--template must be one of ${TEMPLATES.join(", ")}`);
+		return 1;
+	}
+	if (packageManagerFlag !== void 0 && !isPackageManager(packageManagerFlag)) {
+		console.error(`--pm must be one of ${PACKAGE_MANAGERS.join(", ")}`);
+		return 1;
+	}
+	name ??= await ask("Dot name", dir ? toDisplayName(dir) : "Dot");
+	if (!name) {
+		console.error("The dot needs a name. Pass one with: dotctl create [dir] --name \"My Dot\"");
+		return 1;
+	}
+	const template = templateFlag ?? await chooseTemplate();
+	const { root, workspace } = await create({
+		name,
+		dir: dir ?? toPackageName(name),
+		template
+	});
+	const path = relative(process.cwd(), root) || ".";
+	console.log(`\nCreated ${name} in ${path}`);
+	if (workspace) console.log("It is inside the Dot repository, so it uses the workspace packages.");
+	let packageManager = workspace ? "pnpm" : packageManagerFlag ?? launchedBy();
+	console.log();
+	if (await confirm("Install and start it now?", true)) {
+		if (!workspace && !packageManagerFlag) packageManager = await choosePackageManager(packageManager);
+		if (await run(packageManager, ["install"], root) === 0) return run(packageManager, ["run", "dev"], root);
+		console.error(`\n${packageManager} install failed. Fix the problem above, then run the steps below.`);
+	}
+	console.log(`\nNext:\n\n  cd ${path}\n  ${packageManager} install\n  ${packageManager} run dev\n`);
+	return 0;
+}
+function run(command, args, cwd) {
+	return new Promise((resolvePromise, reject) => {
+		const child = spawn(command, args, {
+			cwd,
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		child.on("error", reject);
+		child.on("exit", (code) => resolvePromise(code ?? 1));
+	});
+}
+function chooseTemplate() {
+	console.log();
+	return select("Template?", TEMPLATES.map((template) => ({
+		value: template,
+		hint: TEMPLATE_HINTS[template]
+	})), "starter");
+}
+async function choosePackageManager(suggested) {
+	const installed = installedManagers();
+	if (installed.length < 2) return installed[0] ?? suggested;
+	const fallback = installed.includes(suggested) ? suggested : installed[0];
+	return select("Package manager?", installed.map((manager) => ({ value: manager })), fallback);
+}
+main(process.argv.slice(2)).then((code) => process.exit(code), (error) => {
+	console.error(`error: ${describeError(error)}`);
+	process.exit(1);
+});
+//#endregion
+export { findDotRoot as t };
+
+//# sourceMappingURL=cli.js.map