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

package/dist/{runtime-DUgFfYkN.mjs → runtime-C9CEZhcn.mjs}

@@ -1,13 +1,14 @@
-import { package_default } from "./package-t8dKf4m_.mjs";
+import { package_default } from "./package-BGfw4ZWJ.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 { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { Entry } from "@napi-rs/keyring";
-import { homedir } from "node:os";
+import { isCancel } from "@clack/prompts";
 import { setTimeout } from "node:timers/promises";
+import Table from "cli-table3";
 
 //#region src/core/errors.ts
 var MetabaseError = class extends Error {
@@ -137,99 +138,6 @@ function parseJsonResult(input, schema, opts = {}) {
 	};
 }
 
-//#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());
@@ -243,6 +151,14 @@ const account = {
 	profileApiKey: (profile) => `profile:${profile}:apiKey`,
 	license: "license"
 };
+function configDir() {
+	if (process.platform === "win32") {
+		const appData = process.env["APPDATA"] ?? join(homedir(), "AppData", "Roaming");
+		return join(appData, "metabase-cli");
+	}
+	const xdg = process.env["XDG_CONFIG_HOME"] ?? join(homedir(), ".config");
+	return join(xdg, "metabase-cli");
+}
 function fallbackFilePath() {
 	return join(configDir(), CREDENTIALS_FILE);
 }
@@ -372,9 +288,6 @@ async function clearProfile(name = DEFAULT_PROFILE) {
 	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);
 }
@@ -382,82 +295,6 @@ 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() {
@@ -825,6 +662,312 @@ async function readBodyForError(response) {
 	}
 }
 
+//#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;
+}
+
+//#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"
+	};
+}
+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/output/notice.ts
+function warn(message) {
+	process.stderr.write(message + "\n");
+}
+function listTruncationNotice(bytes) {
+	return `… cut at ${bytes} bytes; rerun with --max-bytes 0`;
+}
+function itemOversizeNotice(bytes) {
+	return `… item is ${bytes} bytes (exceeds --max-bytes); narrow with --fields, or pass --max-bytes 0`;
+}
+
+//#endregion
+//#region src/output/cap.ts
+function capListEnvelope(envelope, maxBytes) {
+	if (maxBytes <= 0) return envelope;
+	const fullBytes = jsonByteLength(envelope);
+	if (fullBytes <= maxBytes) return envelope;
+	let lo = 0;
+	let hi = envelope.data.length;
+	while (lo < hi) {
+		const mid = Math.ceil((lo + hi) / 2);
+		if (jsonByteLength(truncate(envelope, mid, fullBytes)) <= maxBytes) lo = mid;
+		else hi = mid - 1;
+	}
+	return truncate(envelope, lo, fullBytes);
+}
+function truncate(envelope, count, originalBytes) {
+	return {
+		...envelope,
+		data: envelope.data.slice(0, count),
+		returned: count,
+		truncated: {
+			reason: "max_bytes",
+			bytes: originalBytes
+		}
+	};
+}
+function jsonByteLength(value) {
+	return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+
+//#endregion
+//#region src/output/projection.ts
+function applyProjection(value, view, full, fields) {
+	if (fields !== void 0) {
+		if (fields.length === 0) throw new ConfigError("--fields requires at least one path");
+		return projectFields(value, fields);
+	}
+	if (full) return value;
+	const parsed = view.compactPick.safeParse(value);
+	if (parsed.success) return parsed.data;
+	throw new ConfigError(`compact projection failed: ${parsed.error.message}`);
+}
+function projectFields(value, fields) {
+	const out = {};
+	for (const path of fields) {
+		if (path.length === 0) throw new ConfigError(`empty field path`);
+		const parts = path.split(".");
+		if (parts.some((part) => part.length === 0)) throw new ConfigError(`invalid field path: "${path}"`);
+		setPath(out, parts, pickPath(value, parts));
+	}
+	return out;
+}
+function pickPath(value, parts) {
+	let cursor = value;
+	for (const part of parts) {
+		if (!isPlainObject(cursor) || !Object.hasOwn(cursor, part)) throw new ConfigError(`unknown field path: "${parts.join(".")}"`);
+		cursor = Reflect.get(cursor, part);
+	}
+	return cursor;
+}
+function setPath(target, parts, value) {
+	let cursor = target;
+	const lastIndex = parts.length - 1;
+	for (const [index, part] of parts.entries()) {
+		if (index === lastIndex) {
+			cursor[part] = value;
+			return;
+		}
+		const existing = cursor[part];
+		if (isPlainObject(existing)) cursor = existing;
+		else {
+			const next = {};
+			cursor[part] = next;
+			cursor = next;
+		}
+	}
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/output/table.ts
+function renderTable(rows, columns) {
+	const head = columns.map((column) => column.label ?? column.key);
+	const widths = columns.map((column) => column.width ?? null);
+	const hasWidth = widths.some((width) => width !== null);
+	const table = new Table(hasWidth ? {
+		head,
+		colWidths: widths
+	} : { head });
+	for (const row of rows) table.push(columns.map((column) => formatCell(row, column)));
+	return table.toString();
+}
+function formatCell(row, column) {
+	const value = row[column.key];
+	if (column.format !== void 0) return column.format(value);
+	return formatScalar(value);
+}
+function formatScalar(value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+}
+
+//#endregion
+//#region src/output/render.ts
+function renderItem(item, view, opts) {
+	const projected = applyProjection(item, view, opts.full, opts.fields);
+	const body = renderItemBody(item, view, projected, opts) + "\n";
+	process.stdout.write(body);
+	emitItemOversizeNotice(body, opts.maxBytes);
+}
+function renderList(envelope, view, opts) {
+	if (opts.format === "json" || opts.fields !== void 0) {
+		renderJsonEnvelope(envelope, view, opts);
+		return;
+	}
+	if (envelope.data.length === 0) {
+		process.stdout.write("(no results)\n");
+		return;
+	}
+	const capped = capListEnvelope(envelope, opts.maxBytes);
+	process.stdout.write(renderTable(capped.data, view.tableColumns) + "\n");
+	if (capped.truncated !== void 0) warn(listTruncationNotice(capped.truncated.bytes));
+}
+function renderJsonEnvelope(envelope, view, opts) {
+	const projectedItems = envelope.data.map((item) => applyProjection(item, view, opts.full, opts.fields));
+	const projectedEnvelope = {
+		...envelope,
+		data: projectedItems
+	};
+	const capped = capListEnvelope(projectedEnvelope, opts.maxBytes);
+	process.stdout.write(JSON.stringify(capped, null, 2) + "\n");
+	if (capped.truncated !== void 0) warn(listTruncationNotice(capped.truncated.bytes));
+}
+function renderItemBody(item, view, projected, opts) {
+	if (opts.format === "json" || opts.fields !== void 0) return JSON.stringify(projected, null, 2);
+	if (!opts.full) return renderKeyValueLines(columnPairs(item, view.tableColumns));
+	return renderKeyValueLines(objectPairs(projected));
+}
+function columnPairs(item, columns) {
+	return columns.map((column) => [column.label ?? column.key, formatCell(item, column)]);
+}
+function objectPairs(value) {
+	if (!isPlainObject(value)) {
+		const scalar = formatScalar(value);
+		return scalar === "" ? [] : [["", scalar]];
+	}
+	return Object.entries(value).map(([key, raw]) => [key, formatScalar(raw)]);
+}
+function renderKeyValueLines(pairs) {
+	if (pairs.length === 0) return "";
+	const padding = Math.max(...pairs.map(([label]) => label.length));
+	return pairs.map(([label, value]) => `${label.padEnd(padding)}  ${value}`).join("\n");
+}
+function emitItemOversizeNotice(body, maxBytes) {
+	if (maxBytes <= 0) return;
+	const bytes = Buffer.byteLength(body, "utf8");
+	if (bytes <= maxBytes) return;
+	warn(itemOversizeNotice(bytes));
+}
+
+//#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/output/error.ts
 function reportError(error) {
@@ -845,14 +988,9 @@ function resolveFormat({ json, format, isTty }) {
 	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
+const INTEGER_PATTERN = /^-?\d+$/;
 function resolveCommonFlags(args, options = {}) {
 	const isTty = options.isTty ?? Boolean(process.stdout.isTTY);
 	const fields = parseFields(args.fields);
@@ -874,14 +1012,15 @@ function resolveCommonFlags(args, options = {}) {
 }
 function parseFields(value) {
 	if (value === void 0 || value === "") return void 0;
-	const parts = parseCsv(value);
+	const parts = value.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
 	return parts.length > 0 ? parts : void 0;
 }
 function parseMaxBytes(value) {
-	return parseInteger(value ?? String(DEFAULT_MAX_BYTES), {
-		name: "--max-bytes",
-		min: 0
-	});
+	const raw = value ?? String(DEFAULT_MAX_BYTES);
+	if (!INTEGER_PATTERN.test(raw)) throw new ConfigError(`invalid --max-bytes value: "${raw}" (expected non-negative integer)`);
+	const parsed = Number.parseInt(raw, 10);
+	if (parsed < 0) throw new ConfigError(`invalid --max-bytes value: ${parsed} (must be non-negative)`);
+	return parsed;
 }
 
 //#endregion
@@ -893,27 +1032,20 @@ function defineMetabaseCommand(def) {
 		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;
-				};
+				let cached = null;
 				const getClient = async () => {
-					if (cachedClient === null) {
-						const resolved = await getResolvedConfig();
-						cachedClient = createClient({
-							url: resolved.url,
-							apiKey: resolved.apiKey
-						});
-					}
-					return cachedClient;
+					if (cached) return cached;
+					const resolved = await resolveConfig(buildConfigFlags(ctx));
+					cached = createClient({
+						url: resolved.url,
+						apiKey: resolved.apiKey
+					});
+					return cached;
 				};
 				await def.run({
 					args,
 					ctx,
-					getClient,
-					getResolvedConfig
+					getClient
 				});
 			} catch (error) {
 				reportError(error);
@@ -947,4 +1079,4 @@ function buildConfigFlags(ctx) {
 }
 
 //#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 };
+export { AbortError, ConfigError, HttpError, MetabaseError, TimeoutError, account, clearLicense, clearProfile, combineAborts, connectionFlags, createClient, credentials, defineMetabaseCommand, errorMessage, isNotFoundError, listEnvelopeSchema, normalizeUrl, originOnly, outputFlags, parseJson, profileFlag, readEnvCredentials, readEnvLicenseToken, renderItem, renderList, resolveProfileName, throwIfAborted, warn, wrapList, writeLicense, writeProfile };

package/dist/{search-4wKx5ug2.mjs → search-CopOytXY.mjs}

@@ -1,8 +1,7 @@
-import "./package-t8dKf4m_.mjs";
+import "./package-BGfw4ZWJ.mjs";
 import "./command-augment-D9pI9Vbh.mjs";
-import { renderList } from "./render-DlBijc5i.mjs";
-import { ConfigError, connectionFlags, defineMetabaseCommand, listEnvelopeSchema, outputFlags, parseCsv, profileFlag } from "./runtime-DUgFfYkN.mjs";
-import { parseId } from "./parse-id-C1prc9US.mjs";
+import { ConfigError, connectionFlags, defineMetabaseCommand, listEnvelopeSchema, outputFlags, profileFlag, renderList } from "./runtime-C9CEZhcn.mjs";
+import { parseId } from "./parse-id-BhmmfyCP.mjs";
 import { z } from "zod";
 
 //#region src/domain/search.ts
@@ -154,7 +153,7 @@ function nonEmpty(value) {
 }
 function parseModels(raw) {
 	if (raw === void 0 || raw === "") return void 0;
-	const parts = parseCsv(raw);
+	const parts = raw.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
 	if (parts.length === 0) return void 0;
 	const accepted = [];
 	const rejected = [];

package/dist/{set-BZnCRL4c.mjs → set-BcF7M1GQ.mjs}

@@ -1,9 +1,8 @@
-import "./package-t8dKf4m_.mjs";
+import "./package-BGfw4ZWJ.mjs";
 import "./command-augment-D9pI9Vbh.mjs";
-import { renderItem, warn } from "./render-DlBijc5i.mjs";
-import { ConfigError, defineMetabaseCommand, outputFlags, readEnvLicenseToken, writeLicense } from "./runtime-DUgFfYkN.mjs";
-import { readInput } from "./input-BNqSFl38.mjs";
-import { promptPassword } from "./prompt-fXeNtj0M.mjs";
+import { ConfigError, defineMetabaseCommand, outputFlags, readEnvLicenseToken, renderItem, warn, writeLicense } from "./runtime-C9CEZhcn.mjs";
+import { promptPassword } from "./prompt-DpT8yAVy.mjs";
+import { readInput } from "./input-Dojr-RTw.mjs";
 import { z } from "zod";
 
 //#region src/commands/license/set.ts

package/dist/{set-DCjrmTFm.mjs → set-CbibegpA.mjs}

@@ -1,11 +1,10 @@
-import "./package-t8dKf4m_.mjs";
+import "./package-BGfw4ZWJ.mjs";
 import "./command-augment-D9pI9Vbh.mjs";
-import { renderItem } from "./render-DlBijc5i.mjs";
-import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-DUgFfYkN.mjs";
-import "./input-BNqSFl38.mjs";
-import { readBody } from "./body-DwU2s6Pg.mjs";
-import { SettingValue, settingValueView } from "./setting-DM7pm7yh.mjs";
-import { parseSettingKey } from "./key-CyhOpgWt.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag, renderItem } from "./runtime-C9CEZhcn.mjs";
+import "./input-Dojr-RTw.mjs";
+import { readBody } from "./body-Dv9hQ0Qk.mjs";
+import { SettingValue, settingValueView } from "./setting-26ckqHAP.mjs";
+import { parseSettingKey } from "./key-DBxPSFwi.mjs";
 import { z } from "zod";
 
 //#region src/commands/setting/set.ts

package/dist/{setting-C4vQSqer.mjs → setting-U3NtBMFo.mjs}

@@ -8,9 +8,9 @@ var setting_default = defineCommand({
 		alias: "settings"
 	},
 	subCommands: {
-		list: () => import("./list-Y7iGsOfE.mjs").then((m) => m.default),
-		get: () => import("./get-CAVVmdMX.mjs").then((m) => m.default),
-		set: () => import("./set-DCjrmTFm.mjs").then((m) => m.default)
+		list: () => import("./list-Bk6RsbJl.mjs").then((m) => m.default),
+		get: () => import("./get-COXHplHP.mjs").then((m) => m.default),
+		set: () => import("./set-CbibegpA.mjs").then((m) => m.default)
 	}
 });