@monimesl/dot-cli 0.1.0-alpha.2 → 0.1.0-alpha.4

package/README.md

@@ -4,23 +4,42 @@ The `dotctl` command: build mini apps and run them in the simulator. Platform ta
 packaging, signing and publishing mini apps will live here too.
 
 ```sh
-dotctl create [dir]  # scaffold a dot (asks for its name), with a sample home page
-dotctl build [root]   # compile the dot into dist/ui and dist/logic, minified
-dotctl dev [root]     # build, open it in the browser simulator, rebuild and reload on change
+dotctl create [dir]       # scaffold a dot (asks for its name and template)
+dotctl create page <path> # add a page to the dot you are in
+dotctl build [root]       # compile the dot into dist/ui and dist/logic, minified
+dotctl dev [root]         # build, run it in the browser simulator, and reload it on each change
+dotctl lsp                # the .dml language server, which editors start
 ```
 
-| Option                | Applies to | What it does                                            |
-| --------------------- | ---------- | ------------------------------------------------------- |
-| `--out-dir <dir>`     | both       | Output directory (default: `<root>/dist`)               |
-| `--conditions <list>` | both       | Extra export conditions, such as `@monimesl/dot-source` |
-| `--port <port>`       | `dev`      | Simulator port (default: `3680`, or the next free one)  |
+| Option                | Applies to | What it does                                                             |
+| --------------------- | ---------- | ------------------------------------------------------------------------ |
+| `--out-dir <dir>`     | both       | Output directory (default: `<root>/dist`)                                |
+| `--conditions <list>` | both       | Extra export conditions, such as `@monimesl/dot-source`                  |
+| `--port <port>`       | `dev`      | Simulator port (default: `3680`, or the next free one)                   |
+| `--device`            | `dev`      | Also serve the dot to the Dot example apps on phones, through a QR code  |
+| `--name <name>`       | `create`   | The dot's name, instead of asking                                        |
+| `--template <name>`   | `create`   | `starter` (one page to build on, the default) or `showcase` (every page) |
+| `--pm <name>`         | `create`   | The package manager to install with: npm, pnpm, yarn or bun              |
 
 ## `dotctl create`
 
-Asks for the dot's name (`Dot` by default, or pass `--name`) and creates a self-contained project
-in `dir` (by default, the name in kebab case) with one page, `home`: a short welcome, localized for
-Sierra Leone, to a dot running inside Dash. The dot depends on `@monimesl/dot-runtime` and `@monimesl/dot-cli`; inside
-the Dot repository it uses the workspace packages instead. It then offers to install the
-dependencies and start the simulator inside the new dot, asking which of the installed package
-managers to use (npm, pnpm, yarn or bun; the one that launched `dotctl`, or npm, by default).
-`--pm <name>` answers that up front.
+Asks for the dot's name (`Dot` by default) and template, and creates a self-contained project in
+`dir` (by default, the name in kebab case): `starter` is one page to build on, and `showcase` a page
+for each feature. The dot depends on `@monimesl/dot-runtime` and `@monimesl/dot-cli`; inside the Dot
+repository it uses the workspace packages instead. It then offers to install the dependencies and
+start the simulator inside the new dot, asking which of the installed package managers to use (npm,
+pnpm, yarn or bun; the one that launched `dotctl`, or npm, by default).
+
+## `dotctl dev`
+
+Builds the dot, opens it in the browser simulator, and builds it again on each save:
+
+- A change to its pages (`pages/**`) runs in place: each open page keeps its state, and runs the new
+  code. A page whose initial state changed starts over from the new one.
+- Any other change, such as to `dot.ts`, `dot.json`, `.env` or `statics/`, starts the dot again, on
+  the pages it had open.
+- A failed build shows its error, and the dot keeps its last good build.
+
+With `--device`, it also serves each build on the local network to the Dot example apps. It prints a
+QR code to scan with one, which then follows the dot in the same way: see
+[the example apps](../hosts/native/README.md#the-example-apps).

package/dist/cli.js

@@ -3,13 +3,52 @@ import { spawn, spawnSync } from "node:child_process";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
-import { CompileError, build, installedRuntime, loadProject } from "@monimesl/dot-compiler";
+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, writeFile } from "node:fs/promises";
+import { cp, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { DmlParseError } from "@monimesl/dot-dml-parser";
-import { ScriptParseError } from "@monimesl/dot-script-parser";
+import { ScriptParseError, parseDotModule } from "@monimesl/dot-script-parser";
+import { isPageId } from "@monimesl/dot-core";
+import { renderUnicodeCompact } from "uqr";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { networkInterfaces } from "node:os";
+//#region src/report.ts
+/** A mistake in how a command was used, which its message alone explains. */
+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"];
+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",
@@ -23,13 +62,8 @@ function projectFiles(options) {
 		"package.json": packageJson(options),
 		"tsconfig.json": tsconfig(options),
 		".gitignore": "node_modules/\ndist/\n# Types generated by dotctl\n.dot/\n",
-		"dot.json": json({
-			$schema: DOT_JSON_SCHEMA,
-			id: `com.example.${idWord(options.packageName)}`,
-			name: options.name,
-			version: "0.1.0"
-		}),
-		"README.md": readme(options.name)
+		"dot.json": dotJson(options),
+		"README.md": readme(options)
 	};
 }
 function packageJson({ packageName, dotVersion, workspace }) {
@@ -73,7 +107,29 @@ function tsconfig({ workspace }) {
 		]
 	});
 }
-function readme(name) {
+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: [
+		"api.github.com",
+		"avatars.githubusercontent.com",
+		"httpbin.org"
+	] };
+	return json(dot);
+}
+const TEMPLATE_READMES = {
+	starter: `It starts with one page, \`index\`: a greeting from \`.env\` and a count to tap. Change it,
+and add pages as the dot grows. \`npx dotctl create my-tour --template showcase\` makes a dot with a
+page for each feature, to read how each is done.`,
+	showcase: `It starts as a showcase: \`index\` lists a page for each feature, from layout, text, images and
+inputs to state, navigation, and Dash's alerts, network and files. Read a page to see how it's
+done, then delete the ones you don't need, from \`pages/\` and from \`dot.ts\`.`
+};
+function readme({ name, template }) {
 	return `# ${name}
 
 A dot: a mini app that runs inside Dash.
@@ -85,20 +141,21 @@ npm run build   # build it for Dash
 \`\`\`
 
 Each page is a folder under \`pages/\` with three files: \`view.dml\` (what it shows),
-\`state.ts\` (what it starts with) and \`controller.ts\` (how it changes). List new pages in
-\`dot.ts\`; the first one is where the dot starts.
+\`state.ts\` (what it starts with) and \`controller.ts\` (how it changes). A page's markup is one
+root \`<View>\` with everything else inside it. \`npx dotctl create page <path>\` adds a page, such
+as \`cart/checkout\`, with the three files to start from, and lists it in \`dot.ts\`. The first page
+there is where the dot starts.
 
 \`dot.json\` describes the dot to Dash. Change its \`id\` from \`com.example.…\` to a reverse domain
-name you own before you publish: it can't change afterwards. Your editor completes the other fields
-from the schema it points to.
+name you own before you publish: it can't change afterwards. Its \`network.hosts\` lists every host
+the dot sends requests to with \`dash.network\`; requests to any other fail. Your editor completes
+the other fields from the schema it points to.
 
-\`.env\` holds public configuration: variables named \`DOT_PUBLIC_…\`, which the service reads as
-\`env.DOT_PUBLIC_…\`. They are built into the dot, so anyone who has it can read them: never put a
-secret there. \`.env.development\` and \`.env.production\` override it for \`dev\` and \`build\`.
+\`.env\` holds public configuration, which the service reads as \`env.GREETING\`. Every variable
+there is built into the dot, so anyone who has it can read them: never put a secret there.
+\`.env.development\` and \`.env.production\` override it for \`dev\` and \`build\`.
 
-It starts as a counter with two pages. \`index\` counts taps with mutations. \`help/tips\` shows
-navigation: each page you open goes on top of the stack, Back returns to the one below, and the
-trail at the top shows where you are.
+${TEMPLATE_READMES[template]}
 `;
 }
 function idWord(packageName) {
@@ -106,20 +163,21 @@ function idWord(packageName) {
 }
 //#endregion
 //#region src/create/create.ts
-async function create({ name, dir }) {
+async function create({ name, dir, template = "starter" }) {
 	const root = resolve(dir);
-	if (existsSync(root) && readdirSync(root).length > 0) throw new Error(`${dir} already exists and is not empty`);
+	if (existsSync(root) && readdirSync(root).length > 0) throw new CommandError(`${dir} already exists and is not empty`);
 	const packageName = toPackageName(name);
-	if (!packageName) throw new Error(`"${name}" needs at least one letter or digit`);
+	if (!packageName) throw new CommandError(`"${name}" needs at least one letter or digit`);
 	const workspace = isInDotWorkspace(root);
-	const template = templateDir();
+	const source = templateDir(template);
 	await mkdir(root, { recursive: true });
-	for (const path of TEMPLATE_FILES) await cp(join(template, path), join(root, path), { 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
+		workspace,
+		template
 	});
 	for (const [path, content] of Object.entries(generated)) await writeFile(join(root, path), content);
 	return {
@@ -146,9 +204,9 @@ function isInDotWorkspace(dir) {
 		current = parent;
 	}
 }
-function templateDir() {
-	const example = join(cliRoot(), "../../examples/counter");
-	return existsSync(example) ? example : join(cliRoot(), "dist/template");
+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;
@@ -160,6 +218,74 @@ function cliRoot() {
 	return dirname(createRequire(import.meta.url).resolve("@monimesl/dot-cli/package.json"));
 }
 //#endregion
+//#region src/create/page.ts
+/**
+* Adds a page to the dot around `cwd`: its folder under pages/, with its three files, listed last in
+* dot.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 here or in a folder above: run it inside a dot");
+	const dir = join(root, "pages", path);
+	if (existsSync(dir)) throw new CommandError(`pages/${path} already exists`);
+	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;
+	}
+}
+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/package-manager.ts
 const PACKAGE_MANAGERS = [
 	"npm",
@@ -183,25 +309,152 @@ function onPath(name) {
 	}).status === 0;
 }
 //#endregion
-//#region src/report.ts
-function describeError(error) {
-	if (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.`;
+//#region src/device/server.ts
+const DEVICE_SCHEME = "dotdev";
+const WAIT_MS = 25e3;
+const MAX_LOG_BYTES = 1048576;
+async function startDeviceServer({ address = localNetworkAddress(), port = 0, onLog = () => {}, onConnect = () => {} } = {}) {
+	if (address === void 0) throw new Error("This computer has no local network address for devices to reach it on");
+	const token = randomBytes(18).toString("base64url");
+	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 (!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]));
+			sendJson(response, {
+				generation,
+				hotSince,
+				files,
+				error
+			});
+		} 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}`;
+	return {
+		link: `${DEVICE_SCHEME}://connect?server=${encodeURIComponent(origin)}&token=${token}`,
+		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 error instanceof Error ? error.stack ?? error.message : String(error);
+	return { files };
 }
-function printWarnings({ warnings }) {
-	for (const warning of warnings) console.warn(`warning: ${warning.message}`);
+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 printBuildTime(startedAt) {
-	console.log(`Built in ${Math.round(performance.now() - startedAt)}ms`);
+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("Too much log at once");
+		chunks.push(chunk);
+	}
+	return Buffer.concat(chunks).toString("utf8");
 }
 //#endregion
 //#region src/dev.ts
 const CHANGE_DEBOUNCE_MS = 50;
-async function dev({ port, ...options }) {
+async function dev({ port, device, ...options }) {
 	const project = await loadProject(options.root);
 	const outDir = resolve(project.root, options.outDir ?? "dist");
 	const buildOptions = {
@@ -226,20 +479,43 @@ async function dev({ port, ...options }) {
 		dotDir: outDir,
 		reactHostDir: installedRuntime(project.root).react.dir,
 		name: project.dotJson.name,
-		port
+		port,
+		storageDir: join(project.root, ".dot", "files")
 	});
 	if (firstError) simulator.error(firstError);
 	console.log(`\n  Simulator running at: ${simulator.url}\n`);
+	let devices;
+	if (device) {
+		devices = await startDeviceServer({
+			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);
+	}
+	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);
+		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)}`);
@@ -249,9 +525,16 @@ async function dev({ port, ...options }) {
 	return async () => {
 		clearTimeout(debounceTimer);
 		watcher.close();
-		await simulator.close();
+		await Promise.all([simulator.close(), devices?.close()]);
 	};
 }
+function printDeviceLink(link) {
+	console.log("  Scan this in a Dot example app on a phone:\n");
+	console.log(renderUnicodeCompact(link, { border: 2 }).replace(/^/gm, "  "));
+	console.log(`\n  Or open the link on a device, an emulator or a simulator:\n\n  ${link}\n`);
+	console.log(`  Android emulator: adb shell am start -a android.intent.action.VIEW -d '${link}'`);
+	console.log(`  iOS Simulator:    xcrun simctl openurl booted '${link}'\n`);
+}
 var RebuildQueue = class {
 	#rebuild;
 	#building = false;
@@ -286,16 +569,25 @@ function isIgnored(file) {
 //#endregion
 //#region src/cli.ts
 const USAGE = `Usage:
-  dotctl create [dir] [--name <name>] [--pm <npm|pnpm|yarn|bun>]
-                                        Create a dot (asks for its name)
+  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 a page
+                                        for each feature
+  dotctl create page <path>             Add a page to the dot you are in: 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 in the browser simulator, rebuilding on change
+  dotctl lsp [--stdio]                  Serve .dml files to an editor over the Language Server
+                                        Protocol, on stdin and stdout
 
 Options:
   --out-dir <dir>       Output directory (default: <root>/dist)
   --conditions <list>   Extra export conditions, comma separated
   --port <port>         Simulator port for \`dev\`; the next free one is used if taken
                         (default: ${DEFAULT_PORT})
+  --device              With \`dev\`, also serve the dot to the Dot example apps on phones on
+                        the local network, through a link and QR code; they reload on each build
   -h, --help            Show this message`;
 async function main(argv) {
 	const { values, positionals } = parseArgs({
@@ -305,16 +597,25 @@ async function main(argv) {
 			"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] = positionals;
-	if (command === "create" && !values.help) return createApp(target, values.name, values.pm);
+	const [command, target, pagePath] = positionals;
+	if (command === "lsp" && !values.help) {
+		const { serveStdio } = await import("./server-DFOUQnLA.js");
+		serveStdio();
+		return new Promise(() => {});
+	}
+	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") {
 		console.log(USAGE);
 		return values.help ? 0 : 1;
@@ -330,7 +631,8 @@ async function main(argv) {
 	if (command === "dev") {
 		const stop = await dev({
 			...options,
-			port
+			port,
+			device: values.device
 		});
 		await new Promise((resolve) => process.once("SIGINT", resolve));
 		await stop();
@@ -343,7 +645,24 @@ async function main(argv) {
 	printBuildTime(started);
 	return 0;
 }
-async function createApp(dir, name, packageManagerFlag) {
+async function addPage(path) {
+	if (path === void 0) {
+		console.error("Which page? dotctl create page <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(`\nList it in dot.ts to build it: 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;
@@ -353,9 +672,11 @@ async function createApp(dir, name, packageManagerFlag) {
 		console.error("A dot needs a name: dotctl create [dir] --name \"My Dot\"");
 		return 1;
 	}
+	const template = templateFlag ?? await chooseTemplate();
 	const { root, workspace } = await create({
 		name,
-		dir: dir ?? toPackageName(name)
+		dir: dir ?? toPackageName(name),
+		template
 	});
 	const path = relative(process.cwd(), root) || ".";
 	console.log(`\nCreated ${name} in ${path}`);
@@ -403,15 +724,23 @@ async function readAnswer(prompt, fallback) {
 		readline.close();
 	}
 }
+async function chooseTemplate() {
+	if (!process.stdin.isTTY) return "starter";
+	console.log("\nTemplates:\n  starter   one page to build on\n  showcase  a page for each feature, to read");
+	return chooseOne("Template?", TEMPLATES, "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 chooseOne("Package manager?", installed, installed.includes(suggested) ? suggested : installed[0]);
+}
+async function chooseOne(question, options, fallback) {
 	while (true) {
-		const answer = await ask(`Package manager? ${installed.join(" / ")}`, fallback);
+		const answer = await ask(`${question} ${options.join(" / ")}`, fallback);
 		if (answer === void 0) return fallback;
-		if (isPackageManager(answer) && installed.includes(answer)) return answer;
-		console.log(`Choose one of ${installed.join(", ")}.`);
+		const chosen = options.find((option) => option === answer);
+		if (chosen) return chosen;
+		console.log(`Choose one of ${options.join(", ")}.`);
 	}
 }
 main(process.argv.slice(2)).then((code) => process.exit(code), (error) => {