kizlo 0.9.0 → 0.10.0

package/LICENSE

@@ -1,21 +1,201 @@
-MIT License
-
-Copyright (c) 2026 Kizlo
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Kizlo
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/cli/commands/_setup.js

@@ -1,5 +1,6 @@
-import { composeStop, createStack } from "../wp/docker.js";
-import { ensureGitignored, envGroups, envKeysPresent, mergeEnv, pickStackPort, writeFileIfAbsent } from "../utils.js";
+import { LOCAL_DIR_REL } from "../wp/constants.js";
+import { composeStop, createStack, dockerHint, dockerStatus } from "../wp/docker.js";
+import { DEFAULT_ENV_KEYS, ensureGitignored, envGroups, envKeysPresent, mergeEnv, pickStackPort, writeFileIfAbsent } from "../utils.js";
 import { DEFAULT_DEV_DB_PORT, DEFAULT_DEV_PORT, resolveStackName } from "../daemon/config.js";
 import { createAdminAppPassword } from "../wp/bootstrap.js";
 import { bootstrapDev } from "../wp/dev.js";
@@ -14,46 +15,67 @@ import { randomBytes } from "node:crypto";
 import getPort, { portNumbers } from "get-port";
 
 //#region src/cli/commands/_setup.ts
-/** Production connection keys — what a real deploy needs, and what `.env.example` always lists. */
-const PROD_WP_ENV_KEYS = [
-	"KIZLO_SITE_SECRET",
-	"KIZLO_WORDPRESS_URL",
-	"KIZLO_WORDPRESS_USERNAME",
-	"KIZLO_WORDPRESS_APPLICATION_PASSWORD"
-];
 /**
-* The `.env` keys setup manages and the values to write, branched on the connection mode. A local
-* dev stack writes the `KIZLO_DEV_WORDPRESS_*` / `KIZLO_DEV_SITE_SECRET` set plus `KIZLO_TARGET=dev`, so it
-* never touches the production keys (a user can point those at a real site). A remote site writes the
-* bare production keys exactly as before — no `KIZLO_TARGET`, since `"production"` is the default target.
+* The resolved `.env` key names the scaffold writes: the template's declared `env` when it has one,
+* else the preset's built-in `envKeys` (the generic `base` preset), else the {@link DEFAULT_ENV_KEYS}
+* fallback for an in-repo template before the first stamped release. Threaded into `managedEnv`,
+* `writeEnv`, and `collectConnectionFromEnv` so the scaffold writes the names the pinned runtime reads.
 */
-function managedEnv(preset, conn) {
-	if (conn.mode === "local") return {
+function resolveEnvKeys(preset, manifest) {
+	return manifest?.env ?? preset.envKeys ?? DEFAULT_ENV_KEYS;
+}
+/** Remote connection keys — what a real deploy needs, and what `.env.example` always lists. */
+function remoteKeys(envKeys) {
+	return [
+		envKeys.remote.siteSecret,
+		envKeys.remote.wpUrl,
+		envKeys.remote.wpUsername,
+		envKeys.remote.wpPassword
+	];
+}
+/**
+* The `.env` keys setup manages and the values to write, branched on the connection mode. Local
+* WordPress writes the `KIZLO_LOCAL_WP_*` / `KIZLO_LOCAL_WP_SECRET` set plus `KIZLO_CONNECT=local`,
+* so it never touches the remote keys (a user can point those at a real site). A remote site writes
+* the bare remote keys exactly as before — no `KIZLO_CONNECT`, since `"remote"` is the default.
+*/
+function managedEnv(envKeys, conn) {
+	if (conn.mode === "local") {
+		const { connect, siteSecret: siteSecret$1, wpUrl: wpUrl$1, wpUsername: wpUsername$1, wpPassword: wpPassword$1 } = envKeys.local;
+		return {
+			keys: [
+				envKeys.baseUrl,
+				connect,
+				siteSecret$1,
+				wpUrl$1,
+				wpUsername$1,
+				wpPassword$1
+			],
+			values: {
+				[envKeys.baseUrl]: conn.baseUrl,
+				[connect]: "local",
+				[siteSecret$1]: conn.siteSecret,
+				[wpUrl$1]: conn.wpUrl,
+				[wpUsername$1]: conn.wpUsername,
+				[wpPassword$1]: conn.wpPassword
+			}
+		};
+	}
+	const { siteSecret, wpUrl, wpUsername, wpPassword } = envKeys.remote;
+	return {
 		keys: [
-			preset.baseUrlEnvKey,
-			"KIZLO_TARGET",
-			"KIZLO_DEV_SITE_SECRET",
-			"KIZLO_DEV_WORDPRESS_URL",
-			"KIZLO_DEV_WORDPRESS_USERNAME",
-			"KIZLO_DEV_WORDPRESS_APPLICATION_PASSWORD"
+			envKeys.baseUrl,
+			siteSecret,
+			wpUrl,
+			wpUsername,
+			wpPassword
 		],
 		values: {
-			[preset.baseUrlEnvKey]: conn.baseUrl,
-			KIZLO_TARGET: "dev",
-			KIZLO_DEV_SITE_SECRET: conn.siteSecret,
-			KIZLO_DEV_WORDPRESS_URL: conn.wpUrl,
-			KIZLO_DEV_WORDPRESS_USERNAME: conn.wpUsername,
-			KIZLO_DEV_WORDPRESS_APPLICATION_PASSWORD: conn.wpPassword
-		}
-	};
-	return {
-		keys: [preset.baseUrlEnvKey, ...PROD_WP_ENV_KEYS],
-		values: {
-			[preset.baseUrlEnvKey]: conn.baseUrl,
-			KIZLO_SITE_SECRET: conn.siteSecret,
-			KIZLO_WORDPRESS_URL: conn.wpUrl,
-			KIZLO_WORDPRESS_USERNAME: conn.wpUsername,
-			KIZLO_WORDPRESS_APPLICATION_PASSWORD: conn.wpPassword
+			[envKeys.baseUrl]: conn.baseUrl,
+			[siteSecret]: conn.siteSecret,
+			[wpUrl]: conn.wpUrl,
+			[wpUsername]: conn.wpUsername,
+			[wpPassword]: conn.wpPassword
 		}
 	};
 }
@@ -149,18 +171,24 @@ async function collectConnectionInteractively(preset, opts = {}) {
 		initialValue: "local",
 		options: [{
 			value: "local",
-			label: "Set up a local dev environment",
-			hint: "runs WordPress in Docker"
+			label: "Set up local WordPress",
+			hint: "runs in Docker, for dev and test"
 		}, {
 			value: "remote",
 			label: "Use my own WordPress",
-			hint: "connect to an existing site"
+			hint: "connect to your existing WordPress"
 		}]
 	}));
+	if (mode === "local") {
+		const status = await dockerStatus();
+		if (status !== "running") {
+			p.cancel(dockerHint(status));
+			process.exit(1);
+		}
+	}
 	let wpUrl = "";
 	let wpUsername = "";
 	let wpPassword = "";
-	let devPath;
 	if (mode === "remote") {
 		wpUrl = orCancel(await p.text({
 			message: "WordPress URL",
@@ -175,11 +203,7 @@ async function collectConnectionInteractively(preset, opts = {}) {
 			message: "WordPress application password",
 			validate: validate(requiredString)
 		}));
-	} else devPath = orCancel(await p.text({
-		message: "Local WordPress folder",
-		initialValue: "wordpress",
-		validate: validate(dirPath)
-	}));
+	}
 	return {
 		mode,
 		baseUrl,
@@ -187,27 +211,26 @@ async function collectConnectionInteractively(preset, opts = {}) {
 		siteSecret,
 		wpUrl,
 		wpUsername,
-		wpPassword,
-		devPath
+		wpPassword
 	};
 }
 /**
 * Non-interactive connection: skip prompts and use env values where present. Missing ones are
 * left empty for the user to fill in later. Never fails — always yields a fillable project.
 */
-function collectConnectionFromEnv(preset) {
+function collectConnectionFromEnv(envKeys) {
 	return {
 		mode: "remote",
-		baseUrl: process.env[preset.baseUrlEnvKey]?.trim() ?? "",
-		siteSecret: process.env.KIZLO_SITE_SECRET?.trim() || randomBytes(32).toString("hex"),
-		wpUrl: process.env.KIZLO_WORDPRESS_URL?.trim() ?? "",
-		wpUsername: process.env.KIZLO_WORDPRESS_USERNAME?.trim() ?? "",
-		wpPassword: process.env.KIZLO_WORDPRESS_APPLICATION_PASSWORD?.trim() ?? ""
+		baseUrl: process.env[envKeys.baseUrl]?.trim() ?? "",
+		siteSecret: process.env[envKeys.remote.siteSecret]?.trim() || randomBytes(32).toString("hex"),
+		wpUrl: process.env[envKeys.remote.wpUrl]?.trim() ?? "",
+		wpUsername: process.env[envKeys.remote.wpUsername]?.trim() ?? "",
+		wpPassword: process.env[envKeys.remote.wpPassword]?.trim() ?? ""
 	};
 }
-/** Build a {@link ResolvedDevConfig} from the chosen install folder, matching `resolveDevConfig`'s
+/** Build a {@link ResolvedDevConfig} for the fixed `.kizlo/local` install, matching `resolveDevConfig`'s
 * defaults — built directly so setup never has to round-trip through the config file it's writing. */
-function devConfigFor(cwd, devPath) {
+function devConfigFor(cwd) {
 	return {
 		configDir: cwd,
 		project: `${resolveStackName(cwd)}-dev`,
@@ -216,15 +239,15 @@ function devConfigFor(cwd, devPath) {
 		dbPort: DEFAULT_DEV_DB_PORT,
 		dbPortExplicit: false,
 		fixtures: [],
-		wordpressPath: devPath,
-		wordpressDir: path.resolve(cwd, devPath)
+		wordpressPath: LOCAL_DIR_REL,
+		wordpressDir: path.resolve(cwd, LOCAL_DIR_REL)
 	};
 }
 /**
-* Boot the local dev stack once to produce working credentials, then stop it (volumes
-* persist, so a later `kizlo dev` resumes instantly). The dev stack mints no application
-* password — that's a test-stack concern — so we create one here for REST auth in `.env`.
-* While the stack is still up, push the dev site settings (`siteSecret` plus the Kizlo server's
+* Boot local WordPress once to produce working credentials, then stop it (volumes
+* persist, so a later `kizlo dev` resumes instantly). Local WordPress mints no application
+* password — that's a test concern — so we create one here for REST auth in `.env`.
+* While it's still up, push the site settings (`siteSecret` plus the Kizlo server's
 * `url`/`backend_url`, derived from `baseUrl`) into the plugin so webhook signing and event delivery
 * work.
 */
@@ -266,23 +289,24 @@ async function provisionLocalStack(cfg, siteSecret, baseUrl) {
 	};
 }
 /**
-* Provision the local WordPress dev stack and fill the connection's WP credentials from it, then
-* report the outcome. Mutates `conn` in place (wpUrl / wpUsername / wpPassword). Exits on failure,
-* matching the previous inline behavior. No-op for a remote connection.
+* Provision local WordPress and fill the connection's WP credentials from it, then report the
+* outcome. Mutates `conn` in place (wpUrl / wpUsername / wpPassword). Writing the `local` flags into
+* `kizlo.config.ts` is the caller's job (the generated config for `create`/`init`). Exits on failure.
+* No-op for a remote connection.
 */
 async function setupLocalWordPress(cwd, conn) {
-	if (conn.mode !== "local" || !conn.devPath) return;
-	ensureGitignored(cwd, conn.devPath);
+	if (conn.mode !== "local") return;
+	ensureGitignored(cwd, ".kizlo/");
 	const s = p.spinner();
 	s.start("Setting up local WordPress (first run downloads images, this can take a while)");
 	try {
-		const local = await provisionLocalStack(devConfigFor(cwd, conn.devPath), conn.siteSecret, conn.baseUrl);
+		const local = await provisionLocalStack(devConfigFor(cwd), conn.siteSecret, conn.baseUrl);
 		conn.wpUrl = local.url;
 		conn.wpUsername = local.username;
 		conn.wpPassword = local.appPassword;
 		conn.adminPassword = local.adminPassword;
 		s.stop("Local WordPress ready");
-		if (local.secretSyncError) p.log.warn(`Could not sync KIZLO_DEV_SITE_SECRET to the local plugin (${local.secretSyncError})`);
+		if (local.secretSyncError) p.log.warn(`Could not sync KIZLO_LOCAL_WP_SECRET to the local plugin (${local.secretSyncError})`);
 	} catch (error) {
 		s.stop("Local WordPress setup failed");
 		p.cancel(error instanceof Error ? error.message : String(error));
@@ -290,12 +314,34 @@ async function setupLocalWordPress(cwd, conn) {
 	}
 }
 /**
+* The template's own `.env.example`, when it ships one. Templates own the framework-specific key names
+* (e.g. `NEXT_PUBLIC_KIZLO_API_URL`) and the shared section layout, so their file is the source of the
+* scaffold's `.env.example` — see {@link writeEnv}. Undefined for the base preset (no template dir).
+*/
+function readEnvExample(templateDir) {
+	const file = path.join(templateDir, ".env.example");
+	return fs.existsSync(file) ? fs.readFileSync(file, "utf8") : void 0;
+}
+/**
+* The `.env.example` body for the base preset, which ships no template file. Lists the API URL and the
+* remote connection keys, then the commented `KIZLO_CONNECT=local` toggle for the local-dev path. Real
+* templates carry their own `.env.example` (passed to {@link writeEnv}) so its structure and comments
+* stay consistent with the `.env` the scaffold writes.
+*/
+function generatedEnvExample(envKeys) {
+	const exampleKeys = [envKeys.baseUrl, ...remoteKeys(envKeys)];
+	const { content } = mergeEnv("", Object.fromEntries(exampleKeys.map((key) => [key, ""])), new Set(exampleKeys), envGroups(envKeys));
+	return `${content}\n# Point the app at local WordPress (managed by \`kizlo dev\`) instead of the keys above:\n# ${envKeys.local.connect}=local\n`;
+}
+/**
 * Write (or update) `.env` and `.env.example` for the managed keys and report the outcome.
 * Existing conflicting `.env` values are preserved unless `force`; interactively the user is asked,
-* and under `--yes` they are kept. `.env.example` is only written when absent.
+* and under `--yes` they are kept. `.env.example` is only written when absent, and is sourced from the
+* template's own file (`opts.exampleTemplate`) so it matches the `.env` structure, falling back to a
+* generated block for the base preset.
 */
-async function writeEnv(cwd, preset, conn, opts) {
-	const { keys, values: envValues } = managedEnv(preset, conn);
+async function writeEnv(cwd, envKeys, conn, opts) {
+	const { keys, values: envValues } = managedEnv(envKeys, conn);
 	const envPath = path.join(cwd, ".env");
 	const envExisted = fs.existsSync(envPath);
 	const existingEnv = envExisted ? fs.readFileSync(envPath, "utf8") : "";
@@ -311,11 +357,9 @@ async function writeEnv(cwd, preset, conn, opts) {
 			initialValue: true
 		}))) overwriteKeys = /* @__PURE__ */ new Set();
 	}
-	const merge = mergeEnv(existingEnv, envValues, overwriteKeys, envGroups(preset.baseUrlEnvKey));
+	const merge = mergeEnv(existingEnv, envValues, overwriteKeys, envGroups(envKeys));
 	fs.writeFileSync(envPath, merge.content);
-	const exampleKeys = [preset.baseUrlEnvKey, ...PROD_WP_ENV_KEYS];
-	const { content: exampleEnv } = mergeEnv("", Object.fromEntries(exampleKeys.map((key) => [key, ""])), new Set(exampleKeys), envGroups(preset.baseUrlEnvKey));
-	const exampleBody = `${exampleEnv}\n# Point the app at a local dev stack (managed by \`kizlo dev\`) instead of the keys above:\n# KIZLO_TARGET=dev\n`;
+	const exampleBody = opts.exampleTemplate ?? generatedEnvExample(envKeys);
 	const exampleCreated = writeFileIfAbsent(path.join(cwd, ".env.example"), exampleBody);
 	if (!envExisted) p.log.success("Created .env");
 	else if (merge.updated.length || merge.added.length) p.log.success("Updated .env");
@@ -359,4 +403,4 @@ function nextStepsNote(conn, prefix = "") {
 }
 
 //#endregion
-export { collectConnectionFromEnv, collectConnectionInteractively, dirPath, nextStepsLines, nextStepsNote, orCancel, pickAppPort, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv };
+export { collectConnectionFromEnv, collectConnectionInteractively, dirPath, nextStepsLines, nextStepsNote, orCancel, pickAppPort, readEnvExample, resolveEnvKeys, setupLocalWordPress, syncRemote, validate, withApiPath, writeEnv };

package/dist/cli/commands/_wiring.js

@@ -8,13 +8,14 @@ import fs from "node:fs";
 import * as p from "@clack/prompts";
 
 //#region src/cli/commands/_wiring.ts
-/** The kizlo.config.ts a scaffolded project gets: the Kizlo directory, optional import alias, and —
-*  for a local dev setup — the WordPress install folder so `kizlo dev` knows where it lives. */
-function kizloConfigTemplate(dir, alias, devPath) {
+/** The kizlo.config.ts a scaffolded project gets: the Kizlo directory, an optional import alias, and —
+*  when local WordPress is chosen — `dev.local` + `test.local` so `kizlo dev` and `kizlo test` boot the
+*  fixed `.kizlo/local` install. */
+function kizloConfigTemplate(dir, alias, localWordPress = false) {
 	return `import { defineConfig } from "kizlo/config"
 
 export default defineConfig({
-	dir: "${dir}",${alias ? `\n\talias: "${alias}",` : ""}${devPath ? `\n\tdev: { path: "${devPath}" },` : ""}
+	dir: "${dir}",${alias ? `\n\talias: "${alias}",` : ""}${localWordPress ? `\n\tdev: { local: true },\n\ttest: { local: true },` : ""}
 })
 `;
 }