@zitadel/cli 0.1.0-alpha.9 → 0.2.0

package/dist/commands/doctor.mjs

@@ -1,569 +0,0 @@
-import { C as isObject, E as ZitadelError, a as DEFAULT_LOCAL_SERVER_PORT, b as publicCliCommand, c as checkLocalServerHealth, l as defaultLocalServerImageForCliVersion, m as readRuntimeMetadata, p as localServerUrl, s as assertLocalStateWritable, t as BaseCommand } from "../oclif-B7lBzh3R.mjs";
-import { i as issuerFromPort, t as createOrca } from "../orca-U142Wrau.mjs";
-import { a as readZitadelConfig, i as readRendererId, o as readZitadelSecret, r as readDevelopmentIssuer, t as hasZitadelConfig } from "../project-Cd0L3PtM.mjs";
-import { n as listenersForPort } from "../ports-B09RjuHx.mjs";
-import { d as assertServerPackageAvailable, o as imageAvailable, r as dockerAvailable } from "../docker-CnGQK3ZK.mjs";
-import { n as dockerUnavailableMessage, t as dockerRuntimeGuidance } from "../docker-guidance-ypN3IM3o.mjs";
-import { t as discoverManagedRuntimeProcesses } from "../processes-Cw8TO1SY.mjs";
-import { Flags } from "@oclif/core";
-import consola from "consola";
-import { join } from "node:path";
-import { chmod, readFile, stat, writeFile } from "node:fs/promises";
-import "@zitadel/api/generated/endpoints/zitadelNextGen.zod";
-//#region src/commands/doctor/checks/types.ts
-/**
-* Base class for checks: subclasses declare `name`, `path`, and a success
-* `summary`, and implement the single {@link verify} method that throws on
-* failure. {@link run} wraps it so a thrown error becomes a `fail` outcome
-* carrying the error message, and success becomes a `pass` with `summary`.
-*
-* {@link fix} defaults to a no-op: checks whose failure has no safe automatic
-* remedy (a missing secret, an invalid user schema) simply do not override it.
-*/
-var AbstractSanityCheck = class {
-	async run(ctx) {
-		try {
-			await this.verify(ctx);
-			return {
-				name: this.name,
-				status: "pass",
-				message: this.summary,
-				path: this.path
-			};
-		} catch (error) {
-			return {
-				name: this.name,
-				status: "fail",
-				message: error instanceof Error ? error.message : String(error),
-				path: this.path
-			};
-		}
-	}
-	async fix(_ctx) {}
-};
-//#endregion
-//#region src/commands/doctor/checks/config.ts
-/** Verifies `zitadel.json` exists and parses. */
-var ConfigCheck = class extends AbstractSanityCheck {
-	name = "config";
-	path = "zitadel.json";
-	summary = "zitadel.json parses";
-	async verify(ctx) {
-		await readZitadelConfig(ctx.cwd);
-	}
-};
-//#endregion
-//#region src/commands/doctor/checks/secret.ts
-/** Verifies `.zitadel/secret` exists and parses. */
-var SecretCheck = class extends AbstractSanityCheck {
-	name = "secret";
-	path = ".zitadel/secret";
-	summary = ".zitadel/secret parses";
-	async verify(ctx) {
-		await readZitadelSecret(ctx.cwd);
-	}
-};
-//#endregion
-//#region src/commands/doctor/checks/secret-permissions.ts
-/** Verifies `.zitadel/secret` is locked down to `0600`, and re-locks it on fix. */
-var SecretPermissionsCheck = class extends AbstractSanityCheck {
-	name = "secret-permissions";
-	path = ".zitadel/secret";
-	summary = ".zitadel/secret has 0600 permissions";
-	async verify(ctx) {
-		const mode = (await stat(join(ctx.cwd, ".zitadel/secret"))).mode & 511;
-		if (mode !== 384) throw new Error(`expected 0600, got ${mode.toString(8)}`);
-	}
-	async fix(ctx) {
-		if (ctx.dryRun) return;
-		await chmod(join(ctx.cwd, ".zitadel/secret"), 384);
-	}
-};
-//#endregion
-//#region src/commands/doctor/checks/gitignore.ts
-/** The entries `.gitignore` must carry to keep secrets and env files untracked. */
-const REQUIRED_ENTRIES = [
-	".zitadel/secret",
-	".env*",
-	"!.env.example"
-];
-/** Verifies `.gitignore` excludes the local secret and env files; appends any missing. */
-var GitignoreCheck = class extends AbstractSanityCheck {
-	name = "gitignore";
-	path = ".gitignore";
-	summary = ".gitignore protects local secret/env files";
-	async verify(ctx) {
-		const lines = (await readFile(join(ctx.cwd, ".gitignore"), "utf8")).split(/\r?\n/g);
-		for (const entry of REQUIRED_ENTRIES) if (!lines.includes(entry)) throw new Error(`missing ${entry}`);
-	}
-	async fix(ctx) {
-		const path = join(ctx.cwd, ".gitignore");
-		const existing = await readFile(path, "utf8").catch(() => "");
-		const lines = existing.split(/\r?\n/g);
-		const missing = REQUIRED_ENTRIES.filter((entry) => !lines.includes(entry));
-		if (missing.length === 0 || ctx.dryRun) return;
-		await writeFile(path, `${existing}${existing.length > 0 && !existing.endsWith("\n") ? "\n" : ""}${missing.join("\n")}\n`);
-	}
-};
-//#endregion
-//#region src/commands/doctor/checks/env-example.ts
-/** The keys `.env.example` must document for a Zitadel-managed project. */
-const REQUIRED_KEYS = [
-	"ZITADEL_PROJECT_ID",
-	"ZITADEL_ENVIRONMENT",
-	"ZITADEL_ISSUER"
-];
-/** Verifies `.env.example` documents the required Zitadel keys; appends any missing. */
-var EnvExampleCheck = class extends AbstractSanityCheck {
-	name = "env-example";
-	path = ".env.example";
-	summary = ".env.example references required keys";
-	async verify(ctx) {
-		const contents = await readFile(join(ctx.cwd, ".env.example"), "utf8");
-		for (const key of REQUIRED_KEYS) if (!contents.includes(`${key}=`)) throw new Error(`missing ${key}`);
-	}
-	async fix(ctx) {
-		const path = join(ctx.cwd, ".env.example");
-		const existing = await readFile(path, "utf8").catch(() => "");
-		const missing = REQUIRED_KEYS.filter((key) => !existing.includes(`${key}=`));
-		if (missing.length === 0 || ctx.dryRun) return;
-		await writeFile(path, `${existing}${existing.length > 0 && !existing.endsWith("\n") ? "\n" : ""}${missing.map((key) => `${key}=`).join("\n")}\n`);
-	}
-};
-//#endregion
-//#region src/commands/doctor/checks/framework.ts
-/** Verifies the framework detected on disk matches the one recorded in config. */
-var FrameworkCheck = class extends AbstractSanityCheck {
-	name = "framework";
-	path = "zitadel.json";
-	summary = "Detected framework matches recorded framework";
-	async verify(ctx) {
-		const config = await readZitadelConfig(ctx.cwd);
-		const detected = await ctx.orca.detect(ctx.cwd);
-		const recorded = isObject(config.framework) ? config.framework.id : void 0;
-		if (recorded !== detected.id) throw new Error(`expected ${String(recorded)}, detected ${detected.id}`);
-	}
-};
-//#endregion
-//#region src/commands/doctor/patch-context.ts
-/**
-* Reconstructs a {@link PatchContext} from the on-disk project (config, secret)
-* plus fresh framework detection, so a patcher repair can rebuild its plan.
-* Used by the dependency check's `fix`, which reclaims the framework-specific
-* SDK package via `patcher.repair`. The user schema and flow definition are
-* server-owned and no longer scaffolded locally, so nothing here reads them.
-*/
-async function loadPatchContext(cwd, orca, cliVersion) {
-	const config = await readZitadelConfig(cwd);
-	const secret = await readZitadelSecret(cwd);
-	const framework = await orca.detect(cwd);
-	return {
-		framework,
-		rendererId: readRendererId(config),
-		issuer: await resolveIssuer(cwd, config, framework),
-		server: typeof config.server === "string" ? config.server : "",
-		cliVersion,
-		project: {
-			id: secret.project_id,
-			projectSecret: secret.project_secret,
-			previewSecret: secret.preview_secret,
-			previewOrigins: secret.preview_origins,
-			createdAt: secret.created_at
-		}
-	};
-}
-async function resolveIssuer(cwd, config, facts) {
-	const fromConfig = readDevelopmentIssuer(config);
-	if (fromConfig && fromConfig.length > 0) return fromConfig;
-	const state = await readState(cwd);
-	if (typeof state?.dev_port === "number") return issuerFromPort(state.dev_port);
-	return facts.url;
-}
-async function readState(cwd) {
-	try {
-		const contents = await readFile(join(cwd, ".zitadel/state.json"), "utf8");
-		return JSON.parse(contents);
-	} catch {
-		return;
-	}
-}
-//#endregion
-//#region src/commands/doctor/checks/dependency.ts
-/**
-* Verifies the project still declares a Zitadel SDK dependency in
-* `package.json`. The patcher adds a scoped package (e.g.
-* `@zitadel/sdk-next`); the check is generic over the `@zitadel*`
-* scope so any framework renderer's dependency satisfies it.
-*/
-var DependencyCheck = class extends AbstractSanityCheck {
-	name = "dependency";
-	path = "package.json";
-	summary = "package.json depends on a Zitadel SDK package";
-	async verify(ctx) {
-		const pkg = JSON.parse(await readFile(join(ctx.cwd, "package.json"), "utf8"));
-		if (![...Object.keys(pkg.dependencies ?? {}), ...Object.keys(pkg.devDependencies ?? {})].some((name) => name.startsWith("@zitadel"))) throw new Error("no @zitadel* dependency found in package.json");
-	}
-	/**
-	* Repairs by reclaiming the patcher's managed artifacts: rebuilds the
-	* `PatchContext` from disk and calls `patcher.repair`, which re-adds the
-	* SDK dependency via its `add-dep` op. The exact package name is framework
-	* + renderer specific and known only to the patcher (which deliberately
-	* hides its file-op plan behind the family-neutral `Patcher` interface),
-	* so going through `repair` is the only sanctioned path.
-	*/
-	async fix(ctx) {
-		const patchCtx = await loadPatchContext(ctx.cwd, ctx.orca, ctx.cliVersion);
-		await ctx.orca.patcherFor(patchCtx.framework.id).repair(patchCtx, {
-			cwd: ctx.cwd,
-			dryRun: ctx.dryRun,
-			force: true
-		});
-	}
-};
-//#endregion
-//#region src/commands/doctor/checks/project-match.ts
-/** Verifies `.zitadel/secret`'s project_id matches `zitadel.json`'s project. */
-var ProjectMatchCheck = class extends AbstractSanityCheck {
-	name = "project-match";
-	path = ".zitadel/secret";
-	summary = ".zitadel/secret project_id matches zitadel.json project";
-	async verify(ctx) {
-		const config = await readZitadelConfig(ctx.cwd);
-		const secret = await readZitadelSecret(ctx.cwd);
-		const configProject = typeof config.project === "string" ? config.project : void 0;
-		if (secret.project_id !== configProject) throw new Error(".zitadel/secret project_id does not match zitadel.json project");
-	}
-};
-//#endregion
-//#region src/commands/doctor/checks/index.ts
-/** Every diagnostic the `doctor` command runs, in display order. */
-const SANITY_CHECKS = [
-	new ConfigCheck(),
-	new SecretCheck(),
-	new SecretPermissionsCheck(),
-	new GitignoreCheck(),
-	new EnvExampleCheck(),
-	new FrameworkCheck(),
-	new DependencyCheck(),
-	new ProjectMatchCheck()
-];
-//#endregion
-//#region src/commands/doctor/index.ts
-const LOCAL_RUNTIME_CHECK_NAMES = new Set([
-	"server-binary",
-	"docker-cli",
-	"image",
-	"state-dir",
-	"port",
-	"runtime"
-]);
-/**
-* `zitadel doctor` — verify generated files and local state.
-*
-* Runs every registered {@link SANITY_CHECKS} entry and emits the aggregate
-* result; if any check fails it throws `E_VALIDATION` carrying the full check
-* details. With `--fix`, each failing check first attempts its own repair (a
-* no-op for checks with no safe automatic remedy), then the battery re-runs.
-*
-* The `--fix` loop is best-effort: a repair that throws (e.g. a missing
-* prerequisite file the check itself would also flag) is logged at debug
-* level and skipped, not propagated — the post-fix re-verify still reports
-* whatever remains broken.
-*/
-var Doctor = class Doctor extends BaseCommand {
-	static description = "Verify local runtime and project state.";
-	static flags = {
-		fix: Flags.boolean({ description: "Re-apply missing managed files." }),
-		image: Flags.string({ description: "Container image to check." }),
-		port: Flags.integer({
-			description: "Local HTTP port.",
-			default: DEFAULT_LOCAL_SERVER_PORT
-		}),
-		runtime: Flags.string({
-			description: "Local runtime backend.",
-			options: ["binary", "docker"]
-		})
-	};
-	async run() {
-		const { flags } = await this.parse(Doctor);
-		const port = flags.port ?? 8080;
-		await this.toMeta(flags, {
-			resolveServer: false,
-			source: localServerUrl(port)
-		});
-		const { cwd, dryRun } = this.meta;
-		const existingRuntime = await readRuntimeMetadata(cwd);
-		const runtimeBackend = resolveRuntimeBackend({
-			runtime: flags.runtime,
-			image: flags.image,
-			envImage: this.meta.env.ZITADEL_LOCAL_IMAGE,
-			existingRuntime
-		});
-		const image = flags.image ?? this.meta.env.ZITADEL_LOCAL_IMAGE ?? defaultLocalServerImageForCliVersion(this.meta.cliVersion);
-		const runtimeChecks = await runLocalRuntimeChecks(cwd, runtimeBackend, image, port);
-		const hasConfig = await hasZitadelConfig(cwd);
-		const ctx = {
-			cwd,
-			orca: createOrca(),
-			cliVersion: this.meta.cliVersion,
-			dryRun
-		};
-		if (hasConfig && flags.fix) {
-			const before = await Promise.all(SANITY_CHECKS.map((check) => check.run(ctx)));
-			for (const [index, check] of SANITY_CHECKS.entries()) {
-				if (before[index]?.status !== "fail") continue;
-				try {
-					await check.fix(ctx);
-				} catch (error) {
-					consola.debug(`doctor --fix: ${check.name} repair failed`, error);
-				}
-			}
-		}
-		const projectChecks = hasConfig ? await Promise.all(SANITY_CHECKS.map((check) => check.run(ctx))) : [];
-		const checks = [...runtimeChecks, ...projectChecks];
-		const failed = checks.filter((check) => check.status === "fail");
-		const warnings = checks.filter((check) => check.status === "warn");
-		const warningAdvice = advisoryForWarnings(warnings, this.meta.cliVersion);
-		const data = {
-			title: failed.length > 0 ? "Zitadel doctor found issues." : warnings.length > 0 ? "Zitadel doctor passed with warnings." : "Zitadel doctor passed.",
-			ok: failed.length === 0,
-			runtime: runtimeBackend,
-			...runtimeBackend === "docker" ? { image } : {},
-			port,
-			project: { lifecycle: hasConfig ? "configured" : "not-configured" },
-			checks,
-			...warningAdvice ? {
-				next_actions: warningAdvice.nextActions,
-				next_commands: warningAdvice.nextCommands
-			} : {}
-		};
-		if (failed.length > 0) {
-			const advice = failureAdvice(failed, image, port, this.meta.cliVersion);
-			throw new ZitadelError(failed.some((check) => check.name === "port") ? "E_PORT_IN_USE" : "E_VALIDATION", "Zitadel doctor found issues", {
-				hint: advice.hint,
-				nextCommands: advice.nextCommands,
-				details: data
-			});
-		}
-		return this.emit({
-			status: "ok",
-			data,
-			warnings: warnings.map((warning) => `${warning.name}: ${warning.message}`)
-		});
-	}
-};
-function failureAdvice(failed, image, port, cliVersion) {
-	const failedNames = new Set(failed.map((check) => check.name));
-	if (failedNames.has("server-binary")) return {
-		hint: "The Zitadel server npm package is not available. Reinstall the CLI package, then retry.",
-		nextCommands: [publicCliCommand("doctor", cliVersion)]
-	};
-	if (failedNames.has("docker-cli")) {
-		const advice = dockerRuntimeGuidance("doctor", cliVersion);
-		return {
-			hint: advice.hint,
-			nextCommands: advice.nextCommands
-		};
-	}
-	if (failedNames.has("image")) return {
-		hint: "The local Zitadel image is not available. Check Docker registry access, build it locally, or pass --image / ZITADEL_LOCAL_IMAGE.",
-		nextCommands: [`docker pull ${image}`, publicCliCommand("doctor", cliVersion)]
-	};
-	if (failedNames.has("state-dir")) return {
-		hint: "The local Zitadel state directory is not writable. Fix directory permissions, then rerun `zitadel doctor`.",
-		nextCommands: [publicCliCommand("doctor", cliVersion)]
-	};
-	if (failedNames.has("port")) {
-		const fallbackPort = port === 8080 ? port + 1 : DEFAULT_LOCAL_SERVER_PORT;
-		return {
-			hint: `Port ${String(port)} is already in use. Stop the process using it, or choose another port for local Zitadel.`,
-			nextCommands: [publicCliCommand(`doctor --port ${String(fallbackPort)}`, cliVersion)]
-		};
-	}
-	if (failedNames.has("runtime")) return {
-		hint: "Existing local runtime metadata was found, but the local Zitadel server is not healthy. Start it again or reset stale local data.",
-		nextCommands: [publicCliCommand("start", cliVersion), publicCliCommand("reset --force", cliVersion)]
-	};
-	if (failed.some((check) => !LOCAL_RUNTIME_CHECK_NAMES.has(check.name))) return {
-		hint: `Run \`${publicCliCommand("doctor --fix", cliVersion)}\` to re-apply missing managed files.`,
-		nextCommands: [publicCliCommand("doctor --fix", cliVersion)]
-	};
-	return {
-		hint: "Fix the reported checks, then rerun `zitadel doctor`.",
-		nextCommands: [publicCliCommand("doctor", cliVersion)]
-	};
-}
-function advisoryForWarnings(warnings, cliVersion) {
-	const nextActions = [];
-	const nextCommands = [];
-	if (warnings.some((check) => check.name === "docker-cli")) {
-		const advice = dockerRuntimeGuidance("doctor", cliVersion);
-		nextActions.push(...advice.nextActions);
-		nextCommands.push(...advice.nextCommands);
-	}
-	if (hasManagedRuntimeProcesses(warnings.find((check) => check.name === "managed-runtime-processes"))) {
-		nextActions.push("Review other host-wide CLI-managed local Zitadel runtimes before starting a new one.");
-		nextCommands.push(publicCliCommand("stop --all", cliVersion));
-	}
-	if (nextActions.length === 0 && nextCommands.length === 0) return;
-	return {
-		nextActions: unique(nextActions),
-		nextCommands: unique(nextCommands)
-	};
-}
-async function runLocalRuntimeChecks(cwd, runtimeBackend, image, port) {
-	const runtime = await readRuntimeMetadata(cwd);
-	const managedRuntimeCheck = await checkManagedRuntimeProcesses(runtime);
-	if (runtimeBackend === "binary") return [
-		await check("server-binary", "Server npm package is available", async () => {
-			return `@zitadel/server ${await assertServerPackageAvailable()} is available`;
-		}),
-		await check("state-dir", "Local state directory is writable", async () => {
-			const probe = await assertLocalStateWritable(cwd);
-			return probe.checkedPath === probe.targetPath ? `${probe.targetPath} is writable` : `${probe.targetPath} can be created (${probe.checkedPath} is writable)`;
-		}, "warn"),
-		await check("port", `Port ${String(port)} is available`, () => checkPortAvailability(runtime, port)),
-		await checkRuntime(runtime, runtimeBackend),
-		managedRuntimeCheck
-	];
-	const docker = await check("docker-cli", "Docker is reachable", async () => {
-		let result;
-		try {
-			result = await dockerAvailable();
-		} catch (error) {
-			throw new Error(dockerUnavailableMessage(error), { cause: error });
-		}
-		if (result.status !== 0) throw new Error(dockerUnavailableMessage(result.stderr || "docker version failed"));
-		return `Docker engine ${result.stdout.trim() || "available"}`;
-	}, "warn");
-	return [
-		docker,
-		docker.status === "pass" ? await check("image", `Image ${image} is available`, async () => {
-			try {
-				return await imageAvailable(image) === "local" ? `Image ${image} is available locally` : `Image ${image} is available from the registry`;
-			} catch (error) {
-				throw new Error(imageUnavailableMessage(image, error), { cause: error });
-			}
-		}, "warn") : {
-			name: "image",
-			status: "warn",
-			message: "Skipped image check because Docker is not reachable."
-		},
-		await check("state-dir", "Local state directory is writable", async () => {
-			const probe = await assertLocalStateWritable(cwd);
-			return probe.checkedPath === probe.targetPath ? `${probe.targetPath} is writable` : `${probe.targetPath} can be created (${probe.checkedPath} is writable)`;
-		}, "warn"),
-		await check("port", `Port ${String(port)} is available`, () => checkPortAvailability(runtime, port)),
-		await checkRuntime(runtime, runtimeBackend),
-		managedRuntimeCheck
-	];
-}
-async function checkPortAvailability(runtime, port) {
-	if (runtime?.port === port && await checkLocalServerHealth(runtime.server_url)) return `${runtime.server_url} is already healthy`;
-	const listeners = await listenersForPort(port);
-	if (listeners.length > 0) throw new PortInUseCheckError(port, localServerUrl(port), listeners);
-	return `Port ${String(port)} is available`;
-}
-var PortInUseCheckError = class extends Error {
-	constructor(port, serverUrl, listeners) {
-		super(`Port ${String(port)} is already in use by ${formatListeners(listeners)}`);
-		this.port = port;
-		this.serverUrl = serverUrl;
-		this.listeners = listeners;
-	}
-};
-async function checkManagedRuntimeProcesses(runtime) {
-	const discovery = await discoverManagedRuntimeProcesses();
-	if (!discovery.supported) return {
-		name: "managed-runtime-processes",
-		status: "warn",
-		message: "Managed local runtime process discovery is unavailable.",
-		details: {
-			supported: false,
-			error: discovery.error
-		}
-	};
-	const processes = additionalManagedRuntimeProcesses(discovery.processes, runtime);
-	if (processes.length === 0) return {
-		name: "managed-runtime-processes",
-		status: "pass",
-		message: "No additional host-wide managed local runtime processes found.",
-		details: {
-			supported: true,
-			scope: "host",
-			processes: []
-		}
-	};
-	return {
-		name: "managed-runtime-processes",
-		status: "warn",
-		message: `${String(processes.length)} other host-wide managed local runtime process${processes.length === 1 ? "" : "es"} found.`,
-		details: {
-			supported: true,
-			scope: "host",
-			processes
-		}
-	};
-}
-function additionalManagedRuntimeProcesses(processes, runtime) {
-	if (runtime?.backend !== "binary") return processes;
-	return processes.filter((processInfo) => processInfo.pid !== runtime.pid && processInfo.ppid !== runtime.pid);
-}
-async function checkRuntime(runtime, runtimeBackend) {
-	return check("runtime", "Existing local runtime is healthy", async () => {
-		if (!runtime) return "No existing runtime metadata";
-		if (runtime.backend !== runtimeBackend) throw new Error(`Existing local runtime uses ${runtime.backend}; run start --runtime ${runtimeBackend} to switch backends.`);
-		if (!await checkLocalServerHealth(runtime.server_url)) throw new Error(`${runtime.server_url} did not respond to /healthz`);
-		return `${runtime.server_url} is healthy`;
-	});
-}
-function formatListeners(listeners) {
-	return listeners.map((listener) => [listener.command ?? "unknown", listener.pid ? `pid ${String(listener.pid)}` : void 0].filter(Boolean).join(" ")).join(", ");
-}
-function hasManagedRuntimeProcesses(check) {
-	if (!check || check.status !== "warn") return false;
-	const details = check.details;
-	return typeof details === "object" && details !== null && "supported" in details && details.supported === true && Array.isArray(details.processes) && (details.processes?.length ?? 0) > 0;
-}
-function unique(values) {
-	return [...new Set(values)];
-}
-function resolveRuntimeBackend(input) {
-	if (input.runtime === "binary" || input.runtime === "docker") return input.runtime;
-	if (input.existingRuntime) return input.existingRuntime.backend;
-	if (input.image || input.envImage) return "docker";
-	return "binary";
-}
-async function check(name, fallback, run, failureStatus = "fail") {
-	try {
-		return {
-			name,
-			status: "pass",
-			message: await run()
-		};
-	} catch (error) {
-		if (error instanceof PortInUseCheckError) return {
-			name,
-			status: failureStatus,
-			message: error.message,
-			details: {
-				port: error.port,
-				server_url: error.serverUrl,
-				listeners: error.listeners
-			}
-		};
-		return {
-			name,
-			status: failureStatus,
-			message: error instanceof Error ? error.message : fallback
-		};
-	}
-}
-function imageUnavailableMessage(image, error) {
-	const detail = error instanceof Error ? error.message : String(error);
-	return `Image ${image} is not available to Docker${detail.trim() ? ` (${detail.trim()})` : ""}; \`zitadel start\` may need a pull or a different image.`;
-}
-//#endregion
-export { Doctor as default };
-
-//# sourceMappingURL=doctor.mjs.map