@metabase/cli 0.1.8 → 0.1.9

package/dist/start-B7ByBicB.mjs

@@ -1,414 +0,0 @@
-import { ConfigError, errorMessage } from "./command-augment-BH9qgQ5u.mjs";
-import { connectionFlags, outputFlags, profileFlag } from "./error-CTVL5CdB.mjs";
-import { createClient, defineMetabaseCommand, localUrl, parseInteger, parseOptionalInteger, resolveLicenseToken } from "./runtime-B40L_bj8.mjs";
-import { warn } from "./capabilities-7e9MgquN.mjs";
-import { renderSummary } from "./render-0_GsapXa.mjs";
-import { parseId } from "./parse-id-D1LTTt9L.mjs";
-import { pollUntil } from "./poll-DxpnK1wW.mjs";
-import "./yaml-Gv6wRFMF.mjs";
-import { runProcess } from "./process-CM7Uu5q_.mjs";
-import { Workspace } from "./workspace-D8HtUN0y.mjs";
-import { CONTAINER_REPO_DIR, checkDockerReady, containerLifecycleStatus, containerNameFor, pullImage, removeContainer, runWorkspaceContainer, scrubContainerConfig, waitForConfigConsumed } from "./docker-B-QQWThD.mjs";
-import { REPO_SYNC_MODES, RepoSyncMode, buildCredentialsJson, generateWorkspaceCredentials, injectCredentialsIntoConfig, injectRepoSettingsIntoConfig } from "./workspace-credentials-8CBMQJFz.mjs";
-import { z } from "zod";
-import { resolve } from "node:path";
-import { stat } from "node:fs/promises";
-import { createServer } from "node:net";
-
-//#region src/core/http/probe.ts
-async function probeHealth(url, timeoutMs) {
-	try {
-		const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
-		return {
-			ready: response.ok,
-			status: response.status
-		};
-	} catch (error) {
-		if (error instanceof Error) return {
-			ready: false,
-			status: null
-		};
-		throw error;
-	}
-}
-
-//#endregion
-//#region src/runtime/port.ts
-const PORT_SCAN_LIMIT = 100;
-function isPortFree(port) {
-	return new Promise((resolve$1) => {
-		const server = createServer();
-		server.unref();
-		server.once("error", () => resolve$1(false));
-		server.once("listening", () => {
-			server.close(() => resolve$1(true));
-		});
-		server.listen(port, "0.0.0.0");
-	});
-}
-async function findFreePort(start) {
-	for (let port = start; port < start + PORT_SCAN_LIMIT; port++) if (await isPortFree(port)) return port;
-	throw new ConfigError(`no free port in range ${start}..${start + PORT_SCAN_LIMIT - 1}`);
-}
-
-//#endregion
-//#region src/commands/workspace/start.ts
-const ENTERPRISE_IMAGE = "metabase/metabase-enterprise";
-const ENTERPRISE_HEAD_IMAGE = "metabase/metabase-enterprise-head";
-const LATEST_TAG = "latest";
-const WORKSPACES_MIN_VERSION = 62;
-const DEFAULT_HOST_PORT = 3e3;
-const DEFAULT_READY_TIMEOUT_MS = 24e4;
-const HEALTH_INTERVAL_MS = 2e3;
-const HEALTH_MAX_INTERVAL_MS = 1e4;
-const HEALTH_PROBE_TIMEOUT_MS = 4e3;
-const DEFAULT_REPO_MODE = "read-write";
-const REPO_FILE_URL = `file://${CONTAINER_REPO_DIR}`;
-const METADATA_IMPORT_TIMEOUT_MS = DEFAULT_READY_TIMEOUT_MS;
-const METADATA_POLL_INTERVAL_MS = 250;
-const METADATA_POLL_MAX_INTERVAL_MS = 5e3;
-const MetadataImportEnqueued = z.object({
-	queued: z.literal(true),
-	"import-id": z.string()
-});
-const MetadataImportStatus = z.object({
-	id: z.string(),
-	status: z.enum([
-		"queued",
-		"running",
-		"ok",
-		"error"
-	]),
-	"enqueued-at": z.string(),
-	"started-at": z.string().nullable(),
-	"finished-at": z.string().nullable(),
-	"wall-ms": z.number().nullable(),
-	error: z.string().nullable()
-});
-const StartResult = z.object({
-	workspace_id: z.number().int().positive(),
-	workspace_name: z.string(),
-	container_name: z.string(),
-	state: z.enum(["running", "starting"]),
-	host_port: z.number().int().positive(),
-	url: z.string(),
-	image: z.string()
-});
-const startResultView = {
-	compactPick: StartResult.pick({
-		workspace_id: true,
-		workspace_name: true,
-		state: true,
-		url: true
-	}).strip(),
-	tableColumns: [
-		{
-			key: "workspace_id",
-			label: "ID"
-		},
-		{
-			key: "workspace_name",
-			label: "Name"
-		},
-		{
-			key: "state",
-			label: "State"
-		},
-		{
-			key: "url",
-			label: "URL"
-		}
-	]
-};
-var start_default = defineMetabaseCommand({
-	meta: {
-		name: "start",
-		description: "Start a local Docker container that serves as the workspace's dev instance"
-	},
-	capabilities: {
-		minVersion: WORKSPACES_MIN_VERSION,
-		tokenFeature: "workspaces"
-	},
-	args: {
-		...outputFlags,
-		...profileFlag,
-		...connectionFlags,
-		id: {
-			type: "positional",
-			description: "Workspace id",
-			required: true
-		},
-		port: {
-			type: "string",
-			description: `Host port to bind (default: ${DEFAULT_HOST_PORT}; auto-shifts up when this flag is omitted, fails on collision when set explicitly)`
-		},
-		image: {
-			type: "string",
-			description: `Docker image to run. Default: ${ENTERPRISE_IMAGE}:${LATEST_TAG} once Metabase v${WORKSPACES_MIN_VERSION} is released, otherwise ${ENTERPRISE_HEAD_IMAGE}:${LATEST_TAG}.`
-		},
-		wait: {
-			type: "boolean",
-			description: "Block until /api/health is ready before returning. Default: return as soon as the container has consumed config.yml. (Implied when --metadata is on, since the import requires a live API.)",
-			default: false
-		},
-		timeout: {
-			type: "string",
-			description: `Per-phase readiness deadline in ms — covers post-create config consumption, (with --wait) the /api/health probe, and (with --metadata) the metadata-import status poll. Default: ${DEFAULT_READY_TIMEOUT_MS}.`,
-			default: String(DEFAULT_READY_TIMEOUT_MS)
-		},
-		pull: {
-			type: "boolean",
-			description: "Pull the image before starting",
-			default: true
-		},
-		metadata: {
-			type: "boolean",
-			description: "Fetch the workspace's warehouse metadata from the parent and POST it to the child instance once it is healthy",
-			default: true
-		},
-		force: {
-			type: "boolean",
-			description: "Remove and recreate the container even if it is running. Stopped containers (exited/created/dead) are recreated automatically without this flag.",
-			default: false
-		},
-		repo: {
-			type: "string",
-			description: `Bind-mount a host directory (typically a remote-sync git repo) into the container at ${CONTAINER_REPO_DIR}. Sets remote-sync-url=${REPO_FILE_URL} in the workspace config.yml so the child boots already wired to the repo.`
-		},
-		"repo-branch": {
-			type: "string",
-			description: "Branch to set as remote-sync-branch (default: the current branch of the host repo, read from HEAD)"
-		},
-		"repo-mode": {
-			type: "string",
-			description: "remote-sync-type: 'read-write' (default) or 'read-only'",
-			default: DEFAULT_REPO_MODE
-		}
-	},
-	outputSchema: StartResult,
-	examples: [
-		"mb workspace start 1",
-		"mb workspace start 1 --wait",
-		"mb workspace start 1 --port 3100",
-		"mb workspace start 1 --image metabase/metabase-enterprise:latest --no-pull",
-		"mb workspace start 1 --force",
-		"mb workspace start 1 --repo /path/to/sync-repo --wait",
-		"mb workspace start 1 --repo /path/to/sync-repo --repo-branch dev --repo-mode read-only"
-	],
-	async run({ args, ctx, getClient, getResolvedConfig, getServerInfo }) {
-		const workspaceId = parseId(args.id);
-		const containerName = containerNameFor(workspaceId);
-		const requestedPort = parseOptionalInteger(args.port, {
-			name: "--port",
-			min: 1
-		});
-		const readyTimeoutMs = parseInteger(args.timeout ?? String(DEFAULT_READY_TIMEOUT_MS), {
-			name: "--timeout",
-			min: 1e3
-		});
-		const client = await getClient();
-		const resolved = await getResolvedConfig();
-		const licenseToken = await resolveLicenseToken({});
-		const serverInfo = await getServerInfo();
-		const image = args.image ?? resolveDefaultImage(serverInfo?.version ?? null);
-		await checkDockerReady();
-		await ensureNoExistingContainer(workspaceId, containerName, args.force);
-		const pullPromise = args.pull ? pullImage(image) : Promise.resolve();
-		const workspace = await client.requestParsed(Workspace, `/api/ee/workspace-manager/${workspaceId}`);
-		assertAllDatabasesProvisioned(workspace);
-		const hostPort = await resolveHostPort(requestedPort);
-		const [parentConfigYaml, metadataJson, repoOptions] = await Promise.all([
-			fetchConfigYaml(client, workspaceId),
-			args.metadata ? fetchMetadataJson(client, workspaceId) : Promise.resolve(null),
-			resolveRepoOptions({
-				hostPath: args.repo,
-				branch: args["repo-branch"],
-				mode: args["repo-mode"]
-			})
-		]);
-		const bundle = assembleBootBundle(parentConfigYaml, workspaceId, repoOptions);
-		await pullPromise;
-		await runWorkspaceContainer({
-			workspaceId,
-			workspaceName: workspace.name,
-			profile: resolved.profile,
-			parentUrl: resolved.url,
-			image,
-			hostPort,
-			configYaml: bundle.configYaml,
-			credentialsJson: bundle.credentialsJson,
-			licenseToken,
-			bindMounts: repoOptions === null ? [] : [repoOptions.bindMount]
-		});
-		const state = await finalizeContainer({
-			workspaceId,
-			hostPort,
-			credentials: bundle.credentials,
-			metadataJson,
-			wait: args.wait,
-			timeoutMs: readyTimeoutMs
-		});
-		const result = {
-			workspace_id: workspaceId,
-			workspace_name: workspace.name,
-			container_name: containerName,
-			state,
-			host_port: hostPort,
-			url: localUrl(hostPort),
-			image
-		};
-		const message = result.state === "running" ? `Workspace ${workspaceId} "${workspace.name}" is running at ${result.url}.` : `Workspace ${workspaceId} "${workspace.name}" is starting — container is up, instance still booting. Check \`mb workspace ps\` or rerun with --wait.`;
-		renderSummary(result, startResultView, message, ctx);
-	}
-});
-function resolveDefaultImage(version) {
-	const isReleased = version !== null && version.major >= WORKSPACES_MIN_VERSION;
-	const repo = isReleased ? ENTERPRISE_IMAGE : ENTERPRISE_HEAD_IMAGE;
-	return `${repo}:${LATEST_TAG}`;
-}
-function assertAllDatabasesProvisioned(workspace) {
-	const databases = workspace.databases ?? [];
-	if (databases.length === 0) throw new ConfigError(`workspace ${workspace.id} has no databases — provision at least one before starting`);
-	const unready = databases.filter((entry) => entry.status !== "provisioned");
-	if (unready.length > 0) {
-		const summary = unready.map((entry) => `database ${entry.database_id}=${entry.status}`).join(", ");
-		throw new ConfigError(`workspace ${workspace.id} is not ready: ${summary}. Wait for provisioning to finish.`);
-	}
-}
-async function ensureNoExistingContainer(workspaceId, containerName, force) {
-	if (force) {
-		await removeContainer(containerName);
-		return;
-	}
-	const status = await containerLifecycleStatus(containerName);
-	if (status === "missing") return;
-	if (status === "exited" || status === "created" || status === "dead") {
-		await removeContainer(containerName);
-		return;
-	}
-	throw new ConfigError(`container ${containerName} is currently ${status}. Run \`mb workspace stop ${workspaceId}\` first, or use --force to recreate it.`);
-}
-async function resolveHostPort(requested) {
-	if (requested !== null) {
-		if (!await isPortFree(requested)) throw new ConfigError(`port ${requested} is already in use`);
-		return requested;
-	}
-	if (await isPortFree(DEFAULT_HOST_PORT)) return DEFAULT_HOST_PORT;
-	return findFreePort(DEFAULT_HOST_PORT + 1);
-}
-async function fetchConfigYaml(client, workspaceId) {
-	const response = await client.requestRaw(`/api/ee/workspace-manager/${workspaceId}/config`, { expectContentType: "binary" });
-	return response.text();
-}
-async function fetchMetadataJson(client, workspaceId) {
-	const response = await client.requestRaw(`/api/ee/workspace-manager/${workspaceId}/metadata/export`, {
-		expectContentType: "binary",
-		query: {
-			"with-databases": true,
-			"with-tables": true,
-			"with-fields": true
-		}
-	});
-	return new Uint8Array(await response.arrayBuffer());
-}
-function assembleBootBundle(parentConfigYaml, workspaceId, repoOptions) {
-	const credentials = generateWorkspaceCredentials(workspaceId);
-	const withCredentials = injectCredentialsIntoConfig(parentConfigYaml, credentials);
-	const configYaml = repoOptions !== null ? injectRepoSettingsIntoConfig(withCredentials, repoOptions.repo) : withCredentials;
-	return {
-		configYaml,
-		credentialsJson: buildCredentialsJson(credentials),
-		credentials
-	};
-}
-async function finalizeContainer(input) {
-	await waitForConfigConsumed(input.workspaceId, input.timeoutMs);
-	try {
-		await scrubContainerConfig(input.workspaceId);
-	} catch (error) {
-		warn(`could not scrub in-container config.yml: ${errorMessage(error)}`);
-	}
-	const reachedHealth = input.wait || input.metadataJson !== null;
-	if (reachedHealth) await waitForHealth(input.hostPort, input.timeoutMs);
-	if (input.metadataJson !== null) await importMetadataIntoChild(input.hostPort, input.credentials, input.metadataJson, input.timeoutMs);
-	return reachedHealth ? "running" : "starting";
-}
-async function waitForHealth(hostPort, timeoutMs) {
-	const url = `${localUrl(hostPort)}/api/health`;
-	await pollUntil(() => probeHealth(url, HEALTH_PROBE_TIMEOUT_MS), (probe) => probe.ready, {
-		intervalMs: HEALTH_INTERVAL_MS,
-		maxIntervalMs: HEALTH_MAX_INTERVAL_MS,
-		backoff: "exponential",
-		timeoutMs
-	});
-}
-async function importMetadataIntoChild(hostPort, credentials, metadataJson, pollTimeoutMs) {
-	const childClient = createClient({
-		url: localUrl(hostPort),
-		apiKey: credentials.api_key.key
-	});
-	const enqueued = await childClient.requestParsed(MetadataImportEnqueued, "/api/ee/serialization/metadata/import", {
-		method: "POST",
-		body: metadataJson,
-		timeoutMs: METADATA_IMPORT_TIMEOUT_MS
-	});
-	const importId = enqueued["import-id"];
-	const final = await pollUntil(() => childClient.requestParsed(MetadataImportStatus, `/api/ee/serialization/metadata/import/${importId}`), (status) => status.status === "ok" || status.status === "error", {
-		intervalMs: METADATA_POLL_INTERVAL_MS,
-		maxIntervalMs: METADATA_POLL_MAX_INTERVAL_MS,
-		backoff: "exponential",
-		timeoutMs: pollTimeoutMs
-	});
-	if (final.status === "error") {
-		const detail = final.error !== null ? `: ${final.error}` : "";
-		throw new Error(`metadata import failed (id=${importId})${detail}`);
-	}
-}
-async function resolveRepoOptions(input) {
-	if (input.hostPath === void 0 || input.hostPath === "") {
-		const explicitBranch = input.branch !== void 0;
-		const explicitNonDefaultMode = input.mode !== void 0 && input.mode !== DEFAULT_REPO_MODE;
-		if (explicitBranch || explicitNonDefaultMode) throw new ConfigError("--repo-branch and --repo-mode require --repo to point at a host repo path");
-		return null;
-	}
-	const hostPath = resolve(input.hostPath);
-	const stats = await stat(hostPath).catch(() => null);
-	if (stats === null || !stats.isDirectory()) throw new ConfigError(`--repo path does not exist or is not a directory: ${hostPath}`);
-	const mode = parseRepoMode(input.mode);
-	const branch = input.branch ?? await detectBranch(hostPath);
-	return {
-		bindMount: {
-			hostPath,
-			containerPath: CONTAINER_REPO_DIR,
-			readOnly: mode === "read-only"
-		},
-		repo: {
-			url: REPO_FILE_URL,
-			branch,
-			mode
-		}
-	};
-}
-function parseRepoMode(raw) {
-	const result = RepoSyncMode.safeParse(raw ?? DEFAULT_REPO_MODE);
-	if (!result.success) throw new ConfigError(`invalid --repo-mode: "${raw}" (expected one of: ${REPO_SYNC_MODES.join(", ")})`);
-	return result.data;
-}
-async function detectBranch(hostPath) {
-	const result = await runProcess("git", [
-		"-C",
-		hostPath,
-		"symbolic-ref",
-		"--short",
-		"HEAD"
-	]).catch((error) => {
-		throw new ConfigError(`--repo-branch not provided and could not detect a branch at ${hostPath}: ${errorMessage(error)}`);
-	});
-	if (result.exitCode !== 0) throw new ConfigError(`--repo-branch not provided and \`git symbolic-ref\` at ${hostPath} failed: ${result.stderr.trim() || "no output"}`);
-	const branch = result.stdout.trim();
-	if (branch === "") throw new ConfigError(`--repo-branch not provided and HEAD at ${hostPath} resolved to an empty branch name`);
-	return branch;
-}
-
-//#endregion
-export { start_default as default };

package/dist/status-DAzD1Cn_.mjs

@@ -1,34 +0,0 @@
-import "./command-augment-BH9qgQ5u.mjs";
-import { outputFlags } from "./error-CTVL5CdB.mjs";
-import { defineMetabaseCommand, readLicense } from "./runtime-B40L_bj8.mjs";
-import "./capabilities-7e9MgquN.mjs";
-import { renderSummary } from "./render-0_GsapXa.mjs";
-import { z } from "zod";
-
-//#region src/commands/workspace/license/status.ts
-const LicenseStatus = z.object({ present: z.boolean() });
-const licenseStatusView = {
-	compactPick: LicenseStatus,
-	tableColumns: [{
-		key: "present",
-		label: "Present"
-	}]
-};
-var status_default = defineMetabaseCommand({
-	meta: {
-		name: "status",
-		description: "Show whether a license token is stored (does not reveal value)"
-	},
-	capabilities: null,
-	args: { ...outputFlags },
-	outputSchema: LicenseStatus,
-	examples: ["mb workspace license status", "mb workspace license status --json"],
-	async run({ ctx }) {
-		const present = await readLicense() !== null;
-		const summary = present ? "A license token is stored." : "No license token stored.";
-		renderSummary({ present }, licenseStatusView, summary, ctx);
-	}
-});
-
-//#endregion
-export { status_default as default };

package/dist/stop-Cvexagxh.mjs

@@ -1,87 +0,0 @@
-import "./command-augment-BH9qgQ5u.mjs";
-import { outputFlags } from "./error-CTVL5CdB.mjs";
-import { defineMetabaseCommand } from "./runtime-B40L_bj8.mjs";
-import "./capabilities-7e9MgquN.mjs";
-import { renderSummary } from "./render-0_GsapXa.mjs";
-import { parseId } from "./parse-id-D1LTTt9L.mjs";
-import "./poll-DxpnK1wW.mjs";
-import "./process-CM7Uu5q_.mjs";
-import { checkDockerReady, containerLifecycleStatus, containerNameFor, stopContainer } from "./docker-B-QQWThD.mjs";
-import { LocalWorkspaceState } from "./ps-dEqRGeB3.mjs";
-import { z } from "zod";
-
-//#region src/commands/workspace/stop.ts
-const StopResult = z.object({
-	workspace_id: z.number().int().positive(),
-	container_name: z.string(),
-	stopped: z.boolean(),
-	prior_state: LocalWorkspaceState.nullable()
-});
-const stopResultView = {
-	compactPick: StopResult.pick({
-		workspace_id: true,
-		stopped: true,
-		prior_state: true
-	}).strip(),
-	tableColumns: [
-		{
-			key: "workspace_id",
-			label: "ID"
-		},
-		{
-			key: "container_name",
-			label: "Container"
-		},
-		{
-			key: "stopped",
-			label: "Stopped"
-		},
-		{
-			key: "prior_state",
-			label: "Prior State"
-		}
-	]
-};
-var stop_default = defineMetabaseCommand({
-	meta: {
-		name: "stop",
-		description: "Stop the local Docker container for a workspace (does not remove it)"
-	},
-	capabilities: null,
-	args: {
-		...outputFlags,
-		id: {
-			type: "positional",
-			description: "Workspace id",
-			required: true
-		}
-	},
-	outputSchema: StopResult,
-	examples: ["mb workspace stop 1", "mb workspace stop 1 --json"],
-	async run({ args, ctx }) {
-		const workspaceId = parseId(args.id);
-		const containerName = containerNameFor(workspaceId);
-		await checkDockerReady();
-		const status = await containerLifecycleStatus(containerName);
-		const priorState = status === "missing" ? null : status;
-		let stopped = false;
-		if (status === "running") {
-			await stopContainer(containerName);
-			stopped = true;
-		}
-		const result = {
-			workspace_id: workspaceId,
-			container_name: containerName,
-			stopped,
-			prior_state: priorState
-		};
-		let message;
-		if (result.stopped) message = `Stopped workspace ${workspaceId} (container ${containerName}).`;
-		else if (result.prior_state !== null) message = `Workspace ${workspaceId} container is already ${result.prior_state} — nothing to stop.`;
-		else message = `No container found for workspace ${workspaceId} — nothing to stop.`;
-		renderSummary(result, stopResultView, message, ctx);
-	}
-});
-
-//#endregion
-export { stop_default as default };

package/dist/sync-schema-CrmVX1cy.mjs

@@ -1,44 +0,0 @@
-import "./command-augment-BH9qgQ5u.mjs";
-import { connectionFlags, outputFlags, profileFlag } from "./error-CTVL5CdB.mjs";
-import { defineMetabaseCommand } from "./runtime-B40L_bj8.mjs";
-import "./capabilities-7e9MgquN.mjs";
-import { renderSummary } from "./render-0_GsapXa.mjs";
-import "./field-E0IBy4Uw.mjs";
-import { parseId } from "./parse-id-D1LTTt9L.mjs";
-import "./table-qDD2kApF.mjs";
-import { DatabaseSyncResult, databaseSyncResultView } from "./database-BXiue1in.mjs";
-import { z } from "zod";
-
-//#region src/commands/db/sync-schema.ts
-const SyncSchemaApiResponse = z.object({ status: z.literal("ok") });
-var sync_schema_default = defineMetabaseCommand({
-	meta: {
-		name: "sync-schema",
-		description: "Trigger a manual schema sync for a database"
-	},
-	capabilities: { minVersion: 58 },
-	args: {
-		...outputFlags,
-		...profileFlag,
-		...connectionFlags,
-		id: {
-			type: "positional",
-			description: "Database id",
-			required: true
-		}
-	},
-	outputSchema: DatabaseSyncResult,
-	examples: ["mb db sync-schema 1", "mb db sync-schema 1 --json"],
-	async run({ args, ctx, getClient }) {
-		const id = parseId(args.id);
-		const client = await getClient();
-		const response = await client.requestParsed(SyncSchemaApiResponse, `/api/database/${id}/sync_schema`, { method: "POST" });
-		renderSummary({
-			id,
-			status: response.status
-		}, databaseSyncResultView, `Schema sync queued for database ${id}.`, ctx);
-	}
-});
-
-//#endregion
-export { sync_schema_default as default };

package/dist/table-B0fRQv91.mjs

@@ -1,19 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/table/index.ts
-var table_default = defineCommand({
-	meta: {
-		name: "table",
-		description: "Manage Metabase tables"
-	},
-	subCommands: {
-		list: () => import("./list-Brt4oKO7.mjs").then((m) => m.default),
-		get: () => import("./get-CICzGFSW.mjs").then((m) => m.default),
-		metadata: () => import("./metadata-B-GOcWqL.mjs").then((m) => m.default),
-		fields: () => import("./fields-Ck31lDz9.mjs").then((m) => m.default),
-		update: () => import("./update-CZEd_Eej.mjs").then((m) => m.default)
-	}
-});
-
-//#endregion
-export { table_default as default };

package/dist/transform-K_kp6Rdm.mjs

@@ -1,24 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/transform/index.ts
-var transform_default = defineCommand({
-	meta: {
-		name: "transform",
-		description: "Manage Metabase transforms"
-	},
-	subCommands: {
-		list: () => import("./list-bVlCwg8g.mjs").then((mod) => mod.default),
-		get: () => import("./get-BPOd0Rm8.mjs").then((mod) => mod.default),
-		create: () => import("./create-4EAGYVyp.mjs").then((mod) => mod.default),
-		update: () => import("./update-DPouQi4U.mjs").then((mod) => mod.default),
-		delete: () => import("./delete-CJqLgr6w.mjs").then((mod) => mod.default),
-		"delete-table": () => import("./delete-table-ZiJDpMFT.mjs").then((mod) => mod.default),
-		run: () => import("./run-DTsx8bLb.mjs").then((mod) => mod.default),
-		cancel: () => import("./cancel-BwtDQ2MR.mjs").then((mod) => mod.default),
-		"get-run": () => import("./get-run-DhM_PyVy.mjs").then((mod) => mod.default),
-		runs: () => import("./runs-CqfJIuh_.mjs").then((mod) => mod.default)
-	}
-});
-
-//#endregion
-export { transform_default as default };

package/dist/transform-job-CuNN8zgv.mjs

@@ -1,19 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/transform-job/index.ts
-var transform_job_default = defineCommand({
-	meta: {
-		name: "transform-job",
-		description: "Manage Metabase transform jobs"
-	},
-	subCommands: {
-		list: () => import("./list-fIV-P6wP.mjs").then((mod) => mod.default),
-		get: () => import("./get-pO0wiy1e.mjs").then((mod) => mod.default),
-		create: () => import("./create-Dd_Gyg_F.mjs").then((mod) => mod.default),
-		update: () => import("./update-DWn-nLPo.mjs").then((mod) => mod.default),
-		delete: () => import("./delete-Do1agSiL.mjs").then((mod) => mod.default)
-	}
-});
-
-//#endregion
-export { transform_job_default as default };