kizlo 0.9.1 → 0.10.0

package/dist/cli/commands/dev.js

@@ -1,6 +1,6 @@
-import { createStack } from "../wp/docker.js";
-import { ensureGitignored, envGroups, groupDefault, mergeEnv, pickStackPort, withSpinner } from "../utils.js";
-import { hasDevStack, resolveDevConfig } from "../daemon/config.js";
+import { createStack, dockerHint, dockerStatus } from "../wp/docker.js";
+import { DEFAULT_ENV_KEYS, ensureGitignored, envGroups, groupDefault, mergeEnv, pickStackPort, withSpinner } from "../utils.js";
+import { resolveDevConfig, usesLocalWordPress } from "../daemon/config.js";
 import { bootstrapDev } from "../wp/dev.js";
 import { reapOrphans, registerSession, removeProjectContainers, spawnWatchdog, unregisterSession } from "../wp/session.js";
 import { syncSiteSettings } from "../wp/settings.js";
@@ -21,15 +21,13 @@ async function resolve$1(cwd) {
 	};
 }
 /**
-* The stack lifecycle subcommands (`stop`/`down`/`reset`) only act on a local WordPress
-* Docker stack. A bring-your-own-WordPress project (no `dev.path`) has no stack to manage,
-* so — rather than fall through to `resolveDevConfig`'s hard "`dev.path` is required" error —
-* print a plain note explaining there's nothing to do and exit cleanly. Returns true when a
-* local stack is configured and the caller may proceed.
+* The lifecycle subcommands (`stop`/`reset`) only act on local WordPress. A project pointing at its
+* own WordPress (no `dev.local`) has nothing to manage, so print a plain note and exit cleanly. Returns
+* true when local WordPress is configured and the caller may proceed.
 */
-async function requireDevStack(cwd) {
-	if (await hasDevStack(cwd)) return true;
-	note("No local WordPress stack is configured (`dev.path` is unset) — nothing to manage here.");
+async function requireLocalWordPress(cwd) {
+	if (await usesLocalWordPress(cwd)) return true;
+	note("This project doesn't run local WordPress — set `dev.local: true` in kizlo.config.ts to add it.");
 	return false;
 }
 /** A dim, untagged one-liner (no consola timestamp) for the clean dev output. */
@@ -39,7 +37,7 @@ function note(text) {
 }
 /**
 * Print the connection summary as an aligned, Next.js-style block. Shows the wp-admin URL on
-* the loopback ("Local") and — when the stack is installed on a LAN address rather than
+* the loopback ("Local") and — when local WordPress is installed on a LAN address rather than
 * localhost — on the network, so it can be opened from other devices. On a fresh install, also
 * show the one-time wp-admin password (it's never stored, so this is the only chance to see it).
 */
@@ -52,57 +50,56 @@ function printSummary(info) {
 	const width = Math.max(...rows.map(([label]) => label.length)) + 1;
 	const lines = ["", ...rows.map(([label, value]) => `   ${dim}- ${`${label}:`.padEnd(width)}${reset} ${cyan}${value}${reset}`)];
 	if (info.secrets) lines.push("", `   ${dim}admin login:${reset} ${info.username} / ${info.secrets.password}`, `   ${dim}save the password now — it's shown only once${reset}`);
-	else if (info.imported) lines.push("", `   ${dim}log in with your imported site's own credentials${reset}`);
 	if (info.seeded > 0) lines.push(`   ${dim}seeded ${info.seeded} fixture${info.seeded === 1 ? "" : "s"}${reset}`);
 	process.stdout.write(`${lines.join("\n")}\n`);
 }
 /**
-* Dev connection keys a fresh dev install must rewrite (the rest of `.env` is untouched). The
-* production `KIZLO_WORDPRESS_*` / `KIZLO_SITE_SECRET` keys live under their own names and are never
-* touched by `kizlo dev`, so pointing them at a real site survives booting the local stack.
+* Local-WordPress connection keys a fresh install must rewrite (the rest of `.env` is untouched). The
+* remote `KIZLO_WP_*` / `KIZLO_WP_SECRET` keys live under their own names and are never
+* touched by `kizlo dev`, so pointing them at a real site survives booting local WordPress.
 */
 const WP_ENV_KEYS = [
-	"KIZLO_DEV_WORDPRESS_URL",
-	"KIZLO_DEV_WORDPRESS_USERNAME",
-	"KIZLO_DEV_WORDPRESS_APPLICATION_PASSWORD"
+	"KIZLO_LOCAL_WP_URL",
+	"KIZLO_LOCAL_WP_USERNAME",
+	"KIZLO_LOCAL_WP_APP_PASSWORD"
 ];
 /** Read a key's value from raw `.env` content (first match, trimmed); undefined when absent or empty. */
 function readEnvValue(content, key) {
 	return content.match(new RegExp(`^\\s*${key}\\s*=\\s*(.*)$`, "m"))?.[1]?.trim() || void 0;
 }
 /**
-* The Kizlo backend URL from `.env` — the one key ending in `KIZLO_BACKEND_URL` (`KIZLO_BACKEND_URL`,
-* or a framework-prefixed `NEXT_PUBLIC_KIZLO_BACKEND_URL`). It's the handler mount the plugin delivers
+* The Kizlo backend URL from `.env` — the one key ending in `KIZLO_API_URL` (`KIZLO_API_URL`,
+* or a framework-prefixed `NEXT_PUBLIC_KIZLO_API_URL`). It's the handler mount the plugin delivers
 * webhook events to; its origin is the site's canonical URL. User-managed (init writes it), so dev
 * only reads it. Undefined before `kizlo init` has populated `.env`.
 */
 function readBaseUrl(content) {
-	return content.match(/^\s*[A-Z_]*KIZLO_BACKEND_URL\s*=\s*(.*)$/m)?.[1]?.trim() || void 0;
+	return content.match(/^\s*[A-Z_]*KIZLO_API_URL\s*=\s*(.*)$/m)?.[1]?.trim() || void 0;
 }
 /**
-* Rewrite the dev WordPress connection in `.env` after a fresh install. A reset (or first boot)
+* Rewrite the local WordPress connection in `.env` after a fresh install. A reset (or first boot)
 * wipes the database, so the previous application password — and possibly the port — no longer
 * match; without this the app keeps the stale credentials and REST auth fails. Only the three
 * connection keys are overwritten; everything else in `.env` is preserved, and the file is created
 * if absent. Gated by the caller on a minted `appPassword`, so a warm resume never churns it.
 *
-* `KIZLO_TARGET=dev` and `KIZLO_DEV_SITE_SECRET` are written too but kept out of the overwrite set, so a
-* value the user already set is preserved — booting the dev stack only fills them when absent. The
-* resolved dev secret (the existing one, or a freshly minted one) and the Kizlo server base URL are
-* returned so the caller can sync them into the plugin.
+* `KIZLO_CONNECT=local` and `KIZLO_LOCAL_WP_SECRET` are written too but kept out of the overwrite set,
+* so a value the user already set is preserved — booting local WordPress only fills them when absent.
+* The resolved local secret (the existing one, or a freshly minted one) and the Kizlo server base URL
+* are returned so the caller can sync them into the plugin.
 */
 function updateWpEnv(cfg, info) {
 	if (!info.appPassword) return void 0;
 	const envPath = join(cfg.configDir, ".env");
 	const existing = existsSync(envPath) ? readFileSync(envPath, "utf8") : "";
-	const siteSecret = readEnvValue(existing, "KIZLO_DEV_SITE_SECRET") ?? randomBytes(32).toString("hex");
+	const siteSecret = readEnvValue(existing, "KIZLO_LOCAL_WP_SECRET") ?? randomBytes(32).toString("hex");
 	const { content } = mergeEnv(existing, {
-		KIZLO_DEV_WORDPRESS_URL: info.url,
-		KIZLO_DEV_WORDPRESS_USERNAME: info.username,
-		KIZLO_DEV_WORDPRESS_APPLICATION_PASSWORD: info.appPassword,
-		KIZLO_DEV_SITE_SECRET: siteSecret,
-		KIZLO_TARGET: "dev"
-	}, new Set(WP_ENV_KEYS), envGroups("KIZLO_BACKEND_URL"));
+		KIZLO_LOCAL_WP_URL: info.url,
+		KIZLO_LOCAL_WP_USERNAME: info.username,
+		KIZLO_LOCAL_WP_APP_PASSWORD: info.appPassword,
+		KIZLO_LOCAL_WP_SECRET: siteSecret,
+		KIZLO_CONNECT: "local"
+	}, new Set(WP_ENV_KEYS), envGroups(DEFAULT_ENV_KEYS));
 	writeFileSync(envPath, content);
 	return {
 		siteSecret,
@@ -110,19 +107,19 @@ function updateWpEnv(cfg, info) {
 	};
 }
 /**
-* Re-point `KIZLO_DEV_WORDPRESS_URL` at the current dev URL on a warm resume, so a LAN address that
+* Re-point `KIZLO_LOCAL_WP_URL` at the current URL on a warm resume, so a LAN address that
 * changed since the last session (a new DHCP lease, a different network) doesn't leave the app talking
 * to a dead IP. Only this one key is rewritten — the credentials and secret from the fresh install are
 * preserved — and it's a no-op when `.env` is absent (nothing provisioned yet) or already current.
 * The full fresh-install write goes through {@link updateWpEnv} instead; this covers the resume path it
 * skips. Returns true when it changed the file. The app still needs a restart to read the new value.
 */
-function syncDevUrl(cfg, url) {
+function syncLocalUrl(cfg, url) {
 	const envPath = join(cfg.configDir, ".env");
 	if (!existsSync(envPath)) return false;
 	const existing = readFileSync(envPath, "utf8");
-	if (readEnvValue(existing, "KIZLO_DEV_WORDPRESS_URL") === url) return false;
-	const { content } = mergeEnv(existing, { KIZLO_DEV_WORDPRESS_URL: url }, new Set(["KIZLO_DEV_WORDPRESS_URL"]), envGroups("KIZLO_BACKEND_URL"));
+	if (readEnvValue(existing, "KIZLO_LOCAL_WP_URL") === url) return false;
+	const { content } = mergeEnv(existing, { KIZLO_LOCAL_WP_URL: url }, new Set(["KIZLO_LOCAL_WP_URL"]), envGroups(DEFAULT_ENV_KEYS));
 	writeFileSync(envPath, content);
 	return true;
 }
@@ -134,7 +131,7 @@ function syncDevUrl(cfg, url) {
 * `next dev` child server — nothing stops them automatically when we die. A dying process
 * also can't be trusted to finish async work (a closed terminal breaks its stdout
 * mid-write), so this process does no docker work on the way out. It only needs to
-* *exit*; the watchdog, watching our PID from its own session, stops the stack the moment
+* *exit*; the watchdog, watching our PID from its own session, stops it the moment
 * we're gone — by Ctrl+C, SIGTERM, a closed tab, SIGKILL, or a crash alike.
 *
 * We trigger that exit two ways, because neither alone is enough: signal handlers (for
@@ -150,7 +147,7 @@ function armForegroundTeardown(cfg) {
 		exiting = true;
 		unregisterSession(cfg.project);
 		try {
-			note(`Stopping dev stack (${reason})…`);
+			note(`Stopping local WordPress (${reason})…`);
 		} catch {}
 		process.exit(0);
 	};
@@ -169,7 +166,7 @@ function armForegroundTeardown(cfg) {
 	}
 }
 /**
-* Boot the stack and run in the foreground until exit — the path behind bare
+* Boot local WordPress and run in the foreground until exit — the path behind bare
 * `kizlo dev`. Arms teardown first (so a mid-startup cancel still
 * stops partial containers), shows a timed spinner, prints the summary + stop hint, then
 * parks. A referenced timer holds the event loop open — an unresolved promise alone would
@@ -196,7 +193,7 @@ async function startForeground(cfg) {
 	if (dbPort !== cfg.dbPort) note(`Database port ${cfg.dbPort} is in use — using ${dbPort} instead.`);
 	armForegroundTeardown(ready);
 	const start = Date.now();
-	const creds = await withSpinner("Starting WordPress dev stack", () => bootstrapDev(ready));
+	const creds = await withSpinner("Starting local WordPress", () => bootstrapDev(ready));
 	if (creds.appPassword) {
 		const env = updateWpEnv(ready, creds);
 		note("Updated .env with the new WordPress credentials");
@@ -212,12 +209,12 @@ async function startForeground(cfg) {
 			});
 			if (!sync.ok) note(`Could not sync the site settings to WordPress (${sync.error}) — make sure the kizlo plugin is active, then set them from the Kizlo settings.`);
 		}
-	} else if (syncDevUrl(ready, creds.url)) note("Updated .env WordPress URL to the current network address — restart your app to pick it up");
+	} else if (syncLocalUrl(ready, creds.url)) note("Updated .env WordPress URL to the current network address — restart your app to pick it up");
 	printSummary(creds);
 	const { green, dim, bold, reset } = palette();
 	const ms = Date.now() - start;
 	const took = ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
-	process.stdout.write(`\n   ${dim}Press ${reset}${bold}Ctrl+C${reset}${dim} (or close the terminal) to stop the development stack${reset}\n`);
+	process.stdout.write(`\n   ${dim}Press ${reset}${bold}Ctrl+C${reset}${dim} (or close the terminal) to stop local WordPress${reset}\n`);
 	process.stdout.write(`\n ${green}✓${reset} Ready in ${took}\n\n`);
 	const stopWatcher = await startWatcher(ready.configDir);
 	if (stopWatcher) process.on("exit", stopWatcher);
@@ -225,8 +222,8 @@ async function startForeground(cfg) {
 	await new Promise(() => {});
 }
 /**
-* Run the contract watcher in the foreground until exit — the path bare `kizlo dev` takes when no
-* local dev stack is configured (a bring-your-own-WordPress project). Generates once, then watches
+* Run the contract watcher in the foreground until exit — the path bare `kizlo dev` takes when local
+* WordPress isn't configured (a project pointing at its own WordPress). Generates once, then watches
 * the server files and regenerates on save. Returns immediately when another watcher already holds
 * the lock; otherwise the persistent watcher keeps the process alive on its own.
 */
@@ -244,44 +241,39 @@ async function watchOnly(cwd) {
 	});
 }
 /**
-* Start (or resume) the dev stack. Backs bare `kizlo dev`. Always runs in the foreground
-* and stops the stack on exit, so it never outlives the session — the subcommands
-* (`stop`/`down`/`reset`) manage everything else. Without a local dev stack configured
-* (`dev.path` unset), there's nothing to boot, so it runs the contract watcher alone.
+* Start (or resume) local WordPress. Backs bare `kizlo dev`. Always runs in the foreground and stops
+* it on exit, so it never outlives the session — the subcommands (`stop`/`reset`) manage everything
+* else. Without local WordPress configured there's nothing to boot, so it runs the contract watcher
+* alone.
 */
 async function bringUp() {
 	const cwd = process.cwd();
-	if (!await hasDevStack(cwd)) {
+	if (!await usesLocalWordPress(cwd)) {
+		note("This project doesn't run local WordPress — running the contract watcher only. Set `dev.local` in kizlo.config.ts to add it.");
 		await watchOnly(cwd);
 		return;
 	}
+	const status = await dockerStatus();
+	if (status !== "running") {
+		note(dockerHint(status));
+		process.exit(1);
+	}
 	const reaped = await reapOrphans();
-	if (reaped.length) note(`Stopped ${reaped.length} orphaned dev stack${reaped.length === 1 ? "" : "s"}: ${reaped.join(", ")}`);
+	if (reaped.length) note(`Stopped ${reaped.length} orphaned local WordPress${reaped.length === 1 ? "" : "s"}: ${reaped.join(", ")}`);
 	const cfg = await resolveDevConfig(cwd);
-	if (!cfg.wordpressPath.startsWith("..")) ensureGitignored(cfg.configDir, cfg.wordpressPath);
+	ensureGitignored(cfg.configDir, ".kizlo/");
 	await startForeground(cfg);
 }
 const subCommands = {
 	stop: defineCommand({
 		meta: {
 			name: "stop",
-			description: "Stop the dev stack, keeping the database volume"
-		},
-		async run() {
-			if (!await requireDevStack(process.cwd())) return;
-			const { stack } = await resolve$1(process.cwd());
-			await withSpinner("Stopping WordPress dev stack", () => stack.composeStop(), "Stack stopped (volumes kept)");
-		}
-	}),
-	down: defineCommand({
-		meta: {
-			name: "down",
-			description: "Stop and remove the dev stack containers (keeps the database and files)"
+			description: "Stop local WordPress, keeping the database volume"
 		},
 		async run() {
-			if (!await requireDevStack(process.cwd())) return;
+			if (!await requireLocalWordPress(process.cwd())) return;
 			const { stack } = await resolve$1(process.cwd());
-			await withSpinner("Removing WordPress dev stack", () => stack.composeDown(), "Stack removed (database and files kept)");
+			await withSpinner("Stopping local WordPress", () => stack.composeStop(), "Local WordPress stopped (volumes kept)");
 		}
 	}),
 	reset: defineCommand({
@@ -290,21 +282,21 @@ const subCommands = {
 			description: "Wipe the database and the install folder so the next `kizlo dev` rebuilds fresh"
 		},
 		async run() {
-			if (!await requireDevStack(process.cwd())) return;
+			if (!await requireLocalWordPress(process.cwd())) return;
 			const { cfg, stack } = await resolve$1(process.cwd());
-			await withSpinner("Wiping WordPress dev stack", () => stack.composeDown({ volumes: true }), "Local WordPress reset successfully");
+			await withSpinner("Wiping local WordPress", () => stack.composeDown({ volumes: true }), "Local WordPress reset successfully");
 			rmSync(cfg.wordpressDir, {
 				recursive: true,
 				force: true
 			});
-			note("Run `kizlo dev` to rebuild a fresh stack.");
+			note("Run `kizlo dev` to rebuild fresh.");
 		}
 	})
 };
 const dev = defineCommand({
 	meta: {
 		name: "dev",
-		description: "Run the dev stack and contract watcher (stop | down | reset)"
+		description: "Run local WordPress and the contract watcher (stop | reset)"
 	},
 	subCommands,
 	run: groupDefault(Object.keys(subCommands), bringUp)

package/dist/cli/commands/init.js

@@ -1,9 +1,8 @@
-import { dockerAvailable } from "../wp/docker.js";
 import { addDependencyArgs, detectImportAlias, detectPackageManager, ensureGitignored, getVersion, loadEnvFiles, runCommandAsync } from "../utils.js";
 import { PRESETS, detectPreset, getPreset } from "../presets/index.js";
 import { fetchTemplate } from "../presets/source.js";
-import { adaptFile, changesFor, fileEntries, patchEntries, readManifest } from "../presets/template.js";
-import { collectConnectionFromEnv, collectConnectionInteractively, dirPath, nextStepsNote, orCancel, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
+import { adaptFile, changesFor, fileEntries, isOlderVersion, minCliError, patchEntries, readManifest, resolveDependencies } from "../presets/template.js";
+import { collectConnectionFromEnv, collectConnectionInteractively, dirPath, nextStepsNote, orCancel, readEnvExample, resolveEnvKeys, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv } from "./_setup.js";
 import { applyLayoutPatches, buildScaffoldContext, kizloConfigTemplate, reportScaffold, scaffoldFile, writeGeneratedContract } from "./_wiring.js";
 import path from "node:path";
 import fs from "node:fs";
@@ -32,7 +31,6 @@ function detectAppDir(cwd, hasSrcDir) {
 	return hasSrcDir ? "src/app" : "app";
 }
 async function collectInteractively(ctx) {
-	const conn = await collectConnectionInteractively(ctx.preset);
 	const dir = orCancel(await p.text({
 		message: "Kizlo directory",
 		initialValue: defaultDir(ctx.hasSrcDir),
@@ -49,7 +47,7 @@ async function collectInteractively(ctx) {
 		})).trim();
 	}
 	return {
-		...conn,
+		...await collectConnectionInteractively(ctx.preset),
 		dir,
 		alias
 	};
@@ -60,7 +58,7 @@ async function collectInteractively(ctx) {
 * later. Never fails — `--yes` always scaffolds a fillable project.
 */
 function collectFromEnv(ctx) {
-	const conn = collectConnectionFromEnv(ctx.preset);
+	const conn = collectConnectionFromEnv(ctx.envKeys);
 	const dir = defaultDir(ctx.hasSrcDir);
 	return {
 		...conn,
@@ -71,40 +69,23 @@ function collectFromEnv(ctx) {
 function readPkg(pkgPath) {
 	return JSON.parse(fs.readFileSync(pkgPath, "utf8"));
 }
-function kizloDep(pkg) {
-	return pkg.dependencies?.kizlo ?? pkg.devDependencies?.kizlo;
-}
-/** A bare `x.y.z` from a version spec (range prefix and pre-release/build metadata dropped); undefined if none. */
-function coerceVersion(spec) {
-	const match = /(\d+)\.(\d+)\.(\d+)/.exec(spec);
-	return match ? [
-		Number(match[1]),
-		Number(match[2]),
-		Number(match[3])
-	] : void 0;
-}
-/** Whether `have` is a strictly older release than `want`; false when either can't be compared. */
-function isOlder(have, want) {
-	const a = coerceVersion(have);
-	const b = coerceVersion(want);
-	if (!a || !b) return false;
-	for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] < b[i];
-	return false;
-}
 /**
-* The template is authoritative for the kizlo version: it declares `kizloVersion` in its manifest
-* (stamped at release), falling back to the running CLI's version in-repo before the first stamp.
-* When the project's kizlo is older, upgrade the project up to it and say so — a deliberate pin is
-* never changed silently. Never downgrades.
+* The template is authoritative for the pinned versions: it declares `dependencies`/`devDependencies`
+* in its manifest (stamped at release), falling back to the running CLI's version for `kizlo` in-repo
+* before the first stamp. For each declared package the project already has at an older release, upgrade
+* it up to the template's pin and say so — a deliberate pin is never changed silently. Never downgrades,
+* and never adds a package the project doesn't already have (a missing `kizlo` is installed separately).
 */
-async function alignKizloVersion(cwd, pm, pkg, manifest) {
-	const want = manifest.kizloVersion ?? `^${getVersion()}`;
-	const have = kizloDep(pkg);
-	if (!have || !isOlder(have, want)) return;
-	const s = p.spinner();
-	s.start(`Upgrading kizlo from ${have} to ${want}`);
-	const ok = await runCommandAsync(addDependencyArgs(pm, `kizlo@${want}`), cwd, "ignore");
-	s.stop(ok ? `Upgraded kizlo to ${want}` : `Could not upgrade kizlo automatically — install kizlo@${want} yourself`);
+async function alignDependencies(cwd, pm, pkg, manifest) {
+	const { dependencies, devDependencies } = resolveDependencies(manifest);
+	for (const [name, want] of [...Object.entries(dependencies), ...Object.entries(devDependencies)]) {
+		const have = pkg.dependencies?.[name] ?? pkg.devDependencies?.[name];
+		if (!have || !isOlderVersion(have, want)) continue;
+		const s = p.spinner();
+		s.start(`Upgrading ${name} from ${have} to ${want}`);
+		const ok = await runCommandAsync(addDependencyArgs(pm, `${name}@${want}`), cwd, "ignore");
+		s.stop(ok ? `Upgraded ${name} to ${want}` : `Could not upgrade ${name} automatically — install ${name}@${want} yourself`);
+	}
 }
 const init = defineCommand({
 	meta: {
@@ -178,76 +159,85 @@ const init = defineCommand({
 			process.exit(1);
 		}
 		if (yes) loadEnvFiles(cwd);
-		const setup = yes ? collectFromEnv({
-			cwd,
-			hasSrcDir,
-			preset
-		}) : await collectInteractively({
-			cwd,
-			hasSrcDir,
-			preset
-		});
-		if (args.alias !== void 0) setup.alias = String(args.alias).trim();
-		setup.alias = aliasWithSlash(setup.alias);
-		if (setup.mode === "local" && !await dockerAvailable()) {
-			p.cancel("Docker isn't available — start Docker (or install it) and re-run, or choose “Use my own WordPress”.");
-			process.exit(1);
-		}
-		if (!hasKizlo) {
-			const spec = `kizlo@^${getVersion()}`;
-			const s = p.spinner();
-			s.start(`Installing kizlo with ${pm}`);
-			const ok = await runCommandAsync(addDependencyArgs(pm, spec), cwd, "ignore");
-			s.stop(ok ? "Installed kizlo" : "Could not install kizlo automatically");
-			if (!ok) p.log.warn(`Install it yourself: ${addDependencyArgs(pm, spec).join(" ")}`);
-		}
-		if (preset.apiPath && setup.baseUrl) setup.baseUrl = withApiPath(setup.baseUrl, preset.apiPath);
-		await setupLocalWordPress(cwd, setup);
-		await writeEnv(cwd, preset, setup, {
-			force,
-			yes
-		});
-		await syncRemote(setup);
-		const dirRel = setup.dir.replace(/^\.\//, "").replace(/\/+$/, "");
-		const serverDirRel = path.join(dirRel, "server");
-		const clientUrl = setup.siteUrl && !sameOrigin(setup.siteUrl, setup.baseUrl) ? setup.baseUrl : void 0;
-		const scaffold = buildScaffoldContext(cwd, {
-			dirRel,
-			appDir: detectAppDir(cwd, hasSrcDir),
-			alias: setup.alias,
-			clientUrl
-		});
-		const files = [{
-			label: "Kizlo config",
-			relPath: "kizlo.config.ts",
-			contents: kizloConfigTemplate(dirRel, setup.alias, setup.devPath)
-		}];
 		let manifest;
+		let fetched;
 		if (preset.template) {
-			const fetched = await fetchTemplate(preset.template);
-			try {
-				manifest = readManifest(fetched.dir);
-				await alignKizloVersion(cwd, pm, pkg, manifest);
-				for (const entry of fileEntries(changesFor(manifest, "init"))) files.push(adaptFile(fetched.dir, entry, manifest.conventions, scaffold));
-			} finally {
+			fetched = await fetchTemplate(preset.template);
+			manifest = readManifest(fetched.dir);
+			const minErr = minCliError(manifest);
+			if (minErr) {
 				fetched.cleanup();
+				p.cancel(minErr);
+				process.exit(1);
 			}
-		} else if (preset.scaffolds) files.push(...preset.scaffolds(scaffold));
-		const scaffolded = [];
-		for (const file of files) scaffolded.push({
-			file,
-			result: await scaffoldFile(cwd, file, {
+		}
+		const envKeys = resolveEnvKeys(preset, manifest);
+		try {
+			const setup = yes ? collectFromEnv({
+				cwd,
+				hasSrcDir,
+				preset,
+				envKeys
+			}) : await collectInteractively({
+				cwd,
+				hasSrcDir,
+				preset
+			});
+			if (args.alias !== void 0) setup.alias = String(args.alias).trim();
+			setup.alias = aliasWithSlash(setup.alias);
+			if (!hasKizlo) {
+				const spec = `kizlo@${manifest?.dependencies?.kizlo ?? `^${getVersion()}`}`;
+				const s = p.spinner();
+				s.start(`Installing kizlo with ${pm}`);
+				const ok = await runCommandAsync(addDependencyArgs(pm, spec), cwd, "ignore");
+				s.stop(ok ? "Installed kizlo" : "Could not install kizlo automatically");
+				if (!ok) p.log.warn(`Install it yourself: ${addDependencyArgs(pm, spec).join(" ")}`);
+			}
+			if (preset.apiPath && setup.baseUrl) setup.baseUrl = withApiPath(setup.baseUrl, preset.apiPath);
+			await setupLocalWordPress(cwd, setup);
+			await writeEnv(cwd, envKeys, setup, {
 				force,
-				yes
-			})
-		});
-		writeGeneratedContract(cwd, serverDirRel);
-		const gitignore = ensureGitignored(cwd, ".env");
-		for (const { file, result } of scaffolded) reportScaffold(file, result, yes);
-		if (manifest) applyLayoutPatches(cwd, patchEntries(changesFor(manifest, "init")), manifest.conventions, scaffold);
-		if (gitignore !== "present") p.log.success(`${gitignore === "created" ? "Created" : "Updated"} .gitignore (ignoring .env)`);
-		nextStepsNote(setup);
-		p.outro("Kizlo is ready 🎉");
+				yes,
+				exampleTemplate: fetched ? readEnvExample(fetched.dir) : void 0
+			});
+			await syncRemote(setup);
+			const dirRel = setup.dir.replace(/^\.\//, "").replace(/\/+$/, "");
+			const serverDirRel = path.join(dirRel, "server");
+			const clientUrl = setup.siteUrl && !sameOrigin(setup.siteUrl, setup.baseUrl) ? setup.baseUrl : void 0;
+			const scaffold = buildScaffoldContext(cwd, {
+				dirRel,
+				appDir: detectAppDir(cwd, hasSrcDir),
+				alias: setup.alias,
+				clientUrl
+			});
+			const files = [{
+				label: "Kizlo config",
+				relPath: "kizlo.config.ts",
+				contents: kizloConfigTemplate(dirRel, setup.alias, setup.mode === "local")
+			}];
+			if (manifest && fetched) {
+				await alignDependencies(cwd, pm, pkg, manifest);
+				for (const entry of fileEntries(changesFor(manifest, "init"))) files.push(adaptFile(fetched.dir, entry, manifest.conventions, scaffold));
+			} else if (preset.scaffolds) files.push(...preset.scaffolds(scaffold));
+			const scaffolded = [];
+			for (const file of files) scaffolded.push({
+				file,
+				result: await scaffoldFile(cwd, file, {
+					force,
+					yes
+				})
+			});
+			writeGeneratedContract(cwd, serverDirRel);
+			const gitignore = ensureGitignored(cwd, ".env");
+			ensureGitignored(cwd, ".kizlo/");
+			for (const { file, result } of scaffolded) reportScaffold(file, result, yes);
+			if (manifest) applyLayoutPatches(cwd, patchEntries(changesFor(manifest, "init")), manifest.conventions, scaffold);
+			if (gitignore !== "present") p.log.success(`${gitignore === "created" ? "Created" : "Updated"} .gitignore (ignoring .env)`);
+			nextStepsNote(setup);
+			p.outro("Kizlo is ready 🎉");
+		} finally {
+			fetched?.cleanup();
+		}
 	}
 });