kizlo 0.1.0 → 0.2.0

package/dist/cli/wp/compose/override.test.ts

@@ -0,0 +1,115 @@
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+import { afterEach, beforeEach, describe, expect, test } from "vitest"
+import { OPCACHE_INI, REMAP_ENTRYPOINT } from "../constants"
+import { writeDevOverride, writeTestOverride } from "./override"
+
+describe("writeDevOverride", () => {
+	let dir: string
+	let wordpressDir: string
+
+	beforeEach(() => {
+		dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "kizlo-ovr-")))
+		wordpressDir = path.join(dir, "wordpress")
+	})
+
+	afterEach(() => {
+		fs.rmSync(dir, { recursive: true, force: true })
+	})
+
+	test("bind-mounts the whole install on both services and creates the host dir", () => {
+		const file = writeDevOverride(dir, { wordpressDir, mounts: [] })
+		expect(file).toBe(path.join(dir, ".kizlo", "docker-compose.dev.override.yml"))
+		expect(fs.existsSync(wordpressDir)).toBe(true)
+
+		const body = fs.readFileSync(file, "utf8")
+		expect(body).toContain("  wordpress:")
+		expect(body).toContain("  wp-cli:")
+		expect(body).toContain(`- "${wordpressDir}:/var/www/html"`)
+	})
+
+	test("always mounts the dev OPcache config into the wordpress service, read-only", () => {
+		const body = fs.readFileSync(writeDevOverride(dir, { wordpressDir, mounts: [] }), "utf8")
+		expect(body).toContain(`- "${OPCACHE_INI}:/usr/local/etc/php/conf.d/zz-kizlo-opcache.ini:ro"`)
+	})
+
+	test("layers plugin mounts by basename, after the root bind", () => {
+		const body = fs.readFileSync(writeDevOverride(dir, { wordpressDir, mounts: ["plugins/kizlo"] }), "utf8")
+		const rootBind = `- "${wordpressDir}:/var/www/html"`
+		const pluginBind = `- "${path.join(dir, "plugins/kizlo")}:/var/www/html/wp-content/plugins/kizlo"`
+		expect(body).toContain(pluginBind)
+		expect(body.indexOf(rootBind)).toBeLessThan(body.indexOf(pluginBind))
+	})
+
+	test("keeps absolute mount paths verbatim", () => {
+		const abs = path.join(dir, "external", "my-plugin")
+		const body = fs.readFileSync(writeDevOverride(dir, { wordpressDir, mounts: [abs] }), "utf8")
+		expect(body).toContain(`- "${abs}:/var/www/html/wp-content/plugins/my-plugin"`)
+	})
+
+	test("publishes MySQL on the given host port, bound to loopback", () => {
+		const body = fs.readFileSync(writeDevOverride(dir, { wordpressDir, mounts: [], dbPort: 3307 }), "utf8")
+		expect(body).toContain("  mysql:")
+		expect(body).toContain('- "127.0.0.1:3307:3306"')
+	})
+
+	test("leaves MySQL internal-only when no db port is given", () => {
+		const body = fs.readFileSync(writeDevOverride(dir, { wordpressDir, mounts: [] }), "utf8")
+		expect(body).not.toContain("  mysql:")
+	})
+
+	test("omits the uid-remap entrypoint when no host user is given (macOS/Windows)", () => {
+		const body = fs.readFileSync(writeDevOverride(dir, { wordpressDir, mounts: [] }), "utf8")
+		expect(body).not.toContain("entrypoint:")
+		expect(body).not.toContain("KIZLO_PUID")
+		expect(body).not.toContain("user:")
+	})
+
+	test("runs the container as the host user and injects the remap entrypoint (Linux)", () => {
+		const body = fs.readFileSync(writeDevOverride(dir, { wordpressDir, mounts: [], hostUser: { uid: 1000, gid: 1000 } }), "utf8")
+		expect(body).toContain('entrypoint: ["sh","/usr/local/bin/kizlo-remap-entrypoint.sh"]')
+		expect(body).toContain(`- "${REMAP_ENTRYPOINT}:/usr/local/bin/kizlo-remap-entrypoint.sh:ro"`)
+		expect(body).toContain('KIZLO_PUID: "1000"')
+		expect(body).toContain('KIZLO_PGID: "1000"')
+		// wp-cli runs directly as the host user (no entrypoint wrapper needed there).
+		expect(body).toContain('user: "1000:1000"')
+	})
+})
+
+describe("writeTestOverride", () => {
+	let dir: string
+
+	beforeEach(() => {
+		dir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "kizlo-tovr-")))
+	})
+
+	afterEach(() => {
+		fs.rmSync(dir, { recursive: true, force: true })
+	})
+
+	test("mounts local plugin dirs by basename on both services", () => {
+		const file = writeTestOverride(dir, ["plugins/kizlo-woocommerce"])
+		expect(file).toBe(path.join(dir, ".kizlo", "docker-compose.test.override.yml"))
+
+		const body = fs.readFileSync(file, "utf8")
+		const pluginBind = `- "${path.join(dir, "plugins/kizlo-woocommerce")}:/var/www/html/wp-content/plugins/kizlo-woocommerce"`
+		expect(body).toContain("  wordpress:")
+		expect(body).toContain("  wp-cli:")
+		// One bind per service.
+		expect(body.split(pluginBind).length - 1).toBe(2)
+	})
+
+	test("keeps absolute mount paths verbatim", () => {
+		const abs = path.join(dir, "external", "my-plugin")
+		const body = fs.readFileSync(writeTestOverride(dir, [abs]), "utf8")
+		expect(body).toContain(`- "${abs}:/var/www/html/wp-content/plugins/my-plugin"`)
+	})
+
+	test("touches nothing but plugin mounts — no root bind, OPcache, or db port", () => {
+		const body = fs.readFileSync(writeTestOverride(dir, ["plugins/kizlo"]), "utf8")
+		expect(body).not.toContain(':/var/www/html"')
+		expect(body).not.toContain("opcache")
+		expect(body).not.toContain("  mysql:")
+	})
+})

package/dist/cli/wp/compose/override.ts

@@ -0,0 +1,134 @@
+import { mkdirSync, writeFileSync } from "node:fs"
+import { basename, dirname, isAbsolute, resolve } from "node:path"
+import { OPCACHE_INI, REMAP_ENTRYPOINT } from "../constants"
+
+/** Generated dev override location, relative to the config root. */
+const OVERRIDE_REL = ".kizlo/docker-compose.dev.override.yml"
+/** Generated test override location (plugin mounts only), relative to the config root. */
+const TEST_OVERRIDE_REL = ".kizlo/docker-compose.test.override.yml"
+
+const WP_ROOT = "/var/www/html"
+const PLUGINS_DIR = `${WP_ROOT}/wp-content/plugins`
+/** Where the dev OPcache config is dropped so the container's PHP picks it up. */
+const PHP_CONF_TARGET = "/usr/local/etc/php/conf.d/zz-kizlo-opcache.ini"
+/** Where the Linux uid-remap entrypoint is mounted (run via `sh`, so no +x needed). */
+const REMAP_TARGET = "/usr/local/bin/kizlo-remap-entrypoint.sh"
+
+export interface DevOverrideOptions {
+	/** Absolute host directory the whole WordPress install is bind-mounted to. */
+	wordpressDir: string
+	/** Local plugin directories to bind-mount into `wp-content/plugins`, by basename. */
+	mounts: string[]
+	/**
+	 * Host user to run the container as (Linux only). When set, www-data is retagged
+	 * to this uid/gid so files WordPress writes are owned by the host user. Omitted on
+	 * macOS/Windows, where Docker already maps ownership.
+	 */
+	hostUser?: { uid: number; gid: number }
+	/**
+	 * Host port to publish the MySQL service on, bound to `127.0.0.1`, so a SQL client
+	 * can reach the dev database directly. Omitted leaves MySQL internal-only.
+	 */
+	dbPort?: number
+}
+
+interface ServiceBlock {
+	user?: string
+	entrypoint?: string[]
+	env?: Record<string, string>
+	ports?: string[]
+	volumes?: string[]
+}
+
+function renderService(name: string, block: ServiceBlock): string {
+	const lines = [`  ${name}:`]
+	if (block.user) lines.push(`    user: "${block.user}"`)
+	if (block.entrypoint) lines.push(`    entrypoint: ${JSON.stringify(block.entrypoint)}`)
+	if (block.env) {
+		lines.push("    environment:")
+		for (const [key, value] of Object.entries(block.env)) lines.push(`      ${key}: "${value}"`)
+	}
+	if (block.ports?.length) lines.push("    ports:", ...block.ports.map((p) => `      - "${p}"`))
+	if (block.volumes?.length) lines.push("    volumes:", ...block.volumes)
+	return lines.join("\n")
+}
+
+/**
+ * A compose volume line (`- "host:container"`). `:ro` marks it read-only — the
+ * container can read it but never write back to the host file.
+ */
+function bind(host: string, container: string, readOnly = false): string {
+	return `      - "${host}:${container}${readOnly ? ":ro" : ""}"`
+}
+
+/** Resolve each local-plugin dir to a volume bind under `wp-content/plugins`, layered by basename. */
+function pluginBinds(configDir: string, mounts: string[]): string[] {
+	return mounts.map((entry) => bind(isAbsolute(entry) ? entry : resolve(configDir, entry), `${PLUGINS_DIR}/${basename(entry)}`))
+}
+
+/**
+ * Generate the dev compose override. The whole install is bind-mounted from the
+ * host `wordpressDir`, so every file is live and editable; local plugin dirs layer
+ * on top by basename; and the dev OPcache config is dropped into PHP (a speed win
+ * with live-edit-safe settings). Binds apply to both `wordpress` (serves the site)
+ * and `wp-cli` (activates plugins). On Linux (`hostUser` set) the container also
+ * runs as the host user so generated files are owned by you, not uid 33. Returns
+ * the override path to append to the dev stack's compose files.
+ */
+export function writeDevOverride(configDir: string, opts: DevOverrideOptions): string {
+	const path = resolve(configDir, OVERRIDE_REL)
+	mkdirSync(dirname(path), { recursive: true })
+	mkdirSync(opts.wordpressDir, { recursive: true })
+
+	const mounts = pluginBinds(configDir, opts.mounts)
+	const rootBind = bind(opts.wordpressDir, WP_ROOT)
+	const remap = opts.hostUser
+		? {
+				// Run the wrapper as root so it can retag www-data, then it hands off to
+				// the normal entrypoint; wp-cli just runs directly as the host user.
+				wordpress: {
+					user: "0:0",
+					entrypoint: ["sh", REMAP_TARGET],
+					env: { KIZLO_PUID: String(opts.hostUser.uid), KIZLO_PGID: String(opts.hostUser.gid) },
+					scriptBind: bind(REMAP_ENTRYPOINT, REMAP_TARGET, true),
+				},
+				wpCliUser: `${opts.hostUser.uid}:${opts.hostUser.gid}`,
+			}
+		: undefined
+
+	const wordpress: ServiceBlock = {
+		user: remap?.wordpress.user,
+		entrypoint: remap?.wordpress.entrypoint,
+		env: remap?.wordpress.env,
+		volumes: [...(remap ? [remap.wordpress.scriptBind] : []), rootBind, ...mounts, bind(OPCACHE_INI, PHP_CONF_TARGET, true)],
+	}
+	const wpCli: ServiceBlock = { user: remap?.wpCliUser, volumes: [rootBind, ...mounts] }
+
+	// Publish MySQL on a host port (loopback only) so advanced users can point a SQL
+	// client at the dev database. Internal-only when no port is configured.
+	const services = [renderService("wordpress", wordpress), renderService("wp-cli", wpCli)]
+	if (opts.dbPort) services.push(renderService("mysql", { ports: [`127.0.0.1:${opts.dbPort}:3306`] }))
+
+	writeFileSync(path, `services:\n${services.join("\n")}\n`)
+	return path
+}
+
+/**
+ * Generate the test compose override: bind-mount the fixtures' local plugin dirs over
+ * `wp-content/plugins` (by basename) on both `wordpress` and `wp-cli`, layered on top of
+ * the test stack's `wp_data` volume. Unlike the dev override it touches nothing else —
+ * the test stack keeps its volume-backed install, OPcache, and default entrypoints — so a
+ * fixture carrying a `{ path }` plugin runs against your live source with no build/zip
+ * step, exactly as in `kizlo dev`. Returns the override path to append to the test stack's
+ * compose files.
+ */
+export function writeTestOverride(configDir: string, mounts: string[]): string {
+	const path = resolve(configDir, TEST_OVERRIDE_REL)
+	mkdirSync(dirname(path), { recursive: true })
+
+	const binds = pluginBinds(configDir, mounts)
+	const services = [renderService("wordpress", { volumes: binds }), renderService("wp-cli", { volumes: binds })]
+
+	writeFileSync(path, `services:\n${services.join("\n")}\n`)
+	return path
+}

package/dist/cli/wp/compose/remap-entrypoint.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+# Kizlo dev — Linux file-ownership fix.
+#
+# On native Linux, files the container writes into the bind-mounted install would
+# be owned by www-data (uid 33), not you, leaving "permission denied" when you edit
+# them from your file manager. This wrapper runs first (as root), retags www-data to
+# the host user's uid/gid, then hands off to the normal WordPress entrypoint — so
+# everything WordPress creates is owned by you. Injected only on Linux; Mac/Windows
+# never see this file.
+set -e
+
+if [ -n "$KIZLO_PUID" ] && [ "$KIZLO_PUID" != "0" ]; then
+	usermod -o -u "$KIZLO_PUID" www-data 2>/dev/null || true
+	groupmod -o -g "$KIZLO_PGID" www-data 2>/dev/null || true
+fi
+
+exec docker-entrypoint.sh "$@"

package/dist/cli/wp/constants.js

@@ -1,4 +1,4 @@
-import { githubRelease } from "./utils.js";
+import { kizloRelease } from "./utils.js";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -7,6 +7,10 @@ const DEFAULT_PORT = 8080;
 const HERE = dirname(fileURLToPath(import.meta.url));
 /** The docker-compose file shipped alongside this module (in both `src/` and `dist/`). */
 const COMPOSE_FILE = resolve(HERE, "compose/docker-compose.yml");
+/** Dev PHP OPcache config, shipped alongside this module and bind-mounted into the dev stack. */
+const OPCACHE_INI = resolve(HERE, "compose/opcache.ini");
+/** Linux-only entrypoint that retags www-data to the host user (see the script for why). */
+const REMAP_ENTRYPOINT = resolve(HERE, "compose/remap-entrypoint.sh");
 const CONFIG_FILES = [
 	"kizlo.config.ts",
 	"kizlo.config.js",
@@ -14,11 +18,6 @@ const CONFIG_FILES = [
 ];
 /** Credentials artifact location, relative to the config root. */
 const CREDENTIALS_REL = ".kizlo/test-credentials.json";
-const COMPOSE = [
-	"compose",
-	"-f",
-	COMPOSE_FILE
-];
 /**
 * DB-side marker written as the final bootstrap step and checked by `isSeeded`.
 * It records that this database holds a completed bootstrap — independent of any
@@ -30,7 +29,7 @@ const SEED_VERSION = "1";
 /** The kizlo core WordPress plugin, always installed during bootstrap. */
 const DEFAULT_PLUGINS = [{
 	name: "kizlo",
-	source: githubRelease("kizlo-io/kizlo-wordpress", "kizlo-v1.0.0-beta.3")
+	source: kizloRelease("kizlo")
 }];
 const TEST_ADMIN = {
 	firstName: "Admin",
@@ -49,4 +48,4 @@ const TEST_USER = {
 };
 
 //#endregion
-export { COMPOSE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER };
+export { COMPOSE_FILE, CONFIG_FILES, CREDENTIALS_REL, DEFAULT_PLUGINS, DEFAULT_PORT, OPCACHE_INI, REMAP_ENTRYPOINT, SEED_MARKER_OPTION, SEED_VERSION, TEST_ADMIN, TEST_USER };

package/dist/cli/wp/dev.js

@@ -0,0 +1,146 @@
+import { WordPressService } from "../../wordpress/service.js";
+import { compose, composeUp, wpCli } from "./docker.js";
+import { DEFAULT_PLUGINS, TEST_ADMIN } from "./constants.js";
+import { ensurePlugins } from "./utils.js";
+import { createAdminAppPassword, seedUsers } from "./bootstrap.js";
+import { prepareByo } from "./byo.js";
+import { randomBytes } from "node:crypto";
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+
+//#region src/cli/wp/dev.ts
+/** A strong random admin password (144 bits, URL/JSON/CLI-safe characters). */
+function generatePassword() {
+	return randomBytes(18).toString("base64url");
+}
+/**
+* Seed `dev.fixtures` into a freshly installed dev stack, reusing the test seeding
+* primitives: seed the default subscriber so `ctx.userId` exists, then run each `seed`
+* over REST. Plugins are already active (`bootstrapDev` ensures them before seeding).
+* The application password is minted only to drive seeding here — it's never printed
+* or persisted. Returns the number of fixtures seeded.
+*/
+async function seedDevFixtures(cfg, url) {
+	const userId = await seedUsers();
+	const adminId = Number(await wpCli([
+		"user",
+		"get",
+		TEST_ADMIN.username,
+		"--field=ID"
+	]));
+	const password = await createAdminAppPassword("kizlo-dev-seed");
+	const ctx = {
+		service: new WordPressService({ credentials: {
+			url,
+			username: TEST_ADMIN.username,
+			password
+		} }),
+		adminId,
+		userId
+	};
+	let seeded = 0;
+	for (const fixture of cfg.fixtures) if (fixture.seed) {
+		await fixture.seed(ctx);
+		seeded++;
+	}
+	return seeded;
+}
+/**
+* Boot the dev stack via docker + wp-cli. A fresh stack is provisioned one of two ways:
+* a default `wp core install`, or — when `dev.byo` points at an archive — hydrated from
+* that existing site (files + database). Either way it then sets permalinks and ensures
+* the `dev.fixtures` plugins (installed sources + bind-mounted locals). An already-provisioned
+* stack is left untouched (idempotent reruns).
+*
+* Credentials are an output, not a stored file: a default fresh install mints a random
+* admin password and returns it once (to log into wp-admin); a BYO install uses the
+* imported site's own users. No application password is minted — that's a test-stack
+* concern.
+*/
+async function bootstrapDev(cfg) {
+	const url = `http://localhost:${cfg.port}`;
+	const byo = !existsSync(join(cfg.wordpressDir, "wp-includes", "version.php")) && cfg.byo ? await prepareByo(cfg.byo, cfg.wordpressDir, cfg.configDir) : void 0;
+	await composeUp();
+	const installed = (await compose([
+		"exec",
+		"-T",
+		"wp-cli",
+		"wp",
+		"core",
+		"is-installed"
+	])).code === 0;
+	let password;
+	let imported = false;
+	if (!installed && byo) {
+		imported = true;
+		if (byo.prefix !== "wp_") await wpCli([
+			"config",
+			"set",
+			"table_prefix",
+			byo.prefix,
+			"--type=variable"
+		]);
+		const imp = await compose([
+			"exec",
+			"-T",
+			"mysql",
+			"mysql",
+			"-uwordpress",
+			"-pwppass",
+			"wordpress"
+		], { inputFile: byo.sqlPath });
+		if (imp.code !== 0) throw new Error(`importing dev.byo database failed:\n${imp.stderr || imp.stdout}`);
+		rmSync(byo.sqlPath, { force: true });
+		const oldUrl = await wpCli([
+			"option",
+			"get",
+			"siteurl"
+		]).catch(() => "");
+		if (oldUrl && oldUrl !== url) await wpCli([
+			"search-replace",
+			oldUrl,
+			url,
+			"--all-tables",
+			"--skip-columns=guid",
+			"--report-changed-only"
+		]);
+		await wpCli([
+			"rewrite",
+			"flush",
+			"--hard"
+		]);
+	} else if (!installed) {
+		password = generatePassword();
+		await wpCli([
+			"core",
+			"install",
+			`--url=${url}`,
+			"--title=Kizlo Dev",
+			`--admin_user=${TEST_ADMIN.username}`,
+			`--admin_password=${password}`,
+			`--admin_email=${TEST_ADMIN.email}`,
+			"--skip-email"
+		]);
+		await wpCli([
+			"rewrite",
+			"structure",
+			"/%postname%/",
+			"--hard"
+		]);
+	}
+	await ensurePlugins([...DEFAULT_PLUGINS, ...cfg.fixtures.flatMap((fixture) => fixture.plugins ?? [])]);
+	const seeded = !installed && !byo && cfg.fixtures.length ? await seedDevFixtures(cfg, url) : 0;
+	const appPassword = password ? await createAdminAppPassword("kizlo-dev") : void 0;
+	return {
+		url,
+		username: TEST_ADMIN.username,
+		dbPort: cfg.dbPort,
+		imported,
+		seeded,
+		appPassword,
+		secrets: password ? { password } : void 0
+	};
+}
+
+//#endregion
+export { bootstrapDev };

package/dist/cli/wp/docker.d.ts

@@ -1,24 +1,64 @@
 //#region src/cli/wp/docker.d.ts
+/**
+ * Options for a spawned docker command.
+ * - `input`/`inputFile`: data piped to stdin (an in-memory string, or a file streamed from disk).
+ * - `detached`: run in its own process group so a terminal Ctrl+C (delivered to the whole
+ *   foreground group) can't kill it mid-flight — used for teardown's `stop`, which must finish.
+ */
+type RunInput = {
+  input?: string;
+  inputFile?: string;
+  detached?: boolean;
+};
+/** A docker-compose stack: project id (`-p`), published port, and compose files (`-f`). */
+interface Stack {
+  /** Compose project name — isolates this stack's containers + volumes. */
+  project: string;
+  /** Host port published for WordPress (exported as `WP_PORT`). */
+  port: number;
+  /** Compose files, base first then any generated override. */
+  composeFiles: string[];
+}
+/** Stack-bound docker helpers. */
+interface DockerStack {
+  compose(args: string[], opts?: RunInput): Promise<RunResult>;
+  composeUp(): Promise<void>;
+  composeStop(opts?: {
+    detached?: boolean;
+  }): Promise<void>;
+  composeDown(opts?: {
+    volumes?: boolean;
+  }): Promise<void>;
+  /** The host port this stack's WordPress is currently published on, or `undefined` if it isn't running. */
+  publishedPort(): Promise<number | undefined>;
+  wpCli(args: string[]): Promise<string>;
+}
 interface RunResult {
   code: number;
   stdout: string;
   stderr: string;
 }
-/** `docker compose <args>` against the harness compose file. */
-declare function compose(args: string[], opts?: {
-  input?: string;
-}): Promise<RunResult>;
-/** Bring services up detached and wait for health checks. */
-declare function composeUp(): Promise<void>;
-/** Tear everything down, optionally removing volumes. */
-declare function composeDown(opts?: {
-  volumes?: boolean;
-}): Promise<void>;
-/** `docker compose stop` — halt containers but keep volumes (DB intact). */
-declare function composeStop(): Promise<void>;
 /**
- * Run a wp-cli command against the warm `wp-cli` container and return trimmed stdout.
+ * Whether the Docker daemon is reachable. `docker version` contacts the server (not just
+ * the client), so a non-zero exit means the daemon is down or Docker isn't installed —
+ * the early check before a command that needs a stack (e.g. `init`'s local setup).
  */
-declare function wpCli(args: string[]): Promise<string>;
+declare function dockerAvailable(): Promise<boolean>;
+/** Build a stack-bound docker helper and mark it active for the bare helpers below. */
+declare function createStack(stack: Stack): DockerStack;
+/** `docker compose <args>` against the active stack. */
+declare const compose: DockerStack["compose"];
+/** Bring the active stack's services up detached and wait for health checks. */
+declare const composeUp: () => Promise<void>;
+/** Tear the active stack down, optionally removing volumes. */
+declare const composeDown: (opts?: {
+  volumes?: boolean;
+}) => Promise<void>;
+/** `docker compose stop` — halt the active stack's containers but keep volumes. */
+declare const composeStop: (opts?: {
+  detached?: boolean;
+}) => Promise<void>;
+/** Run a wp-cli command against the active stack's warm `wp-cli` container. */
+declare const wpCli: (args: string[]) => Promise<string>;
 //#endregion
-export { compose, composeDown, composeStop, composeUp, wpCli };
+export { DockerStack, RunResult, Stack, compose, composeDown, composeStop, composeUp, createStack, dockerAvailable, wpCli };