@bensandee/tooling 0.16.0 → 0.18.0

package/README.md

@@ -55,7 +55,7 @@ The tool auto-detects project structure, CI platform, project type, and Docker p
 
 Docker packages are discovered automatically. Any package with a `Dockerfile` or `docker/Dockerfile` is a Docker package. Image names are derived as `{root-package-name}-{package-name}`, build context defaults to `.` (project root). For single-package repos, `Dockerfile` or `docker/Dockerfile` at the project root is checked.
 
-When Docker packages are present, `repo:sync` generates a deploy workflow (`.forgejo/workflows/deploy.yml` or `.github/workflows/deploy.yml`) triggered on version tags (`v*.*.*`) that runs `pnpm exec tooling docker:publish`.
+When Docker packages are present, `repo:sync` generates a deploy workflow (`.forgejo/workflows/publish.yml` or `.github/workflows/publish.yml`) triggered on version tags (`v*.*.*`) that runs `pnpm exec tooling docker:publish`.
 
 #### Overrides
 
@@ -219,5 +219,3 @@ if (!result.success) {
 | `VerifyResult`         | Result: `{ success: true, elapsedMs }` or `{ success: false, reason, message, elapsedMs }` |
 | `DockerVerifyExecutor` | Side-effect abstraction (exec, fetch, timers) for testability                              |
 | `ContainerInfo`        | Container status info from `composePs`                                                     |
-
-## [Changelog](./CHANGELOG.md)

package/dist/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as isExecSyncError } from "./exec-CC49vrkM.mjs";
+import { l as createRealExecutor$1, t as runVerification, u as isExecSyncError } from "./verify-BaWlzdPh.mjs";
 import { defineCommand, runMain } from "citty";
 import * as p from "@clack/prompts";
 import path from "node:path";
@@ -7,7 +7,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync
 import JSON5 from "json5";
 import { parse } from "jsonc-parser";
 import { z } from "zod";
-import { isMap, isSeq, parseDocument } from "yaml";
+import { isMap, isSeq, parse as parse$1, parseDocument } from "yaml";
 import { execSync } from "node:child_process";
 import { FatalError, TransientError, UnexpectedError } from "@bensandee/common";
 //#region src/types.ts
@@ -451,6 +451,21 @@ function createDryRunContext(config) {
 //#endregion
 //#region src/utils/tooling-config.ts
 const CONFIG_FILE = ".tooling.json";
+const DeclarativeHealthCheckSchema = z.object({
+	name: z.string(),
+	url: z.string(),
+	status: z.number().int().optional()
+});
+const DockerVerifyConfigSchema = z.object({
+	composeFiles: z.array(z.string()).optional(),
+	envFile: z.string().optional(),
+	services: z.array(z.string()).optional(),
+	healthChecks: z.array(DeclarativeHealthCheckSchema).optional(),
+	buildCommand: z.string().optional(),
+	buildCwd: z.string().optional(),
+	timeoutMs: z.number().int().positive().optional(),
+	pollIntervalMs: z.number().int().positive().optional()
+});
 const ToolingConfigSchema = z.object({
 	structure: z.enum(["single", "monorepo"]).optional(),
 	useEslintPlugin: z.boolean().optional(),
@@ -479,7 +494,8 @@ const ToolingConfigSchema = z.object({
 	docker: z.record(z.string(), z.object({
 		dockerfile: z.string(),
 		context: z.string().default(".")
-	})).optional()
+	})).optional(),
+	dockerVerify: DockerVerifyConfigSchema.optional()
 });
 /** Load saved tooling config from the target directory. Returns undefined if missing or invalid. */
 function loadToolingConfig(targetDir) {
@@ -639,8 +655,8 @@ function addReleaseDeps(deps, config) {
 function getAddedDevDepNames(config) {
 	const deps = { ...ROOT_DEV_DEPS };
 	if (config.structure !== "monorepo") Object.assign(deps, PER_PACKAGE_DEV_DEPS);
-	deps["@bensandee/config"] = "0.8.1";
-	deps["@bensandee/tooling"] = "0.16.0";
+	deps["@bensandee/config"] = "0.8.2";
+	deps["@bensandee/tooling"] = "0.18.0";
 	if (config.formatter === "oxfmt") deps["oxfmt"] = "0.35.0";
 	if (config.formatter === "prettier") deps["prettier"] = "3.8.1";
 	addReleaseDeps(deps, config);
@@ -660,8 +676,8 @@ async function generatePackageJson(ctx) {
 	if (ctx.config.releaseStrategy !== "none" && ctx.config.releaseStrategy !== "changesets") allScripts["trigger-release"] = "pnpm exec tooling release:trigger";
 	const devDeps = { ...ROOT_DEV_DEPS };
 	if (!isMonorepo) Object.assign(devDeps, PER_PACKAGE_DEV_DEPS);
-	devDeps["@bensandee/config"] = isWorkspacePackage(ctx, "@bensandee/config") ? "workspace:*" : "0.8.1";
-	devDeps["@bensandee/tooling"] = isWorkspacePackage(ctx, "@bensandee/tooling") ? "workspace:*" : "0.16.0";
+	devDeps["@bensandee/config"] = isWorkspacePackage(ctx, "@bensandee/config") ? "workspace:*" : "0.8.2";
+	devDeps["@bensandee/tooling"] = isWorkspacePackage(ctx, "@bensandee/tooling") ? "workspace:*" : "0.18.0";
 	if (ctx.config.useEslintPlugin) devDeps["@bensandee/eslint-plugin"] = isWorkspacePackage(ctx, "@bensandee/eslint-plugin") ? "workspace:*" : "0.9.2";
 	if (ctx.config.formatter === "oxfmt") devDeps["oxfmt"] = "0.35.0";
 	if (ctx.config.formatter === "prettier") devDeps["prettier"] = "3.8.1";
@@ -2479,7 +2495,7 @@ async function generateDeployCi(ctx) {
 		description: "Deploy CI workflow not applicable"
 	};
 	const isGitHub = ctx.config.ci === "github";
-	const workflowPath = isGitHub ? ".github/workflows/deploy.yml" : ".forgejo/workflows/deploy.yml";
+	const workflowPath = isGitHub ? ".github/workflows/publish.yml" : ".forgejo/workflows/publish.yml";
 	const nodeVersionYaml = hasEnginesNode(ctx) ? "node-version-file: package.json" : "node-version: \"24\"";
 	const content = deployWorkflow(ctx.config.ci, nodeVersionYaml);
 	if (ctx.exists(workflowPath)) {
@@ -4241,11 +4257,159 @@ const dockerBuildCommand = defineCommand({
 	}
 });
 //#endregion
+//#region src/docker-verify/detect.ts
+/** Compose file names to scan, in priority order. */
+const COMPOSE_FILE_CANDIDATES = [
+	"docker-compose.yaml",
+	"docker-compose.yml",
+	"compose.yaml",
+	"compose.yml"
+];
+/** Zod schema for the subset of compose YAML we care about. */
+const ComposePortSchema = z.union([z.string(), z.object({
+	published: z.union([z.string(), z.number()]),
+	target: z.union([z.string(), z.number()]).optional()
+}).passthrough()]);
+const ComposeServiceSchema = z.object({
+	ports: z.array(ComposePortSchema).optional(),
+	healthcheck: z.unknown().optional()
+}).passthrough();
+const ComposeFileSchema = z.object({ services: z.record(z.string(), ComposeServiceSchema).optional() }).passthrough();
+/** Detect which compose files exist at conventional paths. */
+function detectComposeFiles(cwd) {
+	return COMPOSE_FILE_CANDIDATES.filter((name) => existsSync(path.join(cwd, name)));
+}
+/** Parse a single port mapping string and extract the host port. */
+function parsePortString(port) {
+	const withoutProtocol = port.split("/")[0];
+	if (!withoutProtocol) return void 0;
+	const parts = withoutProtocol.split(":");
+	if (parts.length === 2) {
+		const host = parts[0];
+		if (!host) return void 0;
+		const parsed = Number.parseInt(host, 10);
+		return Number.isNaN(parsed) ? void 0 : parsed;
+	}
+	if (parts.length === 3) {
+		const host = parts[1];
+		if (!host) return void 0;
+		const parsed = Number.parseInt(host, 10);
+		return Number.isNaN(parsed) ? void 0 : parsed;
+	}
+}
+/** Extract the host port from a compose port definition. */
+function extractHostPort(port) {
+	if (typeof port === "string") return parsePortString(port);
+	const published = port.published;
+	if (typeof published === "number") return published;
+	if (typeof published === "string") {
+		const parsed = Number.parseInt(published, 10);
+		return Number.isNaN(parsed) ? void 0 : parsed;
+	}
+}
+/** Parse compose files and return service info (names, ports, healthcheck presence). */
+function parseComposeServices(cwd, composeFiles) {
+	const serviceMap = /* @__PURE__ */ new Map();
+	for (const file of composeFiles) {
+		let parsed;
+		try {
+			const content = readFileSync(path.join(cwd, file), "utf-8");
+			parsed = ComposeFileSchema.safeParse(parse$1(content));
+		} catch (_error) {
+			continue;
+		}
+		if (!parsed.success || !parsed.data.services) continue;
+		for (const [name, service] of Object.entries(parsed.data.services)) {
+			const existing = serviceMap.get(name);
+			let hostPort = existing?.hostPort;
+			if (hostPort === void 0 && service.ports) for (const port of service.ports) {
+				const extracted = extractHostPort(port);
+				if (extracted !== void 0) {
+					hostPort = extracted;
+					break;
+				}
+			}
+			serviceMap.set(name, {
+				name,
+				hostPort,
+				hasHealthcheck: existing?.hasHealthcheck ?? service.healthcheck !== void 0
+			});
+		}
+	}
+	return [...serviceMap.values()];
+}
+/** Generate health checks from parsed services: services with exposed ports get HTTP checks, unless they define a compose-level healthcheck. */
+function deriveHealthChecks(services) {
+	return services.filter((s) => s.hostPort !== void 0 && !s.hasHealthcheck).map((s) => ({
+		name: s.name,
+		url: `http://localhost:${String(s.hostPort)}/`
+	}));
+}
+/** Auto-detect compose config from conventional file locations. */
+function computeVerifyDefaults(cwd) {
+	const composeFiles = detectComposeFiles(cwd);
+	if (composeFiles.length === 0) return {};
+	const services = parseComposeServices(cwd, composeFiles);
+	const healthChecks = deriveHealthChecks(services);
+	return {
+		composeFiles,
+		services: services.map((s) => s.name),
+		healthChecks: healthChecks.length > 0 ? healthChecks : void 0
+	};
+}
+//#endregion
+//#region src/commands/docker-verify.ts
+/** Convert declarative health checks to functional ones. */
+function toHttpHealthChecks(checks) {
+	return checks.map((check) => ({
+		name: check.name,
+		url: check.url,
+		validate: async (res) => check.status ? res.status === check.status : res.ok
+	}));
+}
+const dockerVerifyCommand = defineCommand({
+	meta: {
+		name: "docker:verify",
+		description: "Verify Docker Compose stack health by auto-detecting services from compose files"
+	},
+	args: {
+		timeout: {
+			type: "string",
+			description: "Maximum time to wait for health checks, in ms (default: 120000)"
+		},
+		"poll-interval": {
+			type: "string",
+			description: "Interval between polling attempts, in ms (default: 5000)"
+		}
+	},
+	async run({ args }) {
+		const cwd = process.cwd();
+		const defaults = computeVerifyDefaults(cwd);
+		if (!defaults.composeFiles || defaults.composeFiles.length === 0) throw new FatalError("No compose files found. Expected docker-compose.yaml or compose.yaml.");
+		if (!defaults.services || defaults.services.length === 0) throw new FatalError("No services found in compose files.");
+		const config = {
+			compose: {
+				cwd,
+				composeFiles: defaults.composeFiles,
+				envFile: defaults.envFile,
+				services: defaults.services
+			},
+			buildCommand: defaults.buildCommand,
+			buildCwd: defaults.buildCwd,
+			healthChecks: defaults.healthChecks ? toHttpHealthChecks(defaults.healthChecks) : [],
+			timeoutMs: args.timeout ? Number.parseInt(args.timeout, 10) : defaults.timeoutMs,
+			pollIntervalMs: args["poll-interval"] ? Number.parseInt(args["poll-interval"], 10) : defaults.pollIntervalMs
+		};
+		const result = await runVerification(createRealExecutor$1(), config);
+		if (!result.success) throw new FatalError(`Verification failed (${result.reason}): ${result.message}`);
+	}
+});
+//#endregion
 //#region src/bin.ts
 const main = defineCommand({
 	meta: {
 		name: "tooling",
-		version: "0.16.0",
+		version: "0.18.0",
 		description: "Bootstrap and maintain standardized TypeScript project tooling"
 	},
 	subCommands: {
@@ -4257,10 +4421,11 @@ const main = defineCommand({
 		"changesets:merge": releaseMergeCommand,
 		"release:simple": releaseSimpleCommand,
 		"docker:publish": publishDockerCommand,
-		"docker:build": dockerBuildCommand
+		"docker:build": dockerBuildCommand,
+		"docker:verify": dockerVerifyCommand
 	}
 });
-console.log(`@bensandee/tooling v0.16.0`);
+console.log(`@bensandee/tooling v0.18.0`);
 runMain(main);
 //#endregion
 export {};

package/dist/docker-verify/index.mjs

@@ -1,218 +1,2 @@
-import { t as isExecSyncError } from "../exec-CC49vrkM.mjs";
-import { z } from "zod";
-import { execSync } from "node:child_process";
-//#region src/docker-verify/executor.ts
-/** Create an executor that runs real commands, fetches, and manages process signals. */
-function createRealExecutor() {
-	return {
-		exec(command, options) {
-			try {
-				return {
-					stdout: execSync(command, {
-						cwd: options?.cwd,
-						env: options?.env ? {
-							...process.env,
-							...options.env
-						} : void 0,
-						encoding: "utf-8",
-						stdio: [
-							"pipe",
-							"pipe",
-							"pipe"
-						]
-					}),
-					stderr: "",
-					exitCode: 0
-				};
-			} catch (err) {
-				if (isExecSyncError(err)) return {
-					stdout: err.stdout,
-					stderr: err.stderr,
-					exitCode: err.status
-				};
-				return {
-					stdout: "",
-					stderr: "",
-					exitCode: 1
-				};
-			}
-		},
-		execInherit(command, options) {
-			execSync(command, {
-				cwd: options?.cwd,
-				env: options?.env ? {
-					...process.env,
-					...options.env
-				} : void 0,
-				stdio: "inherit"
-			});
-		},
-		fetch: globalThis.fetch,
-		now: () => Date.now(),
-		sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-		onSignal(signal, handler) {
-			process.on(signal, handler);
-			return () => {
-				process.removeListener(signal, handler);
-			};
-		},
-		log: (msg) => console.log(msg),
-		logError: (msg) => console.error(msg)
-	};
-}
-//#endregion
-//#region src/docker-verify/compose.ts
-/** Zod schema for a single container entry from `docker compose ps --format json`. */
-const ContainerInfoSchema = z.object({
-	Service: z.string(),
-	Health: z.string()
-});
-/** Build the `docker compose` base command string from config. */
-function composeCommand(config) {
-	return `docker compose ${config.composeFiles.map((f) => `-f ${f}`).join(" ")}${config.envFile ? ` --env-file ${config.envFile}` : ""}`;
-}
-/** Run the build command if configured. */
-function buildImages(executor, config) {
-	if (!config.buildCommand) return;
-	executor.execInherit(config.buildCommand, { cwd: config.buildCwd ?? config.compose.cwd });
-}
-/** Start the compose stack in detached mode. */
-function composeUp(executor, config) {
-	executor.execInherit(`${composeCommand(config)} up -d`, { cwd: config.cwd });
-}
-/** Tear down the compose stack, removing volumes and orphans. Swallows errors. */
-function composeDown(executor, config) {
-	try {
-		executor.execInherit(`${composeCommand(config)} down -v --remove-orphans`, { cwd: config.cwd });
-	} catch (_error) {}
-}
-/** Show logs for a specific service (or all services if not specified). Swallows errors. */
-function composeLogs(executor, config, service) {
-	try {
-		const suffix = service ? ` ${service}` : "";
-		executor.execInherit(`${composeCommand(config)} logs${suffix}`, { cwd: config.cwd });
-	} catch (_error) {}
-}
-/**
-* Query container status via `docker compose ps --format json`.
-* Handles both JSON array and newline-delimited JSON (varies by docker compose version).
-*/
-function composePs(executor, config) {
-	const output = executor.exec(`${composeCommand(config)} ps --format json`, { cwd: config.cwd }).stdout.trim();
-	if (!output) return [];
-	const ArraySchema = z.array(ContainerInfoSchema);
-	try {
-		const direct = ArraySchema.safeParse(JSON.parse(output));
-		if (direct.success) return direct.data;
-		const single = ContainerInfoSchema.safeParse(JSON.parse(output));
-		if (single.success) return [single.data];
-	} catch (_error) {}
-	try {
-		const joined = `[${output.split("\n").join(",")}]`;
-		const delimited = ArraySchema.safeParse(JSON.parse(joined));
-		return delimited.success ? delimited.data : [];
-	} catch (_error) {
-		return [];
-	}
-}
-//#endregion
-//#region src/docker-verify/health.ts
-/** Look up the health status of a specific service from container info. */
-function getContainerHealth(containers, serviceName) {
-	return containers.find((c) => c.Service === serviceName)?.Health ?? "unknown";
-}
-/** Run a single HTTP health check, returning true if the validator passes. */
-async function checkHttpHealth(executor, check) {
-	try {
-		const response = await executor.fetch(check.url);
-		return await check.validate(response);
-	} catch (_error) {
-		return false;
-	}
-}
-//#endregion
-//#region src/docker-verify/verify.ts
-const DEFAULT_TIMEOUT_MS = 12e4;
-const DEFAULT_POLL_INTERVAL_MS = 5e3;
-/** Run the full Docker image verification lifecycle. */
-async function runVerification(executor, config) {
-	const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	const pollIntervalMs = config.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-	const { compose } = config;
-	const cleanup = () => composeDown(executor, compose);
-	const disposeInt = executor.onSignal("SIGINT", () => {
-		cleanup();
-		process.exit(1);
-	});
-	const disposeTerm = executor.onSignal("SIGTERM", () => {
-		cleanup();
-		process.exit(1);
-	});
-	try {
-		if (config.buildCommand) {
-			executor.log("Building images...");
-			buildImages(executor, config);
-		}
-		executor.log("Starting compose stack...");
-		composeUp(executor, compose);
-		executor.log(`Waiting for stack to be healthy (max ${timeoutMs / 1e3}s)...`);
-		const startTime = executor.now();
-		const healthStatus = new Map(config.healthChecks.map((c) => [c.name, false]));
-		while (executor.now() - startTime < timeoutMs) {
-			const containers = composePs(executor, compose);
-			for (const service of compose.services) if (getContainerHealth(containers, service) === "unhealthy") {
-				executor.logError(`Container ${service} is unhealthy`);
-				composeLogs(executor, compose, service);
-				cleanup();
-				return {
-					success: false,
-					reason: "unhealthy-container",
-					message: service,
-					elapsedMs: executor.now() - startTime
-				};
-			}
-			for (const check of config.healthChecks) if (!healthStatus.get(check.name)) {
-				if (await checkHttpHealth(executor, check)) {
-					healthStatus.set(check.name, true);
-					executor.log(`${check.name} is healthy!`);
-				}
-			}
-			if ([...healthStatus.values()].every(Boolean)) {
-				executor.log("Verification successful! All systems operational.");
-				cleanup();
-				return {
-					success: true,
-					elapsedMs: executor.now() - startTime
-				};
-			}
-			const elapsed = Math.floor((executor.now() - startTime) / 1e3);
-			if (elapsed > 0 && elapsed % 5 === 0) {
-				const statuses = [...healthStatus.entries()].map(([name, ok]) => `${name}=${ok ? "OK" : "Pending"}`).join(", ");
-				executor.log(`Waiting... (${elapsed}s elapsed). ${statuses}`);
-			}
-			await executor.sleep(pollIntervalMs);
-		}
-		executor.logError("Timeout waiting for stack to become healthy");
-		for (const service of compose.services) composeLogs(executor, compose, service);
-		cleanup();
-		return {
-			success: false,
-			reason: "timeout",
-			message: "Exceeded timeout",
-			elapsedMs: executor.now() - startTime
-		};
-	} catch (error) {
-		cleanup();
-		return {
-			success: false,
-			reason: "error",
-			message: error instanceof Error ? error.message : String(error),
-			elapsedMs: 0
-		};
-	} finally {
-		disposeInt();
-		disposeTerm();
-	}
-}
-//#endregion
+import { a as composeDown, c as composeUp, i as composeCommand, l as createRealExecutor, n as checkHttpHealth, o as composeLogs, r as getContainerHealth, s as composePs, t as runVerification } from "../verify-BaWlzdPh.mjs";
 export { checkHttpHealth, composeCommand, composeDown, composeLogs, composePs, composeUp, createRealExecutor, getContainerHealth, runVerification };

package/dist/verify-BaWlzdPh.mjs

@@ -0,0 +1,223 @@
+import { z } from "zod";
+import { execSync } from "node:child_process";
+//#region src/utils/exec.ts
+/** Type guard for `execSync` errors that carry stdout/stderr/status. */
+function isExecSyncError(err) {
+	return err instanceof Error && "stdout" in err && typeof err.stdout === "string" && "stderr" in err && typeof err.stderr === "string" && "status" in err && typeof err.status === "number";
+}
+//#endregion
+//#region src/docker-verify/executor.ts
+/** Create an executor that runs real commands, fetches, and manages process signals. */
+function createRealExecutor() {
+	return {
+		exec(command, options) {
+			try {
+				return {
+					stdout: execSync(command, {
+						cwd: options?.cwd,
+						env: options?.env ? {
+							...process.env,
+							...options.env
+						} : void 0,
+						encoding: "utf-8",
+						stdio: [
+							"pipe",
+							"pipe",
+							"pipe"
+						]
+					}),
+					stderr: "",
+					exitCode: 0
+				};
+			} catch (err) {
+				if (isExecSyncError(err)) return {
+					stdout: err.stdout,
+					stderr: err.stderr,
+					exitCode: err.status
+				};
+				return {
+					stdout: "",
+					stderr: "",
+					exitCode: 1
+				};
+			}
+		},
+		execInherit(command, options) {
+			execSync(command, {
+				cwd: options?.cwd,
+				env: options?.env ? {
+					...process.env,
+					...options.env
+				} : void 0,
+				stdio: "inherit"
+			});
+		},
+		fetch: globalThis.fetch,
+		now: () => Date.now(),
+		sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+		onSignal(signal, handler) {
+			process.on(signal, handler);
+			return () => {
+				process.removeListener(signal, handler);
+			};
+		},
+		log: (msg) => console.log(msg),
+		logError: (msg) => console.error(msg)
+	};
+}
+//#endregion
+//#region src/docker-verify/compose.ts
+/** Zod schema for a single container entry from `docker compose ps --format json`. */
+const ContainerInfoSchema = z.object({
+	Service: z.string(),
+	Health: z.string()
+});
+/** Build the `docker compose` base command string from config. */
+function composeCommand(config) {
+	return `docker compose ${config.composeFiles.map((f) => `-f ${f}`).join(" ")}${config.envFile ? ` --env-file ${config.envFile}` : ""}`;
+}
+/** Run the build command if configured. */
+function buildImages(executor, config) {
+	if (!config.buildCommand) return;
+	executor.execInherit(config.buildCommand, { cwd: config.buildCwd ?? config.compose.cwd });
+}
+/** Start the compose stack in detached mode. */
+function composeUp(executor, config) {
+	executor.execInherit(`${composeCommand(config)} up -d`, { cwd: config.cwd });
+}
+/** Tear down the compose stack, removing volumes and orphans. Swallows errors. */
+function composeDown(executor, config) {
+	try {
+		executor.execInherit(`${composeCommand(config)} down -v --remove-orphans`, { cwd: config.cwd });
+	} catch (_error) {}
+}
+/** Show logs for a specific service (or all services if not specified). Swallows errors. */
+function composeLogs(executor, config, service) {
+	try {
+		const suffix = service ? ` ${service}` : "";
+		executor.execInherit(`${composeCommand(config)} logs${suffix}`, { cwd: config.cwd });
+	} catch (_error) {}
+}
+/**
+* Query container status via `docker compose ps --format json`.
+* Handles both JSON array and newline-delimited JSON (varies by docker compose version).
+*/
+function composePs(executor, config) {
+	const output = executor.exec(`${composeCommand(config)} ps --format json`, { cwd: config.cwd }).stdout.trim();
+	if (!output) return [];
+	const ArraySchema = z.array(ContainerInfoSchema);
+	try {
+		const direct = ArraySchema.safeParse(JSON.parse(output));
+		if (direct.success) return direct.data;
+		const single = ContainerInfoSchema.safeParse(JSON.parse(output));
+		if (single.success) return [single.data];
+	} catch (_error) {}
+	try {
+		const joined = `[${output.split("\n").join(",")}]`;
+		const delimited = ArraySchema.safeParse(JSON.parse(joined));
+		return delimited.success ? delimited.data : [];
+	} catch (_error) {
+		return [];
+	}
+}
+//#endregion
+//#region src/docker-verify/health.ts
+/** Look up the health status of a specific service from container info. */
+function getContainerHealth(containers, serviceName) {
+	return containers.find((c) => c.Service === serviceName)?.Health ?? "unknown";
+}
+/** Run a single HTTP health check, returning true if the validator passes. */
+async function checkHttpHealth(executor, check) {
+	try {
+		const response = await executor.fetch(check.url);
+		return await check.validate(response);
+	} catch (_error) {
+		return false;
+	}
+}
+//#endregion
+//#region src/docker-verify/verify.ts
+const DEFAULT_TIMEOUT_MS = 12e4;
+const DEFAULT_POLL_INTERVAL_MS = 5e3;
+/** Run the full Docker image verification lifecycle. */
+async function runVerification(executor, config) {
+	const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const pollIntervalMs = config.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+	const { compose } = config;
+	const cleanup = () => composeDown(executor, compose);
+	const disposeInt = executor.onSignal("SIGINT", () => {
+		cleanup();
+		process.exit(1);
+	});
+	const disposeTerm = executor.onSignal("SIGTERM", () => {
+		cleanup();
+		process.exit(1);
+	});
+	try {
+		if (config.buildCommand) {
+			executor.log("Building images...");
+			buildImages(executor, config);
+		}
+		executor.log("Starting compose stack...");
+		composeUp(executor, compose);
+		executor.log(`Waiting for stack to be healthy (max ${timeoutMs / 1e3}s)...`);
+		const startTime = executor.now();
+		const healthStatus = new Map(config.healthChecks.map((c) => [c.name, false]));
+		while (executor.now() - startTime < timeoutMs) {
+			const containers = composePs(executor, compose);
+			for (const service of compose.services) if (getContainerHealth(containers, service) === "unhealthy") {
+				executor.logError(`Container ${service} is unhealthy`);
+				composeLogs(executor, compose, service);
+				cleanup();
+				return {
+					success: false,
+					reason: "unhealthy-container",
+					message: service,
+					elapsedMs: executor.now() - startTime
+				};
+			}
+			for (const check of config.healthChecks) if (!healthStatus.get(check.name)) {
+				if (await checkHttpHealth(executor, check)) {
+					healthStatus.set(check.name, true);
+					executor.log(`${check.name} is healthy!`);
+				}
+			}
+			if ([...healthStatus.values()].every(Boolean)) {
+				executor.log("Verification successful! All systems operational.");
+				cleanup();
+				return {
+					success: true,
+					elapsedMs: executor.now() - startTime
+				};
+			}
+			const elapsed = Math.floor((executor.now() - startTime) / 1e3);
+			if (elapsed > 0 && elapsed % 5 === 0) {
+				const statuses = [...healthStatus.entries()].map(([name, ok]) => `${name}=${ok ? "OK" : "Pending"}`).join(", ");
+				executor.log(`Waiting... (${elapsed}s elapsed). ${statuses}`);
+			}
+			await executor.sleep(pollIntervalMs);
+		}
+		executor.logError("Timeout waiting for stack to become healthy");
+		for (const service of compose.services) composeLogs(executor, compose, service);
+		cleanup();
+		return {
+			success: false,
+			reason: "timeout",
+			message: "Exceeded timeout",
+			elapsedMs: executor.now() - startTime
+		};
+	} catch (error) {
+		cleanup();
+		return {
+			success: false,
+			reason: "error",
+			message: error instanceof Error ? error.message : String(error),
+			elapsedMs: 0
+		};
+	} finally {
+		disposeInt();
+		disposeTerm();
+	}
+}
+//#endregion
+export { composeDown as a, composeUp as c, composeCommand as i, createRealExecutor as l, checkHttpHealth as n, composeLogs as o, getContainerHealth as r, composePs as s, runVerification as t, isExecSyncError as u };

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@bensandee/tooling",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "CLI tool to bootstrap and maintain standardized TypeScript project tooling",
   "bin": {
     "tooling": "./dist/bin.mjs"
   },
   "files": [
-    "dist",
-    "CHANGELOG.md"
+    "dist"
   ],
   "type": "module",
   "imports": {
@@ -42,7 +41,7 @@
     "tsdown": "0.21.2",
     "typescript": "5.9.3",
     "vitest": "4.0.18",
-    "@bensandee/config": "0.8.1"
+    "@bensandee/config": "0.8.2"
   },
   "optionalDependencies": {
     "@changesets/cli": "^2.29.4",

package/CHANGELOG.md

@@ -1,242 +0,0 @@
-# @bensandee/tooling
-
-## 0.16.0
-
-### Minor Changes
-
-- b3e6d83: Redesign as conventions-first tool: auto-detect project structure, CI platform, project type, and Docker packages from the filesystem. `.tooling.json` now stores overrides only. Replace `repo:init`/`repo:update`/`repo:check` with idempotent `repo:sync` (and `repo:sync --check`). Docker packages are discovered by convention (`Dockerfile` or `docker/Dockerfile` in package dirs) instead of requiring explicit config. First-run prompts reduced to release strategy, CI platform (if not detected), and formatter (if Prettier found).
-
-## 0.15.0
-
-### Minor Changes
-
-- 2ef37e2: Add `docker:build` and `docker:publish` CLI commands. Packages declare a `docker` field in their `package.json` with `dockerfile` and `context`, and the tooling handles `docker build` with the correct image name (`{repo}-{package}`). `docker:build --package .` enables a per-package `image:build` script for local testing. `docker:publish` builds all images, then tags/pushes them with semver variants (latest, vX.Y.Z, vX.Y, vX) from each package's own version. Also adds a deploy workflow generator (`setupDocker` config option) that emits a CI workflow triggered on version tags.
-- c09d233: Combine CI and release workflows for changesets strategy into a single check.yml with release job gated on check success
-
-### Patch Changes
-
-- 6cae944: Prompt to overwrite outdated release workflows during repo:update instead of only merging missing steps
-
-## 0.14.1
-
-### Patch Changes
-
-- caeebd8: Add d.ts declaration file output and types export conditions
-- caeebd8: Bump tsdown from 0.21.0 to 0.21.2
-- Updated dependencies [caeebd8]
-- Updated dependencies [caeebd8]
-  - @bensandee/common@0.1.2
-
-## 0.14.0
-
-### Minor Changes
-
-- e95d449: Add `--fail-fast` / `--no-fail-fast` flag to `checks:run` to control whether execution stops on the first failure. Defaults to fail-fast in dev and continue-on-error in CI.
-- 715a4ea: Add `@bensandee/tooling/docker-verify` subpath export: a TypeScript framework for Docker image verification with compose lifecycle management, HTTP health polling, container health monitoring, and signal-safe cleanup. Consumers import building blocks and compose them with custom validators instead of writing boilerplate.
-- 27c3480: Add `release:simple` command and rename CLI subcommands
-
-  **Breaking changes:**
-
-  - `release:create-forgejo-release` renamed to `forgejo:create-release`
-  - `release:merge` renamed to `changesets:merge`
-  - `releaseStrategy: "commit-and-tag-version"` renamed to `"simple"` in `.tooling.json` config
-  - Generated CI workflow for commit-and-tag-version now uses `pnpm exec tooling release:simple` instead of inline shell commands
-
-  **New feature:**
-
-  `release:simple` — a CLI command that handles the full release lifecycle for projects using commit-and-tag-version:
-
-  - Runs `commit-and-tag-version` to bump version, update CHANGELOG, and create a git tag
-  - Pushes to origin with `--follow-tags`
-  - Creates sliding version tags (vX, vX.Y) for flexible deployment pinning
-  - Creates Forgejo or GitHub releases automatically
-
-### Patch Changes
-
-- 715a4ea: Add README files to all published packages for npm registry documentation
-- 27c3480: Pre-populate `repo:init` prompts from saved `.tooling.json` config
-
-  When re-running `repo:init` on a project with an existing `.tooling.json`, each prompt now defaults to the previously saved choice instead of the detection-based default. Press Enter to keep existing settings or change only what you need.
-
-- d448ec6: Update node tsconfig base to use `nodenext` module resolution with `allowImportingTsExtensions`, enabling `.ts` extensions in imports for projects running TypeScript natively on Node 24+. Migrate all tooling-cli imports to use `.ts` extensions and switch `#src` subpath mapping to `#src/*.ts`. Use extensionless imports for library packages.
-- c49593f: Add `commit-and-tag-version` and `@changesets/cli` as optional dependencies
-
-  These tools are only needed when using their respective release strategies, so they're optional rather than required. Target projects already install them as devDependencies via the package-json generator.
-
-- Updated dependencies [715a4ea]
-- Updated dependencies [d448ec6]
-  - @bensandee/common@0.1.1
-
-## 0.13.0
-
-### Minor Changes
-
-- bbe3634: Add `checks:run` command (renamed from `repo:run-checks`). Add `ci:check`, `tooling:check`, and `tooling:update` as generated package.json scripts. CI workflows now run `pnpm ci:check`. Managed scripts are updated on `repo:update`/`repo:check` if they don't reference the expected command.
-
-### Patch Changes
-
-- f20b25d: `checks:run` now reads package.json to detect which scripts are defined. Undefined scripts show "(not defined)" instead of silently passing. Commands use `pnpm run` instead of `pnpm run --if-present`.
-
-## 0.12.0
-
-### Minor Changes
-
-- 5de6090: Add `repo:run-checks` command that runs all standard checks (build, typecheck, lint, test, format, knip, tooling:check, image:check) without short-circuiting, reporting a summary of failures at the end. Supports `--skip` to skip specific checks and `--add` to append custom checks. Generated CI workflows now use `pnpm check`, and the package.json generator produces `check` and `tooling:check` scripts pointing to this command. Managed scripts (`check`, `tooling:check`) are updated on `repo:update`/`repo:check` if they don't already reference the expected command.
-
-## 0.11.0
-
-### Minor Changes
-
-- 493ae65: Add `repo:run-checks` command that runs all standard checks (build, typecheck, lint, test, format, knip, repo:check) without short-circuiting, reporting a summary of failures at the end. Generated CI workflows and package.json `check` scripts now use this command. Skip `trigger-release` script for changesets release strategy.
-
-### Patch Changes
-
-- ae18571: Add .pnpm-store to gitignore file
-- 916c1ee: Ensure `yaml-language-server` schema comment is added to existing Forgejo workflow files during update/merge
-
-## 0.10.1
-
-### Patch Changes
-
-- f131a3d: Add `pnpm why` to the allowed Bash commands in generated Claude settings
-- 1cb2ce8: Add yaml-language-server schema comments to generated Forgejo workflow files and update schema glob to match both .yml and .yaml extensions
-
-## 0.10.0
-
-### Minor Changes
-
-- 34a0e1e: feat: merge missing config into existing lefthook and CI workflow files instead of skipping
-
-  Generators for `lefthook.yml`, CI check workflows, and release workflows now merge required
-  entries into existing files rather than silently skipping them. This means `repo:update` can
-  add new steps (e.g. a newly required CI check) to repos that were initialized before the step
-  existed.
-
-  Add `# @bensandee/tooling:ignore` in the first 10 lines of any YAML file to opt out of
-  automatic merging.
-
-### Patch Changes
-
-- 330cc2c: fix: use semantic JSON comparison in repo:check and repo:update to ignore formatting-only differences
-
-## 0.9.0
-
-### Minor Changes
-
-- 88f2a93: Require `.tooling.json` for `repo:update` and `repo:check` commands. Previously these commands would warn and continue with detected defaults when `.tooling.json` was missing, which could cause unexpected overwrites without proper archiving. Now they exit with an error directing the user to run `tooling repo:init` first.
-
-  Write Forgejo workflow schema mapping to `.code-workspace` file when present, falling back to `.vscode/settings.json`. The `yaml.schemas` setting in `.vscode/settings.json` doesn't apply in VS Code multi-root workspaces.
-
-  Improve post-init guidance: suggest a Claude Code prompt ("Execute the steps in .tooling-migrate.md") instead of "paste contents".
-
-## 0.8.1
-
-### Patch Changes
-
-- efcfdcc: Fix findOpenPr to filter PRs client-side by head.ref instead of relying on Forgejo's inconsistent head query parameter, which could match the wrong PR
-- 88aac23: Add forgejo workflow schema additions
-- e4c41d6: Fix wrong agent name in settings.json for claude
-- 43509b8: Pin @bensandee/\* package versions in generated package.json instead of using "latest". Versions are read from sibling package.json files at build time via tsdown's define feature, so they auto-update with each release.
-- 5e65e50: enhance ciWorkflow to support Forgejo email notifications
-- 60a5502: refactor generateClaudeSettings to handle monorepo structure and update tests for plugin integration
-
-## 0.8.0
-
-### Minor Changes
-
-- 375f7fd: Add claude skills to settings.json
-
-### Patch Changes
-
-- 375098b: Add more safety restrictions to settings.json
-- b330adf: Fix bad update to tsconfig when not needed
-
-## 0.7.3
-
-### Patch Changes
-
-- 3257e04: Fix no-unsafe-json-parse rule and fix new lint errors
-- ca61fa7: Don't overwrite existing oxfmt config
-- 1bdf858: More intelligent addition of src folder to tsconfig
-- 8de49b9: Add line about adding packages when necessary to resolve errors
-
-## 0.7.2
-
-### Patch Changes
-
-- e48bc27: Fix bug where tsconfigs in packages would be force-updated even if solutions-style
-
-## 0.7.1
-
-### Patch Changes
-
-- 6ef4ea9: Fix tsconfig build/update issues
-- 3608a1a: Run pnpm update after repo:update
-
-## 0.7.0
-
-### Minor Changes
-
-- 912013d: Add repo:check command
-- 2545262: Add common package + error subclasses
-
-### Patch Changes
-
-- Updated dependencies [2545262]
-  - @bensandee/common@0.1.0
-
-## 0.6.2
-
-### Patch Changes
-
-- caa1270: Fix hang migrating repo:init
-
-## 0.6.1
-
-### Patch Changes
-
-- 2182ab3: fix bug where renovate.json5 wasn't cleaned up to use our preset
-- d811a96: Lefthook doesn't need an install step in package.json prepare
-
-## 0.6.0
-
-### Minor Changes
-
-- 94cd161: Updated default oxlint config to include more default rules.
-
-## 0.5.1
-
-### Patch Changes
-
-- e0bc32e: Improve migration for tsconfig and husky/lint-staged
-- 02c1a1b: Include version when running tooling cli
-
-## 0.5.0
-
-### Minor Changes
-
-- 58fc8a3: Add lefthook support in place of husky, lint-staged
-
-## 0.4.0
-
-### Minor Changes
-
-- e02953a: Bug fixing, move renovate config to standard location
-- 451908d: Restructure package names and exports.
-
-## 0.3.0
-
-### Minor Changes
-
-- 5e9719f: Many bug fixes
-
-## 0.2.0
-
-### Minor Changes
-
-- c376981: Initial release
-
-### Patch Changes
-
-- 3fc9fe3: Support multiple release architectures (release-it, commit-and-tag-version and changsets)
-- 4004530: Add release-forgejo command to perform final steps of release creation in forgejo.

package/dist/exec-CC49vrkM.mjs

@@ -1,7 +0,0 @@
-//#region src/utils/exec.ts
-/** Type guard for `execSync` errors that carry stdout/stderr/status. */
-function isExecSyncError(err) {
-	return err instanceof Error && "stdout" in err && typeof err.stdout === "string" && "stderr" in err && typeof err.stderr === "string" && "status" in err && typeof err.status === "number";
-}
-//#endregion
-export { isExecSyncError as t };