@metabase/cli 0.1.0-alpha.workspaces-commands.818a8f1

package/dist/runtime-DUgFfYkN.mjs

@@ -0,0 +1,950 @@
+import { package_default } from "./package-t8dKf4m_.mjs";
+import { setMetabaseAugment } from "./command-augment-D9pI9Vbh.mjs";
+import { defineCommand } from "citty";
+import { ZodError, z } from "zod";
+import { isCancel } from "@clack/prompts";
+import { promises } from "node:fs";
+import { dirname, join } from "node:path";
+import { Entry } from "@napi-rs/keyring";
+import { homedir } from "node:os";
+import { setTimeout } from "node:timers/promises";
+
+//#region src/core/errors.ts
+var MetabaseError = class extends Error {
+	get userMessage() {
+		return this.message;
+	}
+};
+var NetworkError = class extends MetabaseError {
+	category = "network";
+	isRetryable = true;
+	exitCode = 1;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "NetworkError";
+		this.developerDetail = developerDetail;
+	}
+};
+var TimeoutError = class extends MetabaseError {
+	category = "timeout";
+	isRetryable = true;
+	exitCode = 1;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "TimeoutError";
+		this.developerDetail = developerDetail;
+	}
+};
+var ValidationError = class extends MetabaseError {
+	category = "validation";
+	isRetryable = false;
+	exitCode = 1;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "ValidationError";
+		this.developerDetail = developerDetail;
+	}
+};
+var ConfigError = class extends MetabaseError {
+	category = "config";
+	isRetryable = false;
+	exitCode = 2;
+	developerDetail = null;
+	constructor(message) {
+		super(message);
+		this.name = "ConfigError";
+	}
+};
+var AbortError = class extends MetabaseError {
+	category = "abort";
+	isRetryable = false;
+	exitCode = 130;
+	developerDetail = null;
+	constructor(message = "aborted") {
+		super(message);
+		this.name = "AbortError";
+	}
+};
+var UnknownError = class extends MetabaseError {
+	category = "unknown";
+	isRetryable = false;
+	exitCode = 1;
+	developerDetail;
+	constructor(input) {
+		super(input.originalMessage);
+		this.name = "UnknownError";
+		this.developerDetail = input;
+	}
+};
+function toMetabaseError(error) {
+	if (error instanceof MetabaseError) return error;
+	if (isCancel(error)) return new AbortError();
+	if (error instanceof ZodError) return new ConfigError(formatZodError(error));
+	if (error instanceof Error) return new UnknownError({
+		originalMessage: error.message,
+		stack: error.stack ?? null
+	});
+	return new UnknownError({
+		originalMessage: String(error),
+		stack: null
+	});
+}
+function formatZodError(error) {
+	return error.issues.map((issue) => {
+		const path = issue.path.join(".");
+		return path ? `${path}: ${issue.message}` : issue.message;
+	}).join("; ");
+}
+function isNotFoundError(value) {
+	return value instanceof Error && "code" in value && value.code === "ENOENT";
+}
+function errorMessage(value) {
+	return value instanceof Error ? value.message : String(value);
+}
+
+//#endregion
+//#region src/runtime/json.ts
+function parseJson(input, schema, opts = {}) {
+	const result = parseJsonResult(input, schema, opts);
+	if (!result.ok) throw result.error;
+	return result.value;
+}
+function parseJsonResult(input, schema, opts = {}) {
+	const sourcePrefix = opts.source ? `${opts.source}: ` : "";
+	let raw;
+	try {
+		raw = JSON.parse(input);
+	} catch (error) {
+		return {
+			ok: false,
+			error: new ConfigError(`${sourcePrefix}invalid JSON: ${errorMessage(error)}`)
+		};
+	}
+	const parsed = schema.safeParse(raw);
+	if (!parsed.success) return {
+		ok: false,
+		error: new ValidationError(`${sourcePrefix}value did not match expected schema`, {
+			source: opts.source ?? "<input>",
+			zodIssues: parsed.error.issues
+		})
+	};
+	return {
+		ok: true,
+		value: parsed.data
+	};
+}
+
+//#endregion
+//#region src/output/types.ts
+const DEFAULT_MAX_BYTES = 65536;
+function listEnvelopeSchema(item) {
+	return z.object({
+		data: z.array(item),
+		returned: z.number().int().nonnegative(),
+		total: z.number().int().nonnegative().optional(),
+		limit: z.number().int().nonnegative().optional(),
+		truncated: z.object({
+			reason: z.literal("max_bytes"),
+			bytes: z.number().int().nonnegative()
+		}).optional()
+	});
+}
+function wrapList(items) {
+	return {
+		data: items,
+		returned: items.length,
+		total: items.length
+	};
+}
+
+//#endregion
+//#region src/commands/flags.ts
+const outputFlags = {
+	format: {
+		type: "string",
+		description: "auto | json | text",
+		default: "auto"
+	},
+	json: {
+		type: "boolean",
+		description: "Shorthand for --format json"
+	},
+	full: {
+		type: "boolean",
+		description: "Return the full object (default: compact)"
+	},
+	fields: {
+		type: "string",
+		description: "Dot-paths, comma separated (mutually exclusive with --full)"
+	},
+	maxBytes: {
+		type: "string",
+		description: "Output size cap; 0 disables",
+		default: String(DEFAULT_MAX_BYTES),
+		alias: "max-bytes"
+	}
+};
+const profileFlag = { profile: {
+	type: "string",
+	description: "Named profile (default: 'default')"
+} };
+const connectionFlags = {
+	url: {
+		type: "string",
+		description: "Metabase URL"
+	},
+	apiKey: {
+		type: "string",
+		description: "API key",
+		alias: "api-key"
+	}
+};
+
+//#endregion
+//#region src/commands/parse-integer.ts
+const INTEGER_PATTERN = /^-?\d+$/;
+function parseInteger(value, options) {
+	const trimmed = value.trim();
+	if (!INTEGER_PATTERN.test(trimmed)) throw new ConfigError(`invalid ${options.name}: "${value}" (expected integer)`);
+	const parsed = Number.parseInt(trimmed, 10);
+	if (parsed < options.min) throw new ConfigError(`invalid ${options.name}: ${parsed} (must be ≥ ${options.min})`);
+	return parsed;
+}
+function parseOptionalInteger(value, options) {
+	if (value === void 0 || value === "") return null;
+	return parseInteger(value, options);
+}
+
+//#endregion
+//#region src/core/paths.ts
+const APP_DIR_NAME = "metabase-cli";
+function configDir() {
+	if (process.platform === "win32") {
+		const appData = process.env["APPDATA"] ?? join(homedir(), "AppData", "Roaming");
+		return join(appData, APP_DIR_NAME);
+	}
+	const xdg = process.env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config");
+	return join(xdg, APP_DIR_NAME);
+}
+
+//#endregion
+//#region src/core/auth/storage.ts
+const CredentialsFileSchema = z.record(z.string(), z.string());
+const KEYRING_SERVICE = "metabase-cli";
+const CREDENTIALS_FILE = "credentials.json";
+const DEFAULT_PROFILE = "default";
+const CREDENTIALS_FILE_MODE = 384;
+const CREDENTIALS_DIR_MODE = 448;
+const account = {
+	profileUrl: (profile) => `profile:${profile}:url`,
+	profileApiKey: (profile) => `profile:${profile}:apiKey`,
+	license: "license"
+};
+function fallbackFilePath() {
+	return join(configDir(), CREDENTIALS_FILE);
+}
+function keyringEnabled() {
+	return process.env["METABASE_CLI_DISABLE_KEYRING"] !== "1";
+}
+function trySetKeyring(key, value) {
+	if (!keyringEnabled()) return false;
+	try {
+		new Entry(KEYRING_SERVICE, key).setPassword(value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function tryReadKeyring(key) {
+	if (!keyringEnabled()) return void 0;
+	try {
+		return new Entry(KEYRING_SERVICE, key).getPassword();
+	} catch {
+		return void 0;
+	}
+}
+function tryRemoveKeyring(key) {
+	if (!keyringEnabled()) return void 0;
+	try {
+		return new Entry(KEYRING_SERVICE, key).deletePassword();
+	} catch {
+		return void 0;
+	}
+}
+async function readFileStore() {
+	const path = fallbackFilePath();
+	let raw;
+	try {
+		raw = await promises.readFile(path, "utf8");
+	} catch (error) {
+		if (isNotFoundError(error)) return {};
+		throw error;
+	}
+	return parseJson(raw, CredentialsFileSchema, { source: path });
+}
+async function writeFileStore(store) {
+	const path = fallbackFilePath();
+	await promises.mkdir(dirname(path), {
+		recursive: true,
+		mode: CREDENTIALS_DIR_MODE
+	});
+	await promises.writeFile(path, JSON.stringify(store, null, 2) + "\n", { mode: CREDENTIALS_FILE_MODE });
+	if (process.platform !== "win32") await promises.chmod(path, CREDENTIALS_FILE_MODE);
+}
+async function setFile(key, value) {
+	const store = await readFileStore();
+	store[key] = value;
+	await writeFileStore(store);
+}
+async function readFromFile(key) {
+	const store = await readFileStore();
+	return store[key] ?? null;
+}
+async function removeFromFile(key) {
+	const store = await readFileStore();
+	if (!(key in store)) return false;
+	delete store[key];
+	if (Object.keys(store).length === 0) await promises.unlink(fallbackFilePath()).catch(() => void 0);
+	else await writeFileStore(store);
+	return true;
+}
+const credentials = {
+	async set(key, value) {
+		if (trySetKeyring(key, value)) {
+			await removeFromFile(key).catch(() => void 0);
+			return {
+				backend: "keyring",
+				service: KEYRING_SERVICE,
+				account: key
+			};
+		}
+		await setFile(key, value);
+		return {
+			backend: "file",
+			path: fallbackFilePath(),
+			account: key
+		};
+	},
+	async read(key) {
+		const fromKeyring = tryReadKeyring(key);
+		if (fromKeyring !== void 0) return fromKeyring;
+		return readFromFile(key);
+	},
+	async has(key) {
+		return await credentials.read(key) !== null;
+	},
+	async remove(key) {
+		const fromKeyring = tryRemoveKeyring(key);
+		const fromFile = await removeFromFile(key).catch(() => false);
+		if (fromKeyring === void 0) return fromFile;
+		return fromKeyring || fromFile;
+	},
+	async location(key) {
+		if (tryReadKeyring(key) !== void 0) return {
+			backend: "keyring",
+			service: KEYRING_SERVICE,
+			account: key
+		};
+		return {
+			backend: "file",
+			path: fallbackFilePath(),
+			account: key
+		};
+	}
+};
+async function readProfile(name = DEFAULT_PROFILE) {
+	const [url, apiKey] = await Promise.all([credentials.read(account.profileUrl(name)), credentials.read(account.profileApiKey(name))]);
+	if (!url || !apiKey) return null;
+	return {
+		url,
+		apiKey
+	};
+}
+async function writeProfile(profile, name = DEFAULT_PROFILE) {
+	await credentials.set(account.profileUrl(name), profile.url);
+	return credentials.set(account.profileApiKey(name), profile.apiKey);
+}
+async function clearProfile(name = DEFAULT_PROFILE) {
+	const removedUrl = await credentials.remove(account.profileUrl(name));
+	const removedKey = await credentials.remove(account.profileApiKey(name));
+	return removedUrl || removedKey;
+}
+async function readLicense() {
+	return credentials.read(account.license);
+}
+async function writeLicense(token) {
+	return credentials.set(account.license, token);
+}
+async function clearLicense() {
+	return credentials.remove(account.license);
+}
+
+//#endregion
+//#region src/core/url.ts
+function normalizeUrl(input) {
+	const trimmed = input.trim().replace(/\/+$/, "");
+	if (!/^https?:\/\//i.test(trimmed)) throw new Error("URL must start with http:// or https://");
+	return trimmed;
+}
+function originOnly(input) {
+	const parsed = new URL(input);
+	parsed.username = "";
+	parsed.password = "";
+	return parsed.origin;
+}
+function localUrl(port) {
+	return `http://localhost:${port}`;
+}
+
+//#endregion
+//#region src/core/config.ts
+const ENV_URL = "METABASE_URL";
+const ENV_API_KEY = "METABASE_API_KEY";
+const ENV_PROFILE = "METABASE_PROFILE";
+const ENV_LICENSE_TOKEN = "METABASE_LICENSE_TOKEN";
+function resolveProfileName(profileFlag$1) {
+	return profileFlag$1 || process.env[ENV_PROFILE] || DEFAULT_PROFILE;
+}
+function readEnvCredentials() {
+	return {
+		url: process.env[ENV_URL] ?? null,
+		apiKey: process.env[ENV_API_KEY] ?? null
+	};
+}
+function readEnvLicenseToken() {
+	return process.env[ENV_LICENSE_TOKEN] ?? null;
+}
+async function resolveConfig(flags) {
+	const profile = resolveProfileName(flags.profile);
+	const env = readEnvCredentials();
+	const flagUrl = flags.url;
+	const flagKey = flags.apiKey;
+	const needsStored = !flagUrl && !env.url || !flagKey && !env.apiKey;
+	const stored = needsStored ? await readProfile(profile) : null;
+	const urlField = pickField(flagUrl, env.url, stored?.url);
+	const keyField = pickField(flagKey, env.apiKey, stored?.apiKey);
+	if (urlField === null || keyField === null) throw new ConfigError(`Not authenticated for profile "${profile}". Run \`metabase auth login\`, set ${ENV_URL}/${ENV_API_KEY}, or pass --url/--api-key.`);
+	return {
+		url: normalizeUrl(urlField.value),
+		apiKey: keyField.value,
+		profile,
+		source: urlField.source === keyField.source ? urlField.source : "mixed"
+	};
+}
+async function resolveLicenseToken(flags) {
+	const flag = flags.token;
+	const env = readEnvLicenseToken();
+	const stored = !flag && !env ? await readLicense() : null;
+	const value = flag ?? env ?? stored;
+	if (!value) throw new ConfigError(`No license token. Pass --token, set ${ENV_LICENSE_TOKEN}, or store one with \`metabase license set\`.`);
+	return value;
+}
+function pickField(flag, env, stored) {
+	if (flag) return {
+		value: flag,
+		source: "flag"
+	};
+	if (env) return {
+		value: env,
+		source: "env"
+	};
+	if (stored) return {
+		value: stored,
+		source: "stored"
+	};
+	return null;
+}
+
+//#endregion
+//#region src/runtime/signal.ts
+function createProcessAbortHandler() {
+	const controller = new AbortController();
+	const handler = () => {
+		if (!controller.signal.aborted) controller.abort(new AbortError("interrupted"));
+		process.off("SIGINT", handler);
+	};
+	process.on("SIGINT", handler);
+	return {
+		signal: controller.signal,
+		uninstall: () => process.off("SIGINT", handler)
+	};
+}
+let singleton = null;
+function getProcessAbortSignal() {
+	if (singleton === null) singleton = createProcessAbortHandler().signal;
+	return singleton;
+}
+function combineAborts(timeoutSignal, callerSignal) {
+	const processSignal = getProcessAbortSignal();
+	const signals = [timeoutSignal, processSignal];
+	if (callerSignal) signals.push(callerSignal);
+	return {
+		combined: AbortSignal.any(signals),
+		processSignal
+	};
+}
+function throwIfAborted(...signals) {
+	for (const signal of signals) if (signal?.aborted) throw abortReason(signal);
+}
+function abortReason(signal) {
+	const reason = signal.reason;
+	if (reason instanceof MetabaseError) return reason;
+	if (reason instanceof Error || typeof reason === "string") return new AbortError(errorMessage(reason) || "aborted");
+	return new AbortError("aborted");
+}
+
+//#endregion
+//#region src/core/http/sanitize.ts
+const SECRET_HEADER_NAMES = new Set([
+	"authorization",
+	"x-api-key",
+	"x-metabase-session",
+	"cookie",
+	"set-cookie",
+	"proxy-authorization"
+]);
+const REDACTED = "[REDACTED]";
+function redactHeaders(headers) {
+	const result = {};
+	const entries = headers instanceof Headers ? headers.entries() : Object.entries(headers);
+	for (const [key, value] of entries) result[key] = SECRET_HEADER_NAMES.has(key.toLowerCase()) ? REDACTED : value;
+	return result;
+}
+function redactBody(body, ctx) {
+	let result = body;
+	for (const secret of ctx.knownSecrets) {
+		if (secret.length === 0) continue;
+		result = result.replaceAll(secret, REDACTED);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/core/http/errors.ts
+const STATUS_CLASSIFICATIONS = {
+	401: {
+		retryable: false,
+		message: "Invalid or unauthorized API key"
+	},
+	403: {
+		retryable: false,
+		message: "Invalid or unauthorized API key"
+	},
+	404: {
+		retryable: false,
+		message: "Endpoint not found — is this a Metabase instance?"
+	},
+	408: {
+		retryable: true,
+		message: "Metabase timed out responding"
+	},
+	425: { retryable: true },
+	429: {
+		retryable: true,
+		message: "Metabase rate-limited the request"
+	},
+	500: { retryable: true },
+	502: { retryable: true },
+	503: { retryable: true },
+	504: {
+		retryable: true,
+		message: "Metabase timed out responding"
+	}
+};
+const ErrorEnvelope = z.object({
+	message: z.string().optional(),
+	error: z.string().optional(),
+	"error-message": z.string().optional()
+});
+var HttpError = class extends MetabaseError {
+	category = "http";
+	exitCode = 1;
+	status;
+	developerDetail;
+	constructor(input) {
+		const sanitizedBody = sanitizeBody(input.rawBody, input.redactionContext);
+		super(input.overrideUserMessage ?? extractUserMessage(input.status, sanitizedBody));
+		this.name = "HttpError";
+		this.status = input.status;
+		this.developerDetail = {
+			status: input.status,
+			statusText: input.statusText,
+			method: input.method,
+			url: input.url,
+			responseHeaders: redactHeaders(input.responseHeaders),
+			body: sanitizedBody
+		};
+	}
+	get isRetryable() {
+		return isRetryableStatus(this.status);
+	}
+};
+function isRetryableStatus(status) {
+	return STATUS_CLASSIFICATIONS[status]?.retryable === true;
+}
+function sanitizeBody(rawBody, ctx) {
+	if (rawBody === null) return null;
+	if (ctx === void 0) return rawBody;
+	return redactBody(rawBody, ctx);
+}
+function extractUserMessage(status, sanitizedBody) {
+	const fromBody = parseEnvelopeMessage(sanitizedBody);
+	if (fromBody) return fromBody;
+	return defaultMessageForStatus(status);
+}
+function parseEnvelopeMessage(sanitizedBody) {
+	if (!sanitizedBody) return null;
+	const result = parseJsonResult(sanitizedBody, ErrorEnvelope);
+	if (!result.ok) return null;
+	const envelope = result.value;
+	return envelope.message ?? envelope.error ?? envelope["error-message"] ?? null;
+}
+function defaultMessageForStatus(status) {
+	return STATUS_CLASSIFICATIONS[status]?.message ?? `Metabase returned ${status}`;
+}
+
+//#endregion
+//#region src/core/http/retry.ts
+const DEFAULT_MAX_RETRIES = 3;
+const BASE_DELAY_MS = 250;
+const MAX_DELAY_MS = 8e3;
+const MS_PER_SECOND = 1e3;
+function backoffDelay({ attempt, retryAfterHeader }) {
+	const fromHeader = parseRetryAfter(retryAfterHeader);
+	if (fromHeader !== null) return fromHeader;
+	return Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** attempt);
+}
+function parseRetryAfter(header) {
+	if (!header) return null;
+	const numeric = Number(header);
+	if (Number.isFinite(numeric) && numeric >= 0) return Math.round(numeric * MS_PER_SECOND);
+	const dateMs = Date.parse(header);
+	if (Number.isFinite(dateMs)) return Math.max(0, dateMs - Date.now());
+	return null;
+}
+function sleep(ms, signal) {
+	return setTimeout(ms, void 0, { signal });
+}
+
+//#endregion
+//#region src/core/http/client.ts
+const DEFAULT_TIMEOUT_MS = 3e4;
+const JSON_CONTENT_TYPE = "application/json";
+const TEXT_CONTENT_TYPE_PREFIX = "text/";
+const ERROR_BODY_BYTE_CAP = 64 * 1024;
+const USER_AGENT = `metabase-cli/${package_default.version}`;
+const IDEMPOTENT_METHODS = new Set([
+	"GET",
+	"HEAD",
+	"OPTIONS"
+]);
+function createClient(config, overrides = {}) {
+	const fetchImpl = overrides.fetchImpl ?? globalThis.fetch.bind(globalThis);
+	const redactionContext = { knownSecrets: new Set([config.apiKey]) };
+	async function attemptOnce(prepared, attempt) {
+		const hasRetriesLeft = attempt < prepared.retries;
+		const timeoutSignal = AbortSignal.timeout(prepared.timeoutMs);
+		const { combined, processSignal } = combineAborts(timeoutSignal, prepared.callerSignal);
+		let response;
+		try {
+			response = await fetchImpl(prepared.url, {
+				method: prepared.method,
+				headers: prepared.headers,
+				body: prepared.body,
+				signal: combined
+			});
+		} catch (error) {
+			throwIfAborted(prepared.callerSignal, processSignal);
+			if (hasRetriesLeft) return {
+				kind: "retry",
+				delayMs: backoffDelay({ attempt })
+			};
+			if (timeoutSignal.aborted) throw new TimeoutError(`Request timed out after ${prepared.timeoutMs}ms`, {
+				kind: "http",
+				method: prepared.method,
+				url: prepared.url,
+				timeoutMs: prepared.timeoutMs
+			});
+			const message = errorMessage(error);
+			throw new NetworkError(`Could not reach Metabase: ${message}`, {
+				method: prepared.method,
+				url: prepared.url,
+				cause: message
+			});
+		}
+		const canRetryStatus = hasRetriesLeft && prepared.idempotent;
+		if (!response.ok && isRetryableStatus(response.status) && canRetryStatus) {
+			const retryAfter = response.headers.get("Retry-After");
+			response.body?.cancel().catch(() => void 0);
+			return {
+				kind: "retry",
+				delayMs: backoffDelay({
+					attempt,
+					retryAfterHeader: retryAfter
+				})
+			};
+		}
+		if (!response.ok) {
+			const rawBody = await readBodyForError(response);
+			throw new HttpError({
+				status: response.status,
+				statusText: response.statusText,
+				method: prepared.method,
+				url: prepared.url,
+				responseHeaders: response.headers,
+				rawBody,
+				redactionContext
+			});
+		}
+		assertContentType(response, prepared);
+		return {
+			kind: "success",
+			response
+		};
+	}
+	async function executeRaw(prepared) {
+		let attempt = 0;
+		while (true) {
+			const result = await attemptOnce(prepared, attempt);
+			if (result.kind === "success") return result.response;
+			await sleep(result.delayMs, prepared.callerSignal);
+			attempt += 1;
+		}
+	}
+	function prepare(path, opts = {}) {
+		const method = opts.method ?? "GET";
+		const expectContentType = opts.expectContentType ?? "json";
+		const url = buildUrl(config.url, path, opts.query);
+		const headers = new Headers();
+		headers.set("x-api-key", config.apiKey);
+		headers.set("accept", acceptHeader(expectContentType));
+		headers.set("user-agent", USER_AGENT);
+		let body = null;
+		if (opts.body !== void 0 && opts.body !== null) if (typeof opts.body === "string" || opts.body instanceof URLSearchParams) body = opts.body;
+		else if (opts.body instanceof FormData || opts.body instanceof ReadableStream) body = opts.body;
+		else {
+			body = JSON.stringify(opts.body);
+			headers.set("content-type", JSON_CONTENT_TYPE);
+		}
+		return {
+			url,
+			method,
+			headers,
+			body,
+			expectContentType,
+			retries: opts.retries ?? DEFAULT_MAX_RETRIES,
+			idempotent: opts.idempotent ?? IDEMPOTENT_METHODS.has(method),
+			timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+			callerSignal: opts.signal
+		};
+	}
+	return {
+		async requestRaw(path, opts) {
+			return executeRaw(prepare(path, opts));
+		},
+		async requestParsed(schema, path, opts) {
+			const prepared = prepare(path, {
+				...opts,
+				expectContentType: "json"
+			});
+			const response = await executeRaw(prepared);
+			const text$1 = await response.text();
+			try {
+				return parseJson(text$1, schema, { source: prepared.url });
+			} catch (error) {
+				if (error instanceof ConfigError) throw new HttpError({
+					status: response.status,
+					statusText: response.statusText,
+					method: prepared.method,
+					url: prepared.url,
+					responseHeaders: response.headers,
+					rawBody: text$1,
+					redactionContext
+				});
+				throw error;
+			}
+		},
+		async requestStream(path, opts) {
+			const prepared = prepare(path, {
+				...opts,
+				expectContentType: opts?.expectContentType ?? "binary"
+			});
+			const response = await executeRaw(prepared);
+			if (!response.body) throw new NetworkError("Response had no body to stream", {
+				method: prepared.method,
+				url: prepared.url,
+				cause: "missing body"
+			});
+			return response.body;
+		}
+	};
+}
+function buildUrl(baseUrl, path, query) {
+	const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+	const target = new URL(baseUrl + normalizedPath);
+	if (query) for (const [key, value] of Object.entries(query)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const entry of value) target.searchParams.append(key, String(entry));
+		else target.searchParams.append(key, String(value));
+	}
+	return target.toString();
+}
+function acceptHeader(expected) {
+	if (expected === "json") return JSON_CONTENT_TYPE;
+	if (expected === "text") return "text/*";
+	return "*/*";
+}
+function assertContentType(response, prepared) {
+	if (prepared.expectContentType === "binary") return;
+	const contentType = response.headers.get("content-type");
+	if (contentType === null) throwContentTypeMismatch(response, prepared, prepared.expectContentType);
+	if (prepared.expectContentType === "json" && !contentType.includes(JSON_CONTENT_TYPE)) throwContentTypeMismatch(response, prepared, "json");
+	if (prepared.expectContentType === "text" && !contentType.startsWith(TEXT_CONTENT_TYPE_PREFIX)) throwContentTypeMismatch(response, prepared, "text");
+}
+function throwContentTypeMismatch(response, prepared, expected) {
+	const actual = response.headers.get("content-type") ?? "no content-type";
+	throw new HttpError({
+		status: response.status,
+		statusText: response.statusText,
+		method: prepared.method,
+		url: prepared.url,
+		responseHeaders: response.headers,
+		rawBody: null,
+		overrideUserMessage: `Expected ${expected} response but got ${actual}`
+	});
+}
+async function readBodyForError(response) {
+	try {
+		const buffer = Buffer.from(await response.arrayBuffer());
+		return buffer.subarray(0, ERROR_BODY_BYTE_CAP).toString("utf8");
+	} catch (error) {
+		return `[body read failed: ${errorMessage(error)}]`;
+	}
+}
+
+//#endregion
+//#region src/output/error.ts
+function reportError(error) {
+	const handled = toMetabaseError(error);
+	process.stderr.write(handled.userMessage + "\n");
+	if (process.env["METABASE_VERBOSE"] === "1" && handled.developerDetail !== null) process.stderr.write(JSON.stringify(handled.developerDetail, null, 2) + "\n");
+	process.exitCode = handled.exitCode;
+}
+
+//#endregion
+//#region src/output/format.ts
+function resolveFormat({ json, format, isTty }) {
+	const explicit = format !== void 0 && format !== "auto" ? format : null;
+	if (explicit !== null && explicit !== "json" && explicit !== "text") throw new ConfigError(`invalid --format value: "${explicit}" (expected: auto, json, text)`);
+	if (json && explicit !== null && explicit !== "json") throw new ConfigError(`--json conflicts with --format ${explicit}`);
+	if (json) return "json";
+	if (explicit !== null) return explicit;
+	return isTty ? "text" : "json";
+}
+
+//#endregion
+//#region src/runtime/csv.ts
+function parseCsv(raw) {
+	return raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+
+//#endregion
+//#region src/commands/context.ts
+function resolveCommonFlags(args, options = {}) {
+	const isTty = options.isTty ?? Boolean(process.stdout.isTTY);
+	const fields = parseFields(args.fields);
+	const full = args.full === true;
+	if (full && fields !== void 0) throw new ConfigError("--full conflicts with --fields (use one or neither)");
+	return {
+		format: resolveFormat({
+			json: args.json,
+			format: args.format,
+			isTty
+		}),
+		full,
+		fields,
+		maxBytes: parseMaxBytes(args.maxBytes),
+		url: args.url,
+		apiKey: args.apiKey,
+		profile: args.profile
+	};
+}
+function parseFields(value) {
+	if (value === void 0 || value === "") return void 0;
+	const parts = parseCsv(value);
+	return parts.length > 0 ? parts : void 0;
+}
+function parseMaxBytes(value) {
+	return parseInteger(value ?? String(DEFAULT_MAX_BYTES), {
+		name: "--max-bytes",
+		min: 0
+	});
+}
+
+//#endregion
+//#region src/commands/runtime.ts
+function defineMetabaseCommand(def) {
+	const cmd = defineCommand({
+		meta: def.meta,
+		args: def.args,
+		async run({ args }) {
+			try {
+				const ctx = resolveCommonFlags(pickCommonArgs(args));
+				let cachedConfig = null;
+				let cachedClient = null;
+				const getResolvedConfig = async () => {
+					if (cachedConfig === null) cachedConfig = await resolveConfig(buildConfigFlags(ctx));
+					return cachedConfig;
+				};
+				const getClient = async () => {
+					if (cachedClient === null) {
+						const resolved = await getResolvedConfig();
+						cachedClient = createClient({
+							url: resolved.url,
+							apiKey: resolved.apiKey
+						});
+					}
+					return cachedClient;
+				};
+				await def.run({
+					args,
+					ctx,
+					getClient,
+					getResolvedConfig
+				});
+			} catch (error) {
+				reportError(error);
+			}
+		}
+	});
+	setMetabaseAugment(cmd, {
+		examples: def.examples ?? [],
+		outputSchema: def.outputSchema ?? null
+	});
+	return cmd;
+}
+function pickCommonArgs(args) {
+	const out = {};
+	if (typeof args["format"] === "string") out.format = args["format"];
+	if (typeof args["json"] === "boolean") out.json = args["json"];
+	if (typeof args["full"] === "boolean") out.full = args["full"];
+	if (typeof args["fields"] === "string") out.fields = args["fields"];
+	if (typeof args["maxBytes"] === "string") out.maxBytes = args["maxBytes"];
+	if (typeof args["profile"] === "string") out.profile = args["profile"];
+	if (typeof args["url"] === "string") out.url = args["url"];
+	if (typeof args["apiKey"] === "string") out.apiKey = args["apiKey"];
+	return out;
+}
+function buildConfigFlags(ctx) {
+	const flags = {};
+	if (ctx.profile !== void 0) flags.profile = ctx.profile;
+	if (ctx.url !== void 0) flags.url = ctx.url;
+	if (ctx.apiKey !== void 0) flags.apiKey = ctx.apiKey;
+	return flags;
+}
+
+//#endregion
+export { AbortError, ConfigError, HttpError, MetabaseError, TimeoutError, ValidationError, account, clearLicense, clearProfile, combineAborts, connectionFlags, createClient, credentials, defineMetabaseCommand, errorMessage, isNotFoundError, listEnvelopeSchema, localUrl, normalizeUrl, originOnly, outputFlags, parseCsv, parseInteger, parseJson, parseOptionalInteger, profileFlag, readEnvCredentials, readEnvLicenseToken, resolveLicenseToken, resolveProfileName, throwIfAborted, wrapList, writeLicense, writeProfile };