kizlo 0.1.0 → 0.1.1

package/dist/cli/commands/dev.js

@@ -0,0 +1,82 @@
+import { createStack } from "../wp/docker.js";
+import { ensureGitignored, groupDefault, withSpinner } from "../utils.js";
+import { log } from "../daemon/logger.js";
+import { resolveDevConfig } from "../daemon/config.js";
+import { bootstrapDev } from "../wp/dev.js";
+import { devStack } from "../wp/stack.js";
+import { rmSync } from "node:fs";
+import { defineCommand } from "citty";
+
+//#region src/cli/commands/dev.ts
+async function resolve(cwd) {
+	const cfg = await resolveDevConfig(cwd);
+	return {
+		cfg,
+		stack: createStack(devStack(cfg))
+	};
+}
+/** Print the connection summary. On a fresh install, show the one-time wp-admin password. */
+function printSummary(info) {
+	log.success(`WordPress dev stack ready at ${info.url}`);
+	if (info.secrets) {
+		log.info(`wp-admin: ${info.url}/wp-admin  (user: ${info.username} / pass: ${info.secrets.password})`);
+		log.info("Save the password now — it's shown only once and isn't stored on disk.");
+	} else if (info.imported) log.info(`wp-admin: ${info.url}/wp-admin — log in with your imported site's own credentials`);
+	else log.info(`wp-admin: ${info.url}/wp-admin  (user: ${info.username}) — password unchanged from first install`);
+	log.info(`database: 127.0.0.1:${info.dbPort}  (db: wordpress, user: wordpress, pass: wppass)`);
+	if (info.seeded > 0) log.info(`seeded:   ${info.seeded} fixture${info.seeded === 1 ? "" : "s"}`);
+}
+/** Start (or resume) the dev stack and print the connection summary. Backs bare `kizlo dev`. */
+async function bringUp() {
+	const { cfg } = await resolve(process.cwd());
+	if (!cfg.wordpressPath.startsWith("..")) ensureGitignored(cfg.configDir, cfg.wordpressPath);
+	printSummary(await withSpinner("Starting WordPress dev stack", () => bootstrapDev(cfg), "WordPress dev stack ready"));
+}
+const subCommands = {
+	stop: defineCommand({
+		meta: {
+			name: "stop",
+			description: "Stop the dev stack, keeping the database volume"
+		},
+		async run() {
+			const { stack } = await resolve(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)"
+		},
+		async run() {
+			const { stack } = await resolve(process.cwd());
+			await withSpinner("Removing WordPress dev stack", () => stack.composeDown(), "Stack removed (database and files kept)");
+		}
+	}),
+	reset: defineCommand({
+		meta: {
+			name: "reset",
+			description: "Wipe the database and the install folder, then rebuild fresh"
+		},
+		async run() {
+			const { cfg, stack } = await resolve(process.cwd());
+			await withSpinner("Wiping WordPress dev stack", () => stack.composeDown({ volumes: true }), "Stack wiped");
+			rmSync(cfg.wordpressDir, {
+				recursive: true,
+				force: true
+			});
+			printSummary(await withSpinner("Starting WordPress dev stack", () => bootstrapDev(cfg), "WordPress dev stack ready"));
+		}
+	})
+};
+const dev = defineCommand({
+	meta: {
+		name: "dev",
+		description: "Manage the local WordPress dev stack (stop | down | reset)"
+	},
+	subCommands,
+	run: groupDefault(Object.keys(subCommands), bringUp)
+});
+
+//#endregion
+export { dev };

package/dist/cli/commands/init.js

@@ -4,8 +4,8 @@ import { printBanner } from "../banner.js";
 import { PRESETS, detectPreset, getPreset } from "../presets/index.js";
 import z from "zod/v4";
 import { randomBytes } from "node:crypto";
-import path from "node:path";
 import fs from "node:fs";
+import path from "node:path";
 import { defineCommand } from "citty";
 import * as p from "@clack/prompts";
 

package/dist/cli/commands/test.js

@@ -1,13 +1,34 @@
+import { createStack } from "../wp/docker.js";
 import { isSeeded } from "../wp/utils.js";
-import { composeDown, composeUp } from "../wp/docker.js";
-import { withSpinner } from "../utils.js";
+import { groupDefault, withSpinner } from "../utils.js";
 import { log } from "../daemon/logger.js";
 import { resolveTestConfig } from "../daemon/config.js";
+import { testStack } from "../wp/stack.js";
 import { runSeeds } from "../wp/setup.js";
 import { spawn } from "node:child_process";
 import { defineCommand } from "citty";
 
 //#region src/cli/commands/test.ts
+async function resolve(cwd) {
+	const cfg = await resolveTestConfig(cwd);
+	return {
+		cfg,
+		stack: createStack(testStack(cfg))
+	};
+}
+/** Boot the stack and seed it once (idempotent — skips seeding if already seeded). */
+async function bringUp(cfg, stack) {
+	await withSpinner("Starting WordPress test stack", () => stack.composeUp(), "WordPress test stack ready");
+	if (await isSeeded()) {
+		log.info("Stack already seeded — skipping seed.");
+		return;
+	}
+	await withSpinner("Seeding WordPress", () => runSeeds({
+		port: cfg.port,
+		fixtures: cfg.fixtures
+	}), "WordPress seeded");
+	log.success(`Stack ready on http://localhost:${cfg.port} — credentials at ${cfg.credentialsPath}`);
+}
 /** `<pm> test` runs the project's own test script (bun needs `run` to skip its built-in runner). */
 function testCommand(pm) {
 	return pm === "bun" ? [
@@ -23,45 +44,86 @@ function spawnTest(command, pm) {
 		stdio: "inherit",
 		shell: command !== void 0 || process.platform === "win32"
 	});
-	return new Promise((resolve, reject) => {
+	return new Promise((resolvePromise, reject) => {
 		child.on("error", reject);
-		child.on("close", (code) => resolve(code ?? 0));
+		child.on("close", (code) => resolvePromise(code ?? 0));
 	});
 }
-const test = defineCommand({
-	meta: {
-		name: "test",
-		description: "Boot the WordPress test stack (if needed), seed it, and run your tests against it"
+const runArgs = {
+	teardown: {
+		type: "boolean",
+		description: "Tear down the test stack after tests finish (default: leave it running for fast reruns)"
 	},
-	args: {
-		teardown: {
-			type: "boolean",
-			description: "Tear down the test stack after tests finish (default: leave it running for fast reruns)"
+	reset: {
+		type: "boolean",
+		description: "Wipe the database and reseed before running"
+	}
+};
+/** Boot (+ seed) the stack, run the project's test script, then leave it up (or tear down). */
+async function runSuite({ args }) {
+	const { cfg, stack } = await resolve(process.cwd());
+	if (args.reset) await withSpinner("Wiping WordPress database", () => stack.composeDown({ volumes: true }), "Database wiped");
+	await withSpinner("Starting WordPress test stack", () => stack.composeUp(), "WordPress test stack ready");
+	if (!await isSeeded()) await withSpinner("Seeding WordPress", () => runSeeds({
+		port: cfg.port,
+		fixtures: cfg.fixtures
+	}), "WordPress seeded");
+	log.info(cfg.command ? `Running: ${cfg.command}` : `Running: ${testCommand(cfg.packageManager).join(" ")}`);
+	let code = 1;
+	try {
+		code = await spawnTest(cfg.command, cfg.packageManager);
+	} finally {
+		if (args.teardown) await withSpinner("Tearing down WordPress test stack", () => stack.composeDown(), "WordPress test stack stopped");
+		else log.info("Stack left running for fast reruns — `kizlo test stop` to stop it, or rerun with --teardown.");
+	}
+	process.exit(code);
+}
+const subCommands = {
+	stop: defineCommand({
+		meta: {
+			name: "stop",
+			description: "Stop the WordPress test stack, keeping the database volume"
 		},
-		reset: {
+		async run() {
+			const { stack } = await resolve(process.cwd());
+			await withSpinner("Stopping WordPress test stack", () => stack.composeStop(), "Stack stopped (volumes kept)");
+		}
+	}),
+	down: defineCommand({
+		meta: {
+			name: "down",
+			description: "Stop and remove the test stack containers"
+		},
+		args: { volumes: {
 			type: "boolean",
-			description: "Wipe the database and reseed before running"
+			alias: "v",
+			description: "Also drop the database volume"
+		} },
+		async run({ args }) {
+			const { stack } = await resolve(process.cwd());
+			await withSpinner("Removing WordPress test stack", () => stack.composeDown({ volumes: args.volumes }), args.volumes ? "Stack removed (volumes dropped)" : "Stack removed (volumes kept)");
 		}
-	},
-	async run({ args }) {
-		const cfg = await resolveTestConfig(process.cwd());
-		process.env.WP_PORT = String(cfg.port);
-		if (args.reset) await withSpinner("Wiping WordPress database", () => composeDown({ volumes: true }), "Database wiped");
-		await withSpinner("Starting WordPress test stack", composeUp, "WordPress test stack ready");
-		if (!await isSeeded()) await withSpinner("Seeding WordPress", () => runSeeds({
-			port: cfg.port,
-			fixtures: cfg.fixtures
-		}), "WordPress seeded");
-		log.info(cfg.command ? `Running: ${cfg.command}` : `Running: ${testCommand(cfg.packageManager).join(" ")}`);
-		let code = 1;
-		try {
-			code = await spawnTest(cfg.command, cfg.packageManager);
-		} finally {
-			if (args.teardown) await withSpinner("Tearing down WordPress test stack", () => composeDown(), "WordPress test stack stopped");
-			else log.info("Stack left running for fast reruns — `kizlo wp stop` to stop it, or rerun with --teardown.");
+	}),
+	reset: defineCommand({
+		meta: {
+			name: "reset",
+			description: "Wipe the database and reseed a fresh WordPress test stack"
+		},
+		async run() {
+			const { cfg, stack } = await resolve(process.cwd());
+			await withSpinner("Wiping WordPress database", () => stack.composeDown({ volumes: true }), "Database wiped");
+			await bringUp(cfg, stack);
 		}
-		process.exit(code);
-	}
+	})
+};
+const test = defineCommand({
+	meta: {
+		name: "test",
+		description: "Manage the WordPress test stack and run tests (stop | down | reset)"
+	},
+	args: runArgs,
+	subCommands,
+	run: groupDefault(Object.keys(subCommands), runSuite)
 });
 
 //#endregion

package/dist/cli/daemon/config.js

@@ -2,8 +2,8 @@ import { credentialsPath, findConfigDir } from "../wp/utils.js";
 import { detectPackageManager } from "../utils.js";
 import { log } from "./logger.js";
 import z from "zod/v4";
-import path from "node:path";
 import fs from "node:fs";
+import path from "node:path";
 import { createJiti } from "jiti";
 
 //#region src/cli/daemon/config.ts
@@ -12,6 +12,14 @@ const fixtureSchema = z.custom((value) => typeof value === "object" && value !==
 const configSchema = z.object({
 	dir: z.string().optional(),
 	alias: z.string().optional(),
+	name: z.string().optional(),
+	dev: z.object({
+		path: z.string().optional(),
+		port: z.number().int().positive().optional(),
+		dbPort: z.number().int().positive().optional(),
+		byo: z.string().optional(),
+		fixtures: z.array(fixtureSchema).optional()
+	}).optional(),
 	test: z.object({
 		port: z.number().int().positive().optional(),
 		fixtures: z.array(fixtureSchema).optional(),
@@ -66,22 +74,74 @@ async function resolveConfig(cwd, flags) {
 	};
 }
 /**
+* Sanitize an arbitrary package/dir name into a valid Docker compose project id:
+* lowercase, `@scope/pkg` → `scope-pkg`, dropping anything outside `[a-z0-9_-]`.
+*/
+function sanitizeProjectName(raw) {
+	return raw.toLowerCase().replace(/^@/, "").replace(/\//g, "-").replace(/[^a-z0-9_-]/g, "").replace(/^[-_]+|[-_]+$/g, "") || "kizlo";
+}
+/**
+* Base name for the local stacks: the config `name` if set, else the `package.json`
+* `name` at `configDir`, else the config dir basename — sanitized to a Docker id.
+*/
+function resolveStackName(configDir, configName) {
+	if (configName) return sanitizeProjectName(configName);
+	let pkgName;
+	try {
+		pkgName = JSON.parse(fs.readFileSync(path.join(configDir, "package.json"), "utf8")).name;
+	} catch {
+		pkgName = void 0;
+	}
+	return sanitizeProjectName(pkgName ?? path.basename(configDir));
+}
+/**
 * Resolve the `test` block from `kizlo.config.*` into concrete values for the
-* `wp`/`test` commands, applying defaults (port 8080, auto-detected package
-* manager) and anchoring the credentials artifact to the config directory.
+* `test` command, applying defaults (port 8889, auto-detected package manager)
+* and anchoring the credentials artifact to the config directory.
 */
 async function resolveTestConfig(cwd) {
 	const configDir = findConfigDir(cwd);
-	const test = (await loadConfigFile(configDir))?.test ?? {};
+	const fileConfig = await loadConfigFile(configDir);
+	const test = fileConfig?.test ?? {};
 	return {
 		configDir,
+		project: `${resolveStackName(configDir, fileConfig?.name)}-test`,
 		command: test.command,
-		port: test.port ?? 8080,
+		port: test.port ?? 8889,
 		fixtures: test.fixtures ?? [],
 		credentialsPath: credentialsPath(cwd),
 		packageManager: test.packageManager ?? detectPackageManager(configDir)
 	};
 }
+/**
+* Resolve the `dev` block from `kizlo.config.*` into concrete values for the `dev`
+* command, applying defaults (port 8080). `dev.path` is required — the whole
+* WordPress install lives there, so we make the user choose a real folder rather
+* than hide it under a default.
+*/
+async function resolveDevConfig(cwd) {
+	const configDir = findConfigDir(cwd);
+	const fileConfig = await loadConfigFile(configDir);
+	const dev = fileConfig?.dev ?? {};
+	if (!dev.path) {
+		log.error("`dev.path` is required in kizlo.config — it's the folder your local WordPress lives in.\nPick a real, visible folder (it persists your site between runs), e.g. dev: { path: \"wordpress\" }.");
+		process.exit(1);
+	}
+	if (dev.byo && dev.fixtures?.length) {
+		log.error("`dev.byo` and `dev.fixtures` are mutually exclusive — byo imports an existing site, so it brings its own data.");
+		process.exit(1);
+	}
+	return {
+		configDir,
+		project: `${resolveStackName(configDir, fileConfig?.name)}-dev`,
+		port: dev.port ?? 8080,
+		dbPort: dev.dbPort ?? 3307,
+		byo: dev.byo ? path.resolve(configDir, dev.byo) : void 0,
+		fixtures: dev.fixtures ?? [],
+		wordpressPath: dev.path,
+		wordpressDir: path.resolve(configDir, dev.path)
+	};
+}
 
 //#endregion
-export { resolveConfig, resolveTestConfig };
+export { resolveConfig, resolveDevConfig, resolveTestConfig };

package/dist/cli/daemon/generate.js

@@ -1,7 +1,7 @@
 import { generateContract } from "../../shared/contract.js";
 import { loadEnvFiles } from "../utils.js";
-import path from "node:path";
 import fs from "node:fs";
+import path from "node:path";
 import { createJiti } from "jiti";
 
 //#region src/cli/daemon/generate.ts

package/dist/cli/daemon/lock.js

@@ -1,5 +1,5 @@
-import path from "node:path";
 import fs from "node:fs";
+import path from "node:path";
 
 //#region src/cli/daemon/lock.ts
 function lockPath(cwd) {

package/dist/cli/index.js

@@ -13,7 +13,7 @@ runMain(defineCommand({
 		init: () => import("./commands/init.js").then((m) => m.init),
 		watch: () => import("./commands/watch.js").then((m) => m.watch),
 		generate: () => import("./commands/generate.js").then((m) => m.generate),
-		wp: () => import("./commands/wp.js").then((m) => m.wp),
+		dev: () => import("./commands/dev.js").then((m) => m.dev),
 		test: () => import("./commands/test.js").then((m) => m.test)
 	}
 }));

package/dist/cli/utils.js

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process";
+import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import fs from "node:fs";
 import * as p from "@clack/prompts";
 
 //#region src/cli/utils.ts
@@ -177,6 +177,21 @@ async function withSpinner(message, fn, done) {
 		throw error;
 	}
 }
+/**
+* Wrap a command group's default `run` so it fires only for the bare invocation
+* (`kizlo test`), not when a subcommand was given (`kizlo test up`). citty runs a
+* group's own `run` *in addition to* the matched subcommand, so without this guard
+* the default would double-fire on every subcommand. Pass the group's subcommand
+* names; the first non-flag arg is matched the same way citty picks the subcommand.
+*/
+function groupDefault(subCommandNames, run) {
+	const names = new Set(subCommandNames);
+	return async (ctx) => {
+		const sub = ctx.rawArgs.find((arg) => !arg.startsWith("-"));
+		if (sub !== void 0 && names.has(sub)) return;
+		await run(ctx);
+	};
+}
 
 //#endregion
-export { addDependencyArgs, detectImportAlias, detectPackageManager, ensureGitignored, envKeysPresent, getVersion, loadEnvFiles, mergeEnv, resolveModuleImport, runCommand, withSpinner, writeFileIfAbsent };
+export { addDependencyArgs, detectImportAlias, detectPackageManager, ensureGitignored, envKeysPresent, getVersion, groupDefault, loadEnvFiles, mergeEnv, resolveModuleImport, runCommand, withSpinner, writeFileIfAbsent };

package/dist/cli/wp/bootstrap.js

@@ -1,6 +1,6 @@
-import { ensurePlugin, resolvePluginSource } from "./utils.js";
-import { DEFAULT_PLUGINS, DEFAULT_PORT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER } from "./constants.js";
 import { compose, composeUp, wpCli } from "./docker.js";
+import { DEFAULT_PLUGINS, DEFAULT_PORT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER } from "./constants.js";
+import { ensurePlugins } from "./utils.js";
 
 //#region src/cli/wp/bootstrap.ts
 async function seedUsers() {
@@ -22,7 +22,7 @@ async function seedUsers() {
 	if (!id) throw new Error("seed/users.json must include a user with username \"user\"");
 	return Number(id);
 }
-async function createAdminAppPassword() {
+async function createAdminAppPassword(label = "harness") {
 	await compose([
 		"exec",
 		"-T",
@@ -39,7 +39,7 @@ async function createAdminAppPassword() {
 		"application-password",
 		"create",
 		TEST_ADMIN.username,
-		"harness",
+		label,
 		"--porcelain"
 	]);
 }
@@ -50,9 +50,7 @@ async function createAdminAppPassword() {
 * construct the REST client in Phase 2.
 */
 async function bootstrapWp(config) {
-	const port = config.port ?? DEFAULT_PORT;
-	const url = `http://localhost:${port}`;
-	process.env.WP_PORT = String(port);
+	const url = `http://localhost:${config.port ?? DEFAULT_PORT}`;
 	await composeUp();
 	if ((await compose([
 		"exec",
@@ -77,7 +75,7 @@ async function bootstrapWp(config) {
 		"/%postname%/",
 		"--hard"
 	]);
-	for (const plugin of [...DEFAULT_PLUGINS, ...config.fixtures?.flatMap((a) => a.plugins ?? []) ?? []]) await ensurePlugin(...resolvePluginSource(plugin));
+	await ensurePlugins([...DEFAULT_PLUGINS, ...config.fixtures?.flatMap((f) => f.plugins ?? []) ?? []]);
 	const adminId = Number(await wpCli([
 		"user",
 		"get",
@@ -88,7 +86,12 @@ async function bootstrapWp(config) {
 	const appPassword = await createAdminAppPassword();
 	await wpCli([
 		"option",
-		"update",
+		"delete",
+		SEED_MARKER_OPTION
+	]).catch(() => {});
+	await wpCli([
+		"option",
+		"add",
 		SEED_MARKER_OPTION,
 		SEED_VERSION,
 		"--autoload=no"
@@ -111,4 +114,4 @@ async function bootstrapWp(config) {
 }
 
 //#endregion
-export { bootstrapWp };
+export { bootstrapWp, createAdminAppPassword, seedUsers };

package/dist/cli/wp/byo.js

@@ -0,0 +1,113 @@
+import { execFileSync } from "node:child_process";
+import { cpSync, createReadStream, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { createInterface } from "node:readline";
+
+//#region src/cli/wp/byo.ts
+/** Path under the config's `.kizlo/` dir where the dump is staged for import, then deleted. */
+const SQL_STAGE_REL = ".kizlo/byo-import.sql";
+function tar(args) {
+	try {
+		return execFileSync("tar", args, {
+			encoding: "utf8",
+			maxBuffer: 64 * 1024 * 1024
+		});
+	} catch (error) {
+		const e = error;
+		throw new Error(`tar ${args.join(" ")} failed:\n${e.stderr || e.message}`);
+	}
+}
+/** Drop a leading `./` that some tar archives prefix entries with. */
+function norm(entry) {
+	return entry.replace(/^\.\//, "");
+}
+/** Move `src` to `dest`, falling back to copy+remove across filesystems (rename's EXDEV). */
+function moveInto(src, dest) {
+	try {
+		renameSync(src, dest);
+	} catch (error) {
+		if (error.code !== "EXDEV") throw error;
+		cpSync(src, dest, { recursive: true });
+		rmSync(src, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* Validate a BYO archive and return the name of its single root-level `.sql` dump. The
+* archive must be a `.tar.gz` holding a top-level `wordpress/` directory and exactly one
+* root-level `*.sql`, and must live outside `wordpressDir` (else `reset`, which wipes
+* that folder, would delete the archive before it could be re-read).
+*/
+function validateByoArchive(archivePath, wordpressDir) {
+	if (!existsSync(archivePath)) throw new Error(`dev.byo archive not found: ${archivePath}`);
+	if (!/\.tar(\.(gz|xz|bz2|zst))?$|\.(tgz|txz|tbz2?|tzst)$/i.test(archivePath)) throw new Error(`dev.byo must be a tar archive (.tar.gz, .tar.xz, .tar.bz2, .tar.zst, .tar): ${archivePath}`);
+	if (resolve(archivePath).startsWith(resolve(wordpressDir) + sep)) throw new Error(`dev.byo archive must live outside dev.path — reset would delete it: ${archivePath}`);
+	const entries = tar(["-tf", archivePath]).split("\n").map(norm).filter(Boolean);
+	if (!entries.some((e) => e === "wordpress/" || e.startsWith("wordpress/"))) throw new Error("dev.byo archive must contain a top-level `wordpress/` directory");
+	const sqls = entries.filter((e) => /^[^/]+\.sql$/.test(e));
+	if (sqls.length !== 1) throw new Error(`dev.byo archive must contain exactly one root-level .sql file (found ${sqls.length})`);
+	return sqls[0];
+}
+/**
+* Detect the dump's table prefix from its `{prefix}options` table — the one table every
+* WordPress install has exactly one of. Streams the file and stops at the first match;
+* falls back to `wp_` when none is found (so a standard dump still imports).
+*/
+async function detectTablePrefix(sqlPath) {
+	const rl = createInterface({
+		input: createReadStream(sqlPath),
+		crlfDelay: Number.POSITIVE_INFINITY
+	});
+	try {
+		for await (const line of rl) {
+			const match = line.match(/(?:CREATE TABLE(?:\s+IF NOT EXISTS)?|INSERT INTO)\s+`?([0-9a-zA-Z$_]+?)options`?\b/i);
+			if (match) return match[1];
+		}
+	} finally {
+		rl.close();
+	}
+	return "wp_";
+}
+/**
+* Lay a BYO install onto disk before the containers boot: extract the archive, move its
+* `wordpress/` files into `wordpressDir` (dropping the bundled `wp-config.php` — the image
+* regenerates one with the compose DB credentials), stage the dump under `.kizlo/`, and
+* read its table prefix. Returns the prefix (to match the regenerated config) and the host
+* path of the staged dump (the caller pipes it into the `mysql` container, then deletes it).
+*/
+async function prepareByo(archivePath, wordpressDir, configDir) {
+	const sqlName = validateByoArchive(archivePath, wordpressDir);
+	const tmp = join(configDir, ".kizlo", "byo-extract");
+	rmSync(tmp, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync(tmp, { recursive: true });
+	try {
+		tar([
+			"-xf",
+			archivePath,
+			"-C",
+			tmp
+		]);
+		mkdirSync(wordpressDir, { recursive: true });
+		for (const entry of readdirSync(join(tmp, "wordpress"))) moveInto(join(tmp, "wordpress", entry), join(wordpressDir, entry));
+		rmSync(join(wordpressDir, "wp-config.php"), { force: true });
+		const sqlPath = join(configDir, SQL_STAGE_REL);
+		moveInto(join(tmp, sqlName), sqlPath);
+		return {
+			prefix: await detectTablePrefix(sqlPath),
+			sqlPath
+		};
+	} finally {
+		rmSync(tmp, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+
+//#endregion
+export { prepareByo };

package/dist/cli/wp/compose/docker-compose.yml

@@ -1,5 +1,4 @@
-name: kizlo-wp-test
-
+# Project name is supplied per-stack via `docker compose -p <project>`.
 services:
   mysql:
     image: mysql:8

package/dist/cli/wp/compose/opcache.ini

@@ -0,0 +1,16 @@
+; Kizlo dev — PHP OPcache tuned for local development.
+;
+; OPcache keeps compiled PHP bytecode in memory, so WordPress skips re-reading and
+; recompiling its hundreds of files on every request — the single biggest speedup
+; when the install is bind-mounted from the host.
+;
+; validate_timestamps=1 (with revalidate_freq=0) makes OPcache re-check each file's
+; mtime every request, so live edits from a bind mount show up immediately. Never
+; set this to 0 in dev or your changes will appear "stuck" behind a stale cache.
+opcache.enable=1
+opcache.enable_cli=0
+opcache.memory_consumption=128
+opcache.interned_strings_buffer=16
+opcache.max_accelerated_files=10000
+opcache.validate_timestamps=1
+opcache.revalidate_freq=0