@metabase/cli 0.1.0 → 0.1.2

package/dist/{query-PihYi-UZ.mjs → query-jmfqaXRP.mjs}

@@ -1,8 +1,11 @@
-import "./package-BGfw4ZWJ.mjs";
+import "./package-DV6Asqim.mjs";
 import "./command-augment-D9pI9Vbh.mjs";
-import { ConfigError, connectionFlags, defineMetabaseCommand, outputFlags, parseJson, profileFlag, renderItem } from "./runtime-C9CEZhcn.mjs";
-import { CardQueryResult, cardQueryView } from "./card-CsXk8T6A.mjs";
-import { parseId } from "./parse-id-BhmmfyCP.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import { ConfigError } from "./predicates-DiIiS3k7.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, parseJson, profileFlag } from "./runtime-cwBS8wwK.mjs";
+import { parseId } from "./parse-id-B38zTlYs.mjs";
+import "./field-B3gvaqpK.mjs";
+import { CardQueryResult, cardQueryView } from "./card-CQxvHeyP.mjs";
 import { z } from "zod";
 import { Writable } from "node:stream";
 
@@ -13,12 +16,16 @@ async function pipeToStdout(stream) {
 
 //#endregion
 //#region src/commands/card/query.ts
-const ExportFormat = z.enum(["csv", "xlsx"]);
+const ExportFormat = z.enum([
+	"csv",
+	"json",
+	"xlsx"
+]);
 const QueryParameters = z.array(z.unknown());
 var query_default = defineMetabaseCommand({
 	meta: {
 		name: "query",
-		description: "Run a saved card and return results (json envelope, CSV, or XLSX)"
+		description: "Run a saved card and return results (json envelope, or stream CSV/JSON/XLSX via --export-format)"
 	},
 	args: {
 		...outputFlags,
@@ -39,7 +46,17 @@ var query_default = defineMetabaseCommand({
 		},
 		limit: {
 			type: "string",
-			description: "Cap rows kept in the JSON envelope (no effect on csv/xlsx exports)"
+			description: "Cap rows kept in the JSON envelope (no effect on streamed exports)"
+		},
+		"format-rows": {
+			type: "boolean",
+			description: "Streamed exports only: apply visualization-settings formatting to values (default false)",
+			default: false
+		},
+		"pivot-results": {
+			type: "boolean",
+			description: "Streamed exports only: emit the pivoted output for pivot questions (default false)",
+			default: false
 		}
 	},
 	outputSchema: CardQueryResult,
@@ -55,8 +72,12 @@ var query_default = defineMetabaseCommand({
 		const client = await getClient();
 		const exportFormatRaw = args["export-format"];
 		if (exportFormatRaw !== void 0 && exportFormatRaw !== "") {
-			const exportFormat = parseExportFormat(exportFormatRaw);
-			await streamExport(client, id, exportFormat, parameters);
+			await streamExport(client, id, {
+				format: parseExportFormat(exportFormatRaw),
+				parameters,
+				formatRows: args["format-rows"],
+				pivotResults: args["pivot-results"]
+			});
 			return;
 		}
 		const result = await client.requestParsed(CardQueryResult, `/api/card/${id}/query`, {
@@ -77,7 +98,7 @@ function parseExportFormat(raw) {
 	return result.data;
 }
 function applyLimit(result, limit) {
-	if (limit === null || result.status !== "completed" || result.data.rows.length <= limit) return result;
+	if (limit === null || result.data === void 0 || result.data.rows.length <= limit) return result;
 	return {
 		...result,
 		data: {
@@ -86,9 +107,13 @@ function applyLimit(result, limit) {
 		}
 	};
 }
-async function streamExport(client, id, format, parameters) {
-	const body = new URLSearchParams({ parameters: JSON.stringify(parameters) });
-	const stream = await client.requestStream(`/api/card/${id}/query/${format}`, {
+async function streamExport(client, id, options) {
+	const body = new URLSearchParams({
+		parameters: JSON.stringify(options.parameters),
+		format_rows: String(options.formatRows),
+		pivot_results: String(options.pivotResults)
+	});
+	const stream = await client.requestStream(`/api/card/${id}/query/${options.format}`, {
 		method: "POST",
 		body
 	});

package/dist/remove-C2iv0g03.mjs

@@ -0,0 +1,98 @@
+import "./package-DV6Asqim.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { defineMetabaseCommand, outputFlags } from "./runtime-cwBS8wwK.mjs";
+import { parseId } from "./parse-id-B38zTlYs.mjs";
+import { promptConfirm } from "./prompt-Bf3DQ-qE.mjs";
+import "./poll-Bh6oAifO.mjs";
+import { checkDockerReady, containerNameFor, removeContainer, removeVolume, volumeNameFor } from "./docker-CHpV8PRz.mjs";
+import { z } from "zod";
+
+//#region src/commands/workspace/remove.ts
+const RemoveResult = z.object({
+	workspace_id: z.number().int().positive(),
+	container_name: z.string(),
+	volume_name: z.string(),
+	removed_container: z.boolean(),
+	removed_volume: z.boolean()
+});
+const removeResultView = {
+	compactPick: RemoveResult.pick({
+		workspace_id: true,
+		removed_container: true,
+		removed_volume: true
+	}).strip(),
+	tableColumns: [
+		{
+			key: "workspace_id",
+			label: "ID"
+		},
+		{
+			key: "container_name",
+			label: "Container"
+		},
+		{
+			key: "volume_name",
+			label: "Volume"
+		},
+		{
+			key: "removed_container",
+			label: "Removed Container"
+		},
+		{
+			key: "removed_volume",
+			label: "Removed Volume"
+		}
+	]
+};
+var remove_default = defineMetabaseCommand({
+	meta: {
+		name: "remove",
+		description: "Stop and remove the local container + app-db volume (does not affect remote)"
+	},
+	args: {
+		...outputFlags,
+		id: {
+			type: "positional",
+			description: "Workspace id",
+			required: true
+		},
+		"keep-volume": {
+			type: "boolean",
+			description: "Keep the workspace's app-db volume (faster restart, app-db survives)",
+			default: false
+		},
+		yes: {
+			type: "boolean",
+			description: "Skip the confirmation prompt",
+			default: false
+		}
+	},
+	outputSchema: RemoveResult,
+	examples: ["metabase workspace remove 1 --yes", "metabase workspace remove 1 --keep-volume --yes"],
+	async run({ args, ctx }) {
+		const workspaceId = parseId(args.id);
+		const containerName = containerNameFor(workspaceId);
+		const volumeName = volumeNameFor(workspaceId);
+		const shouldRemoveVolume = args["keep-volume"] !== true;
+		await checkDockerReady();
+		if (!args.yes && process.stdin.isTTY === true) {
+			const confirmed = await promptConfirm({ message: shouldRemoveVolume ? `Remove container ${containerName} and its app-db volume ${volumeName}?` : `Remove container ${containerName}? (volume ${volumeName} will be kept)` });
+			if (!confirmed) return;
+		}
+		const removedContainer = await removeContainer(containerName);
+		const removedVolume = shouldRemoveVolume ? await removeVolume(volumeName) : false;
+		const result = {
+			workspace_id: workspaceId,
+			container_name: containerName,
+			volume_name: volumeName,
+			removed_container: removedContainer,
+			removed_volume: removedVolume
+		};
+		renderItem(result, removeResultView, ctx);
+	}
+});
+
+//#endregion
+export { remove_default as default };

package/dist/remove-collection-DhZghaZy.mjs

@@ -0,0 +1,38 @@
+import "./package-DV6Asqim.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-cwBS8wwK.mjs";
+import { parseId } from "./parse-id-B38zTlYs.mjs";
+import "./poll-task-vPwV31Fs.mjs";
+import "./poll-Bh6oAifO.mjs";
+import { SyncSettingsUpdateResult, setCollectionRemoteSynced, syncSettingsUpdateView } from "./add-collection-DwxQDXzL.mjs";
+
+//#region src/commands/git-sync/remove-collection.ts
+var remove_collection_default = defineMetabaseCommand({
+	meta: {
+		name: "remove-collection",
+		description: "Unmark a collection as git-synced; cascades to descendants by location prefix"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		id: {
+			type: "positional",
+			description: "Collection id (positive integer)",
+			required: true
+		}
+	},
+	outputSchema: SyncSettingsUpdateResult,
+	examples: ["metabase git-sync remove-collection 12", "metabase git-sync remove-collection 12 --json --profile prod"],
+	async run({ args, ctx, getClient }) {
+		const collectionId = parseId(args.id, "id");
+		const client = await getClient();
+		const result = await setCollectionRemoteSynced(client, collectionId, false);
+		renderItem(result, syncSettingsUpdateView, ctx);
+	}
+});
+
+//#endregion
+export { remove_collection_default as default };

package/dist/{remove-B2hVYn1v.mjs → remove-xskleeru.mjs}

@@ -1,7 +1,9 @@
-import "./package-BGfw4ZWJ.mjs";
+import "./package-DV6Asqim.mjs";
 import "./command-augment-D9pI9Vbh.mjs";
-import { ConfigError, clearLicense, defineMetabaseCommand, outputFlags, renderItem } from "./runtime-C9CEZhcn.mjs";
-import { promptConfirm } from "./prompt-DpT8yAVy.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { clearLicense, defineMetabaseCommand, outputFlags } from "./runtime-cwBS8wwK.mjs";
+import { promptConfirm } from "./prompt-Bf3DQ-qE.mjs";
 import { z } from "zod";
 
 //#region src/commands/license/remove.ts
@@ -35,8 +37,7 @@ var remove_default = defineMetabaseCommand({
 	outputSchema: LicenseRemoveResult,
 	examples: ["metabase license remove --yes"],
 	async run({ args, ctx }) {
-		if (!args.yes) {
-			if (!process.stdin.isTTY) throw new ConfigError("--yes required to remove license non-interactively");
+		if (!args.yes && process.stdin.isTTY === true) {
 			const ok = await promptConfirm({
 				message: "Remove stored license token?",
 				initialValue: false

package/dist/render-DXv-D6fU.mjs

@@ -0,0 +1,182 @@
+import { ConfigError, isPlainObject } from "./predicates-DiIiS3k7.mjs";
+import Table from "cli-table3";
+
+//#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/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/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;
+		}
+	}
+}
+
+//#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 writeJson(value) {
+	process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}
+function writeText(text) {
+	process.stdout.write(text + "\n");
+}
+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
+export { renderItem, renderList, warn, writeJson, writeText };

package/dist/rescan-values-DW6u90ep.mjs

@@ -0,0 +1,43 @@
+import "./package-DV6Asqim.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-cwBS8wwK.mjs";
+import { parseId } from "./parse-id-B38zTlYs.mjs";
+import "./field-B3gvaqpK.mjs";
+import "./table-B-PYcgGb.mjs";
+import { DatabaseSyncResult, databaseSyncResultView } from "./database-vvig8k4x.mjs";
+import { z } from "zod";
+
+//#region src/commands/db/rescan-values.ts
+const RescanValuesApiResponse = z.object({ status: z.literal("ok") });
+var rescan_values_default = defineMetabaseCommand({
+	meta: {
+		name: "rescan-values",
+		description: "Trigger a rescan of cached field values for a database"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		id: {
+			type: "positional",
+			description: "Database id",
+			required: true
+		}
+	},
+	outputSchema: DatabaseSyncResult,
+	examples: ["metabase db rescan-values 1", "metabase db rescan-values 1 --json"],
+	async run({ args, ctx, getClient }) {
+		const id = parseId(args.id);
+		const client = await getClient();
+		const response = await client.requestParsed(RescanValuesApiResponse, `/api/database/${id}/rescan_values`, { method: "POST" });
+		renderItem({
+			id,
+			status: response.status
+		}, databaseSyncResultView, ctx);
+	}
+});
+
+//#endregion
+export { rescan_values_default as default };

package/dist/revision-message-flag-CWQbKhdl.mjs

@@ -0,0 +1,11 @@
+//#region src/commands/revision-message-flag.ts
+const DEFAULT_ARCHIVE_REVISION_MESSAGE = "Archived via metabase CLI";
+const revisionMessageFlag = { revisionMessage: {
+	type: "string",
+	description: "Audit-log message recorded with the change",
+	alias: "revision-message",
+	default: DEFAULT_ARCHIVE_REVISION_MESSAGE
+} };
+
+//#endregion
+export { revisionMessageFlag };

package/dist/{run-C2so6Qp6.mjs → run-DxVzhcF3.mjs}

@@ -1,9 +1,12 @@
-import "./package-BGfw4ZWJ.mjs";
+import "./package-DV6Asqim.mjs";
 import "./command-augment-D9pI9Vbh.mjs";
-import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag, renderItem } from "./runtime-C9CEZhcn.mjs";
-import { parseId } from "./parse-id-BhmmfyCP.mjs";
-import { DEFAULT_INTERVAL_MS, DEFAULT_TIMEOUT_MS, pollUntil } from "./poll-ILanYysl.mjs";
-import { TransformRun } from "./transform-B5uRpg1G.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-cwBS8wwK.mjs";
+import { parseId } from "./parse-id-B38zTlYs.mjs";
+import { pollUntil } from "./poll-Bh6oAifO.mjs";
+import { TransformRun } from "./transform-IEX4Mx3X.mjs";
+import { parseWaitFlags, waitFlags } from "./wait-flags-CjX2sEGm.mjs";
 import { z } from "zod";
 
 //#region src/commands/transform/run.ts
@@ -25,9 +28,9 @@ const TransformRunKickoff = z.object({
 const TransformRunResult = z.object({
 	message: z.string(),
 	run_id: z.number().int().positive().nullable(),
-	final: TransformRun.nullable().optional()
+	final: TransformRun.nullable()
 });
-const transformRunView = {
+const transformRunResultView = {
 	compactPick: TransformRunResult,
 	tableColumns: [{
 		key: "run_id",
@@ -46,21 +49,7 @@ var run_default = defineMetabaseCommand({
 		...outputFlags,
 		...profileFlag,
 		...connectionFlags,
-		wait: {
-			type: "boolean",
-			description: "Poll until the run reaches a terminal status",
-			default: false
-		},
-		timeout: {
-			type: "string",
-			description: "Polling timeout in ms (used with --wait)",
-			default: String(DEFAULT_TIMEOUT_MS)
-		},
-		interval: {
-			type: "string",
-			description: "Polling interval in ms (used with --wait)",
-			default: String(DEFAULT_INTERVAL_MS)
-		},
+		...waitFlags,
 		id: {
 			type: "positional",
 			description: "Transform id",
@@ -71,31 +60,33 @@ var run_default = defineMetabaseCommand({
 	examples: ["metabase transform run 1", "metabase transform run 1 --wait --json"],
 	async run({ args, ctx, getClient }) {
 		const id = parseId(args.id);
+		const wait = parseWaitFlags(args);
 		const client = await getClient();
 		const kickoff = await client.requestParsed(TransformRunKickoff, `/api/transform/${id}/run`, { method: "POST" });
-		if (!args.wait || kickoff.run_id === null) {
+		if (!wait.enabled) {
 			renderItem({
 				message: kickoff.message,
-				run_id: kickoff.run_id
-			}, transformRunView, ctx);
+				run_id: kickoff.run_id,
+				final: null
+			}, transformRunResultView, ctx);
 			return;
 		}
-		const intervalMs = parseId(args.interval, "interval");
-		const timeoutMs = parseId(args.timeout, "timeout");
+		if (kickoff.run_id === null) {
+			renderItem({
+				message: kickoff.message,
+				run_id: null,
+				final: null
+			}, transformRunResultView, ctx);
+			throw new Error(`transform run did not start: ${kickoff.message}`);
+		}
 		const runId = kickoff.run_id;
-		const final = await pollUntil(async () => client.requestParsed(TransformRun, `/api/transform/run/${runId}`), (run) => RUN_TERMINAL_STATUSES.has(run.status), {
-			intervalMs,
-			timeoutMs
-		});
+		const final = await pollUntil(async () => client.requestParsed(TransformRun, `/api/transform/run/${runId}`), (run) => RUN_TERMINAL_STATUSES.has(run.status), wait.schedule);
 		renderItem({
 			message: kickoff.message,
 			run_id: runId,
 			final
-		}, transformRunView, ctx);
-		if (RUN_FAILURE_STATUSES.has(final.status)) {
-			const detail = final.message ? `: ${final.message}` : "";
-			throw new Error(`transform run ${runId} ${final.status}${detail}`);
-		}
+		}, transformRunResultView, ctx);
+		if (RUN_FAILURE_STATUSES.has(final.status)) throw new Error(`transform run ${runId} ${final.status}`);
 	}
 });
 

package/dist/runs-BOHk1XnM.mjs

@@ -0,0 +1,54 @@
+import "./package-DV6Asqim.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderList } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { connectionFlags, defineMetabaseCommand, listEnvelopeSchema, outputFlags, profileFlag } from "./runtime-cwBS8wwK.mjs";
+import { parseId } from "./parse-id-B38zTlYs.mjs";
+import { collectPaginated } from "./paginate-CTSfuYiF.mjs";
+import { TransformRun, TransformRunCompact, transformRunView } from "./transform-IEX4Mx3X.mjs";
+
+//#region src/commands/transform/runs.ts
+const TransformRunListEnvelope = listEnvelopeSchema(TransformRunCompact);
+var runs_default = defineMetabaseCommand({
+	meta: {
+		name: "runs",
+		description: "List recent transform runs"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		"transform-id": {
+			type: "string",
+			description: "Filter to runs of a single transform id"
+		},
+		limit: {
+			type: "string",
+			description: "Cap total runs returned (default: drain all pages)"
+		}
+	},
+	outputSchema: TransformRunListEnvelope,
+	examples: [
+		"metabase transform runs",
+		"metabase transform runs --transform-id 1 --json",
+		"metabase transform runs --limit 10 --json"
+	],
+	async run({ args, ctx, getClient }) {
+		const transformId = args["transform-id"] === void 0 ? void 0 : parseId(args["transform-id"], "--transform-id");
+		const max = args.limit === void 0 ? void 0 : parseId(args.limit, "--limit");
+		const client = await getClient();
+		const items = await collectPaginated(client, "/api/transform/run", TransformRun, {
+			query: { "transform-ids": transformId },
+			...max !== void 0 && { max }
+		});
+		const envelope = {
+			data: items,
+			returned: items.length,
+			...max === void 0 ? { total: items.length } : { limit: max }
+		};
+		renderList(envelope, transformRunView, ctx);
+	}
+});
+
+//#endregion
+export { runs_default as default };