@zitadel/cli 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/{project-C3pSfbao.mjs → oclif-B7lBzh3R.mjs}

@@ -1,9 +1,11 @@
 import { Command, Flags } from "@oclif/core";
 import consola from "consola";
-import { readFile, stat } from "node:fs/promises";
-import { join, resolve } from "node:path";
 import { ApiError } from "@zitadel/api/runtime/fetch";
 import { stringify } from "safe-stable-stringify";
+import { dirname, join, resolve } from "node:path";
+import { access, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
 //#region src/lib/errors.ts
 /**
 * Maps each {@link ZitadelErrorCode} to the process exit code the CLI
@@ -17,6 +19,8 @@ const EXIT_CODES = {
 	E_NETWORK: 4,
 	E_AUTH: 1,
 	E_CONFLICT: 5,
+	E_LOCAL_SERVER_NOT_RUNNING: 4,
+	E_PORT_IN_USE: 5,
 	E_VALIDATION: 3,
 	E_NOT_IMPLEMENTED: 2
 };
@@ -144,6 +148,287 @@ function isObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
+//#region src/lib/paths.ts
+/**
+* Resolve the working directory the CLI should operate against, defaulting to
+* the process CWD when no `--cwd` override is given. Always returns an
+* absolute path so downstream `join`/`readFile` calls are unaffected by later
+* `process.chdir` or relative-path ambiguity.
+*/
+function resolveCwd(cwd) {
+	return resolve(cwd ?? process.cwd());
+}
+/**
+* Sentinel comment stamped at the top of every file the CLI generates and
+* owns. Commands like `doctor` and `eject` look for this marker to decide
+* whether a file is safe to touch; the trailing `v1` lets the format evolve
+* without mistaking newer managed files for hand-edited ones.
+*/
+const MANAGED_MARKER = "// zitadel-cli: managed-file v1";
+//#endregion
+//#region src/lib/public-cli.ts
+const CLI_PACKAGE_NAME = "@zitadel/cli";
+function npmDistTagForCliVersion(cliVersion) {
+	return cliVersion.trim().replace(/^v/, "").match(/^\d+\.\d+\.\d+-([0-9A-Za-z][0-9A-Za-z-]*)/)?.[1] ?? "latest";
+}
+function npmSelectorForCliVersion(cliVersion) {
+	const normalized = cliVersion.trim().replace(/^v/, "");
+	if (/^\d+\.\d+\.\d+-alpha\.\d+$/.test(normalized)) return normalized;
+	return npmDistTagForCliVersion(normalized);
+}
+function publicCliCommand(args, cliVersion) {
+	const prefix = `npx ${CLI_PACKAGE_NAME}@${npmSelectorForCliVersion(cliVersion)}`;
+	return args.length > 0 ? `${prefix} ${args}` : prefix;
+}
+function normalizePublicCliCommand(command, cliVersion) {
+	if (command === "zitadel") return publicCliCommand("", cliVersion);
+	if (command.startsWith("zitadel ")) return publicCliCommand(command.slice(8), cliVersion);
+	return command;
+}
+function normalizePublicCliCommands(commands, cliVersion) {
+	return commands?.map((command) => normalizePublicCliCommand(command, cliVersion));
+}
+//#endregion
+//#region src/lib/local-server/runtime.ts
+const LOCAL_SERVER_IMAGE_NAME = "ghcr.io/zitadel/nextgen";
+const DEFAULT_LOCAL_SERVER_IMAGE = `${LOCAL_SERVER_IMAGE_NAME}:latest`;
+const DEFAULT_LOCAL_SERVER_PORT = 8080;
+const DEFAULT_LOCAL_SERVER_URL = "http://localhost:8080";
+const LOCAL_RUNTIME_DIR = ".zitadel/local";
+const LOCAL_DATA_DIR = ".zitadel/local/nextgen-data";
+const LOCAL_RUNTIME_FILE = ".zitadel/local/runtime.json";
+const LOCAL_SERVER_LOG_FILE = ".zitadel/local/server.log";
+const LOCAL_CONTAINER_PASSWD_FILE = ".zitadel/local/container-passwd";
+const LOCAL_CONTAINER_GROUP_FILE = ".zitadel/local/container-group";
+const CONTAINER_DATA_DIR = "/var/lib/zitadel/nextgen-data";
+const CONTAINER_HTTP_PORT = 8080;
+function localRuntimePaths(cwd) {
+	return {
+		runtimeDir: join(cwd, LOCAL_RUNTIME_DIR),
+		dataDir: join(cwd, LOCAL_DATA_DIR),
+		runtimeFile: join(cwd, LOCAL_RUNTIME_FILE),
+		logFile: join(cwd, LOCAL_SERVER_LOG_FILE),
+		containerPasswdFile: join(cwd, LOCAL_CONTAINER_PASSWD_FILE),
+		containerGroupFile: join(cwd, LOCAL_CONTAINER_GROUP_FILE)
+	};
+}
+function localContainerName(cwd) {
+	return `zitadel-server-${createHash("sha256").update(resolve(cwd)).digest("hex").slice(0, 12)}`;
+}
+function localServerUrl(port) {
+	return `http://localhost:${port}`;
+}
+function defaultLocalServerImageForCliVersion(cliVersion) {
+	const normalized = cliVersion.trim().replace(/^v/, "");
+	if (/^\d+\.\d+\.\d+-alpha\.\d+$/.test(normalized)) return `${LOCAL_SERVER_IMAGE_NAME}:${normalized}`;
+	return DEFAULT_LOCAL_SERVER_IMAGE;
+}
+async function ensureLocalState(cwd) {
+	const paths = localRuntimePaths(cwd);
+	await mkdir(paths.dataDir, {
+		recursive: true,
+		mode: 448
+	});
+	await appendGitignoreEntry(cwd, `${LOCAL_RUNTIME_DIR}/`);
+	return paths;
+}
+async function assertLocalStateWritable(cwd) {
+	const paths = localRuntimePaths(cwd);
+	const checkedPath = await nearestExistingDirectory(paths.dataDir);
+	await access(checkedPath, constants.W_OK);
+	return {
+		targetPath: paths.dataDir,
+		checkedPath
+	};
+}
+async function ensureContainerIdentity(cwd, user) {
+	if (user.uid === void 0 || user.uid <= 0) return;
+	const gid = user.gid ?? user.uid;
+	const paths = localRuntimePaths(cwd);
+	await mkdir(paths.runtimeDir, {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(paths.containerPasswdFile, [
+		"root:x:0:0:root:/root:/bin/sh",
+		"nonroot:x:65532:65532:nonroot:/nonexistent:/usr/sbin/nologin",
+		`zitadel-local:x:${String(user.uid)}:${String(gid)}:Zitadel local user:/tmp:/usr/sbin/nologin`,
+		""
+	].join("\n"), { mode: 420 });
+	await writeFile(paths.containerGroupFile, [
+		"root:x:0:",
+		"nonroot:x:65532:",
+		`zitadel-local:x:${String(gid)}:`,
+		""
+	].join("\n"), { mode: 420 });
+	return {
+		uid: user.uid,
+		gid,
+		passwdFile: paths.containerPasswdFile,
+		groupFile: paths.containerGroupFile
+	};
+}
+async function readRuntimeMetadata(cwd) {
+	const paths = localRuntimePaths(cwd);
+	let raw;
+	try {
+		raw = await readFile(paths.runtimeFile, "utf8");
+	} catch (error) {
+		if (isErrno(error, "ENOENT")) return;
+		throw error;
+	}
+	return normalizeRuntimeMetadata(parseJsonObject(raw, LOCAL_RUNTIME_FILE));
+}
+async function writeRuntimeMetadata(cwd, metadata) {
+	const paths = localRuntimePaths(cwd);
+	await mkdir(paths.runtimeDir, {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(paths.runtimeFile, `${JSON.stringify(metadata, null, 2)}\n`, { mode: 384 });
+}
+async function removeRuntimeMetadata(cwd) {
+	await rm(localRuntimePaths(cwd).runtimeFile, { force: true });
+}
+async function removeLocalData(cwd) {
+	await rm(localRuntimePaths(cwd).dataDir, {
+		recursive: true,
+		force: true
+	});
+}
+async function checkLocalServerHealth(serverUrl, timeoutMs = 1500) {
+	try {
+		const healthUrl = new URL("/healthz", serverUrl);
+		return (await fetch(healthUrl, { signal: AbortSignal.timeout(timeoutMs) })).ok;
+	} catch {
+		return false;
+	}
+}
+async function resolveLocalServer(cwd) {
+	const runtime = await readRuntimeMetadata(cwd);
+	if (runtime) {
+		if (await checkLocalServerHealth(runtime.server_url)) return runtime.server_url;
+		throw localServerNotRunning(runtime.server_url);
+	}
+	if (await checkLocalServerHealth("http://localhost:8080")) return DEFAULT_LOCAL_SERVER_URL;
+	throw localServerNotRunning(DEFAULT_LOCAL_SERVER_URL);
+}
+function localServerNotRunning(serverUrl) {
+	return new ZitadelError("E_LOCAL_SERVER_NOT_RUNNING", "Local Zitadel server is not running", {
+		hint: `No healthy local server responded at ${serverUrl}.`,
+		nextCommands: ["zitadel start"],
+		details: { server_url: serverUrl }
+	});
+}
+async function appendGitignoreEntry(cwd, entry) {
+	const path = join(cwd, ".gitignore");
+	let existing = "";
+	try {
+		existing = await readFile(path, "utf8");
+	} catch (error) {
+		if (!isErrno(error, "ENOENT")) throw error;
+	}
+	if (existing.split(/\r?\n/).map((line) => line.trim()).includes(entry)) return;
+	const prefix = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
+	await writeFile(path, `${existing}${prefix}${entry}\n`);
+}
+function normalizeRuntimeMetadata(input) {
+	if (input.schema_version !== 1 || typeof input.port !== "number" || !isValidPort(input.port) || typeof input.server_url !== "string" || !isValidServerUrl(input.server_url, input.port) || typeof input.data_dir !== "string" || typeof input.created_at !== "string" || typeof input.cli_version !== "string") throw malformedRuntime(input);
+	const backend = input.backend === void 0 ? "docker" : input.backend;
+	const base = {
+		schema_version: 1,
+		port: input.port,
+		server_url: input.server_url,
+		data_dir: input.data_dir,
+		created_at: input.created_at,
+		cli_version: input.cli_version
+	};
+	if (backend === "binary") {
+		if (typeof input.pid !== "number" || !Number.isInteger(input.pid) || input.pid <= 0 || typeof input.command !== "string" || typeof input.log_path !== "string" || typeof input.server_package !== "string" || typeof input.server_version !== "string") throw malformedRuntime(input);
+		return {
+			...base,
+			backend: "binary",
+			pid: input.pid,
+			command: input.command,
+			log_path: input.log_path,
+			server_package: input.server_package,
+			server_version: input.server_version
+		};
+	}
+	if (backend !== "docker" || typeof input.container_name !== "string" || typeof input.container_id !== "string" || typeof input.image !== "string") throw malformedRuntime(input);
+	return {
+		...base,
+		backend: "docker",
+		container_name: input.container_name,
+		container_id: input.container_id,
+		image: input.image
+	};
+}
+async function nearestExistingDirectory(path) {
+	let current = path;
+	while (true) try {
+		if (!(await stat(current)).isDirectory()) throw new Error(`${current} exists but is not a directory`);
+		return current;
+	} catch (error) {
+		if (!isErrno(error, "ENOENT")) throw error;
+		const parent = dirname(current);
+		if (parent === current) throw error;
+		current = parent;
+	}
+}
+function isErrno(error, code) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function runtimeSummary(metadata) {
+	if (!metadata) return { configured: false };
+	const base = {
+		configured: true,
+		backend: metadata.backend,
+		port: metadata.port,
+		server_url: metadata.server_url,
+		data_dir: metadata.data_dir,
+		created_at: metadata.created_at
+	};
+	if (metadata.backend === "binary") return {
+		...base,
+		pid: metadata.pid,
+		command: metadata.command,
+		log_path: metadata.log_path,
+		server_package: metadata.server_package,
+		server_version: metadata.server_version
+	};
+	return {
+		...base,
+		container_name: metadata.container_name,
+		container_id: metadata.container_id,
+		image: metadata.image
+	};
+}
+function isValidPort(value) {
+	return Number.isInteger(value) && value >= 1 && value <= 65535;
+}
+function isValidServerUrl(value, port) {
+	try {
+		const url = new URL(value);
+		return (url.protocol === "http:" || url.protocol === "https:") && url.hostname.length > 0 && explicitUrlPort(value) === port;
+	} catch {
+		return false;
+	}
+}
+function explicitUrlPort(value) {
+	const match = value.match(/^[a-z][a-z\d+\-.]*:\/\/(?:\[[^\]]+\]|[^/?#:]+):(\d+)(?:[/?#]|$)/i);
+	if (!match) return;
+	const port = Number(match[1]);
+	return isValidPort(port) ? port : void 0;
+}
+function malformedRuntime(input) {
+	return new ZitadelError("E_VALIDATION", `${LOCAL_RUNTIME_FILE} is malformed`, {
+		hint: "Run `zitadel reset --force`, then `zitadel start`.",
+		nextCommands: ["zitadel reset --force", "zitadel start"],
+		details: input
+	});
+}
+//#endregion
 //#region src/lib/server.ts
 /**
 * Server URL used when nothing else resolves. Also surfaced in hints and
@@ -160,23 +445,23 @@ const DEFAULT_SERVER = "https://api.zitadel.cloud";
 * `ZitadelError` rather than silently falling through.
 */
 async function resolveServer(input) {
-	if (input.serverFlag) return validate({
+	if (input.serverFlag) return validate(input.cwd, {
 		value: input.serverFlag,
 		origin: "flag"
 	});
 	const envValue = input.env.ZITADEL_API_BASE;
-	if (envValue) return validate({
+	if (envValue) return validate(input.cwd, {
 		value: envValue,
 		origin: "env"
 	});
 	const config = await readConfig(input.cwd);
 	if (config) {
 		const envBranch = readEnvServer(config, input.environment);
-		if (envBranch) return validate({
+		if (envBranch) return validate(input.cwd, {
 			value: envBranch,
 			origin: "config-env"
 		});
-		if (typeof config.server === "string") return validate({
+		if (typeof config.server === "string") return validate(input.cwd, {
 			value: config.server,
 			origin: "config-top"
 		});
@@ -186,7 +471,11 @@ async function resolveServer(input) {
 		origin: "default"
 	};
 }
-function validate(resolved) {
+async function validate(cwd, resolved) {
+	if (resolved.value === "local") return {
+		value: await resolveLocalServer(cwd),
+		origin: "local"
+	};
 	try {
 		const url = new URL(resolved.value);
 		if (url.protocol !== "https:" && url.protocol !== "http:") throw new ZitadelError("E_VALIDATION", `Server URL must use http(s): ${resolved.value}`, { hint: `Set "server" in zitadel.json to a URL like ${DEFAULT_SERVER}.` });
@@ -219,24 +508,6 @@ function readEnvServer(config, environment) {
 	return typeof branch.server === "string" ? branch.server : void 0;
 }
 //#endregion
-//#region src/lib/paths.ts
-/**
-* Resolve the working directory the CLI should operate against, defaulting to
-* the process CWD when no `--cwd` override is given. Always returns an
-* absolute path so downstream `join`/`readFile` calls are unaffected by later
-* `process.chdir` or relative-path ambiguity.
-*/
-function resolveCwd(cwd) {
-	return resolve(cwd ?? process.cwd());
-}
-/**
-* Sentinel comment stamped at the top of every file the CLI generates and
-* owns. Commands like `doctor` and `eject` look for this marker to decide
-* whether a file is safe to touch; the trailing `v1` lets the format evolve
-* without mistaking newer managed files for hand-edited ones.
-*/
-const MANAGED_MARKER = "// zitadel-cli: managed-file v1";
-//#endregion
 //#region src/lib/oclif/base.ts
 /**
 * Base class for every oclif command. Owns the global flags, builds the
@@ -281,11 +552,14 @@ var BaseCommand = class extends Command {
 	* `source` by the documented precedence and storing the result on
 	* `this.meta` so the error handler can render a complete envelope.
 	*/
-	async toMeta(flags) {
+	async toMeta(flags, options = {}) {
 		const cwd = resolveCwd(typeof flags.cwd === "string" ? flags.cwd : void 0);
 		const serverFlag = typeof flags.server === "string" ? flags.server : void 0;
 		const environment = typeof flags.environment === "string" ? flags.environment : "development";
-		const source = await resolveServer({
+		const source = options.resolveServer === false ? {
+			value: options.source ?? "",
+			origin: "default"
+		} : await resolveServer({
 			cwd,
 			env: process.env,
 			serverFlag,
@@ -324,8 +598,9 @@ var BaseCommand = class extends Command {
 	* envelope so oclif's `--json` path serialises it.
 	*/
 	emit(result) {
-		this.log(renderPretty(result, this.meta));
-		return toEnvelope(result, this.meta);
+		const normalized = normalizeCommandResult(result, this.meta);
+		this.log(renderPretty(normalized, this.meta));
+		return toEnvelope(normalized, this.meta);
 	}
 	/**
 	* Renders any thrown error as the failure envelope and exits with its code.
@@ -340,7 +615,7 @@ var BaseCommand = class extends Command {
 		};
 		const zitadelError = toZitadelError(error);
 		if (this.jsonEnabled()) this.logJson(toErrorEnvelope(zitadelError, meta));
-		else this.logToStderr(renderError(zitadelError));
+		else this.logToStderr(renderError(zitadelError, meta));
 		return this.exit(zitadelError.exitCode);
 	}
 	/**
@@ -364,6 +639,24 @@ var BaseCommand = class extends Command {
 		};
 	}
 };
+function normalizeCommandResult(result, meta) {
+	if (result.status === "ok") return {
+		...result,
+		data: normalizeDataNextCommands(result.data, meta)
+	};
+	return {
+		...result,
+		data: normalizeDataNextCommands(result.data, meta),
+		nextCommands: normalizePublicCliCommands(result.nextCommands, meta.cliVersion)
+	};
+}
+function normalizeDataNextCommands(data, meta) {
+	if (!isObject(data) || !Array.isArray(data.next_commands)) return data;
+	return {
+		...data,
+		next_commands: data.next_commands.map((command) => typeof command === "string" ? normalizePublicCliCommand(command, meta.cliVersion) : command)
+	};
+}
 /** Wraps a {@link CommandResult} with the invocation metadata into the final envelope. */
 function toEnvelope(result, meta) {
 	const base = {
@@ -395,7 +688,7 @@ function toErrorEnvelope(error, meta) {
 		code: error.code,
 		message: error.message,
 		hint: error.hint,
-		next_commands: error.nextCommands,
+		next_commands: normalizePublicCliCommands(error.nextCommands, meta.cliVersion),
 		details: error.details
 	};
 }
@@ -419,12 +712,13 @@ function renderPretty(result, meta) {
 * Renders a {@link ZitadelError} as a human-readable block for stderr: the
 * coded message, an optional hint, and any suggested next commands.
 */
-function renderError(error) {
+function renderError(error, meta) {
 	const lines = [`Error ${error.code}: ${error.message}`];
 	if (error.hint) lines.push(error.hint);
-	if (error.nextCommands && error.nextCommands.length > 0) {
+	const nextCommands = normalizePublicCliCommands(error.nextCommands, meta.cliVersion);
+	if (nextCommands && nextCommands.length > 0) {
 		lines.push("Next:");
-		for (const cmd of error.nextCommands) lines.push(`  $ ${cmd}`);
+		for (const cmd of nextCommands) lines.push(`  $ ${cmd}`);
 	}
 	return lines.join("\n");
 }
@@ -453,9 +747,16 @@ function formatData(data, warnings, opts) {
 			for (const cmd of data.next_commands) lines.push(`  $ ${String(cmd)}`);
 		}
 	}
-	for (const warning of warnings) lines.push(`Warning: ${warning}`);
+	for (const warning of warnings.filter((warning) => !warningRenderedInChecks(data, warning))) lines.push(`Warning: ${warning}`);
 	return lines.join("\n");
 }
+function warningRenderedInChecks(data, warning) {
+	if (!isObject(data) || !Array.isArray(data.checks)) return false;
+	return data.checks.some((check) => {
+		if (!isObject(check) || check.status !== "warn") return false;
+		return warning === `${String(check.name ?? "check")}: ${String(check.message ?? "")}`;
+	});
+}
 function renderKnownSections(lines, data) {
 	if (isObject(data.project)) {
 		const project = data.project;
@@ -483,7 +784,7 @@ function renderKnownSections(lines, data) {
 		lines.push("Checks:");
 		for (const check of data.checks) {
 			if (!isObject(check)) continue;
-			const status = check.status === "pass" ? "ok" : "fail";
+			const status = check.status === "pass" ? "ok" : check.status === "warn" ? "warn" : "fail";
 			lines.push(`  [${status}] ${String(check.name ?? "check")}: ${String(check.message ?? "")}`);
 		}
 	}
@@ -502,87 +803,6 @@ function suffixBlock(opts) {
 	return suffix ? ` ${suffix}` : "";
 }
 //#endregion
-//#region src/lib/project.ts
-/**
-* Reports whether `cwd` has already been initialized, i.e. a committed
-* `zitadel.json` exists. Used to decide whether setup should run or skip.
-*/
-async function hasZitadelConfig(cwd) {
-	return exists(join(cwd, "zitadel.json"));
-}
-/**
-* Reports whether local secret material (`.zitadel/secret`) is present. Gates
-* commands that need credentials, and signals that secrets were already pulled.
-*/
-async function hasZitadelSecret(cwd) {
-	return exists(join(cwd, ".zitadel/secret"));
-}
-async function exists(path) {
-	try {
-		await stat(path);
-		return true;
-	} catch (error) {
-		if (isNotFound(error)) return false;
-		throw error;
-	}
-}
-/**
-* Reads and parses `zitadel.json` into a plain object. Translates a missing
-* file into an actionable `E_VALIDATION` error pointing at `zitadel setup`;
-* other errors (e.g. malformed JSON) propagate unchanged.
-*/
-async function readZitadelConfig(cwd) {
-	try {
-		return parseJsonObject(await readFile(join(cwd, "zitadel.json"), "utf8"), "zitadel.json");
-	} catch (error) {
-		if (isNotFound(error)) throw new ZitadelError("E_VALIDATION", "zitadel.json was not found", {
-			hint: "Run `zitadel setup` first.",
-			nextCommands: ["zitadel setup"]
-		});
-		throw error;
-	}
-}
-/**
-* Reads, parses, and structurally validates `.zitadel/secret`, returning it
-* as a {@link ZitadelSecret}. A missing file becomes an actionable
-* `E_VALIDATION` error pointing at `zitadel setup` / `zitadel doctor --fix`;
-* a present-but-incomplete file throws so callers never proceed with partial
-* credentials.
-*/
-async function readZitadelSecret(cwd) {
-	try {
-		const secret = parseJsonObject(await readFile(join(cwd, ".zitadel/secret"), "utf8"), ".zitadel/secret");
-		if (typeof secret.project_id !== "string" || typeof secret.project_secret !== "string" || typeof secret.preview_secret !== "string" || !Array.isArray(secret.preview_origins)) throw new Error(".zitadel/secret is missing required fields");
-		return secret;
-	} catch (error) {
-		if (isNotFound(error)) throw new ZitadelError("E_VALIDATION", ".zitadel/secret was not found", {
-			hint: "Run `zitadel setup` first, or restore the project secret with `zitadel doctor --fix`.",
-			nextCommands: ["zitadel setup", "zitadel doctor --fix"]
-		});
-		throw error;
-	}
-}
-/**
-* Reads the configured renderer id from a parsed `zitadel.json`, normalising the
-* legacy `default` alias to `react` and falling back to `react` when unset. The
-* value is validated downstream by `getRenderer`, so callers need not re-check.
-*/
-function readRendererId(config) {
-	const branding = isObject(config.branding) ? config.branding : void 0;
-	const value = branding && typeof branding.renderer === "string" ? branding.renderer : "react";
-	return value === "default" ? "react" : value;
-}
-/** Reads `environments.development.issuer` from a parsed `zitadel.json`, if present. */
-function readDevelopmentIssuer(config) {
-	if (isObject(config.environments) && isObject(config.environments.development)) {
-		const issuer = config.environments.development.issuer;
-		return typeof issuer === "string" ? issuer : void 0;
-	}
-}
-function isNotFound(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
-}
-//#endregion
-export { readZitadelConfig as a, MANAGED_MARKER as c, parseJsonObject as d, stableStringify as f, readRendererId as i, DEFAULT_SERVER as l, hasZitadelSecret as n, readZitadelSecret as o, ZitadelError as p, readDevelopmentIssuer as r, BaseCommand as s, hasZitadelConfig as t, isObject as u };
+export { isObject as C, toZitadelError as D, ZitadelError as E, resolveCwd as S, stableStringify as T, runtimeSummary as _, DEFAULT_LOCAL_SERVER_PORT as a, publicCliCommand as b, checkLocalServerHealth as c, ensureLocalState as d, localContainerName as f, removeRuntimeMetadata as g, removeLocalData as h, CONTAINER_HTTP_PORT as i, defaultLocalServerImageForCliVersion as l, readRuntimeMetadata as m, DEFAULT_SERVER as n, DEFAULT_LOCAL_SERVER_URL as o, localServerUrl as p, CONTAINER_DATA_DIR as r, assertLocalStateWritable as s, BaseCommand as t, ensureContainerIdentity as u, writeRuntimeMetadata as v, parseJsonObject as w, MANAGED_MARKER as x, npmDistTagForCliVersion as y };
 
-//# sourceMappingURL=project-C3pSfbao.mjs.map
+//# sourceMappingURL=oclif-B7lBzh3R.mjs.map