@metabase/cli 0.1.6 → 0.1.8-alpha.cleanup-workspaces.75fe1d5

package/dist/start-3PX3ahjT.mjs

@@ -1,413 +0,0 @@
-import { ConfigError, errorMessage } from "./command-augment-BH9qgQ5u.mjs";
-import { connectionFlags, outputFlags, profileFlag } from "./error-C9S6PN3-.mjs";
-import { createClient, defineMetabaseCommand, localUrl, parseInteger, parseOptionalInteger, resolveLicenseToken } from "./runtime-Dmv5VtUK.mjs";
-import { warn } from "./capabilities-7e9MgquN.mjs";
-import { renderItem } from "./render-CfznwleY.mjs";
-import { parseId } from "./parse-id-lk_K-CEF.mjs";
-import { pollUntil } from "./poll-DHKDpCiq.mjs";
-import "./yaml-YTQiYJ9s.mjs";
-import { runProcess } from "./process-C7V8LJ-j.mjs";
-import { Workspace } from "./workspace-BBXJczJK.mjs";
-import { CONTAINER_REPO_DIR, checkDockerReady, containerLifecycleStatus, containerNameFor, pullImage, removeContainer, runWorkspaceContainer, scrubContainerConfig, waitForConfigConsumed } from "./docker-Oq80q3tu.mjs";
-import { REPO_SYNC_MODES, RepoSyncMode, buildCredentialsJson, generateWorkspaceCredentials, injectCredentialsIntoConfig, injectRepoSettingsIntoConfig } from "./workspace-credentials-BXpABsNZ.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
-		};
-		renderItem(result, startResultView, 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-CEplmC44.mjs

@@ -1,34 +0,0 @@
-import "./command-augment-BH9qgQ5u.mjs";
-import { outputFlags } from "./error-C9S6PN3-.mjs";
-import { defineMetabaseCommand, readLicense } from "./runtime-Dmv5VtUK.mjs";
-import "./capabilities-7e9MgquN.mjs";
-import { renderScalar } from "./render-CfznwleY.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.";
-		renderScalar({ present }, licenseStatusView, summary, ctx);
-	}
-});
-
-//#endregion
-export { status_default as default };

package/dist/stop-CQ0XGrN8.mjs

@@ -1,83 +0,0 @@
-import "./command-augment-BH9qgQ5u.mjs";
-import { outputFlags } from "./error-C9S6PN3-.mjs";
-import { defineMetabaseCommand } from "./runtime-Dmv5VtUK.mjs";
-import "./capabilities-7e9MgquN.mjs";
-import { renderItem } from "./render-CfznwleY.mjs";
-import { parseId } from "./parse-id-lk_K-CEF.mjs";
-import "./poll-DHKDpCiq.mjs";
-import "./process-C7V8LJ-j.mjs";
-import { checkDockerReady, containerLifecycleStatus, containerNameFor, stopContainer } from "./docker-Oq80q3tu.mjs";
-import { LocalWorkspaceState } from "./ps-CJU0EbrC.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
-		};
-		renderItem(result, stopResultView, ctx);
-	}
-});
-
-//#endregion
-export { stop_default as default };

package/dist/table-e6h8SLVX.mjs

@@ -1,20 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/table/index.ts
-var table_default = defineCommand({
-	meta: {
-		name: "table",
-		alias: "tables",
-		description: "Manage Metabase tables"
-	},
-	subCommands: {
-		list: () => import("./list-sD5N3fGk.mjs").then((m) => m.default),
-		get: () => import("./get-C_w1kvN3.mjs").then((m) => m.default),
-		metadata: () => import("./metadata-DqiI2q9q.mjs").then((m) => m.default),
-		fields: () => import("./fields-CoQi99gv.mjs").then((m) => m.default),
-		update: () => import("./update-_QfgNa53.mjs").then((m) => m.default)
-	}
-});
-
-//#endregion
-export { table_default as default };

package/dist/transform-BMYh1lsC.mjs

@@ -1,25 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/transform/index.ts
-var transform_default = defineCommand({
-	meta: {
-		name: "transform",
-		alias: "transforms",
-		description: "Manage Metabase transforms"
-	},
-	subCommands: {
-		list: () => import("./list-C3hfovHv.mjs").then((mod) => mod.default),
-		get: () => import("./get-C2p383Qc.mjs").then((mod) => mod.default),
-		create: () => import("./create-BYlIju0b.mjs").then((mod) => mod.default),
-		update: () => import("./update-mYVnoYNV.mjs").then((mod) => mod.default),
-		delete: () => import("./delete-ZjnV35OJ.mjs").then((mod) => mod.default),
-		"delete-table": () => import("./delete-table-agZJpivt.mjs").then((mod) => mod.default),
-		run: () => import("./run-B4Wn43zm.mjs").then((mod) => mod.default),
-		cancel: () => import("./cancel-Dl_Ho056.mjs").then((mod) => mod.default),
-		"get-run": () => import("./get-run-B7sKdaDU.mjs").then((mod) => mod.default),
-		runs: () => import("./runs-Bbaszr18.mjs").then((mod) => mod.default)
-	}
-});
-
-//#endregion
-export { transform_default as default };

package/dist/transform-job-Cm7z5TfH.mjs

@@ -1,20 +0,0 @@
-import { defineCommand } from "citty";
-
-//#region src/commands/transform-job/index.ts
-var transform_job_default = defineCommand({
-	meta: {
-		name: "transform-job",
-		alias: "transform-jobs",
-		description: "Manage Metabase transform jobs"
-	},
-	subCommands: {
-		list: () => import("./list-d58BprgJ.mjs").then((mod) => mod.default),
-		get: () => import("./get-Hc93A0Yz.mjs").then((mod) => mod.default),
-		create: () => import("./create-CzzrbL0u.mjs").then((mod) => mod.default),
-		update: () => import("./update-DSgceARZ.mjs").then((mod) => mod.default),
-		delete: () => import("./delete-Dimc-2y8.mjs").then((mod) => mod.default)
-	}
-});
-
-//#endregion
-export { transform_job_default as default };

package/dist/update-DHZubok3.mjs

@@ -1,77 +0,0 @@
-import "./command-augment-BH9qgQ5u.mjs";
-import { connectionFlags, outputFlags, profileFlag } from "./error-C9S6PN3-.mjs";
-import { defineMetabaseCommand } from "./runtime-Dmv5VtUK.mjs";
-import "./capabilities-7e9MgquN.mjs";
-import { renderItem } from "./render-CfznwleY.mjs";
-import "./input-cMSEqISy.mjs";
-import { parseId } from "./parse-id-lk_K-CEF.mjs";
-import { readBody } from "./body-DjdFxjpg.mjs";
-import { bodyInputFlags } from "./body-flags-D7q87Btw.mjs";
-import "./poll-DHKDpCiq.mjs";
-import { parseWaitFlags, waitFlags } from "./wait-flags-Dzq9BGQY.mjs";
-import { Workspace, WorkspaceUpdateDatabaseInput, workspaceView } from "./workspace-BBXJczJK.mjs";
-import { waitForDatabaseProvisioned } from "./wait-8yV9_WIo.mjs";
-import { parseSchemasCsv } from "./parse-schemas-BqUdWUwq.mjs";
-
-//#region src/commands/workspace/database/update.ts
-var update_default = defineMetabaseCommand({
-	meta: {
-		name: "update",
-		description: "Update a workspace's database (deprovisions then re-provisions with new input schemas)"
-	},
-	capabilities: {
-		minVersion: 62,
-		tokenFeature: "workspaces"
-	},
-	args: {
-		...outputFlags,
-		...profileFlag,
-		...connectionFlags,
-		...bodyInputFlags,
-		...waitFlags,
-		schemas: {
-			type: "string",
-			description: "Comma-separated input schemas (alternative to --body / --file)"
-		},
-		id: {
-			type: "positional",
-			description: "Workspace id",
-			required: true
-		},
-		"db-id": {
-			type: "positional",
-			description: "Database id",
-			required: true
-		}
-	},
-	outputSchema: Workspace,
-	examples: [
-		"mb workspace database update 1 5 --schemas analytics,github",
-		"mb workspace database update 1 5 --schemas analytics --wait",
-		"mb workspace database update 1 5 --file update.json"
-	],
-	async run({ args, ctx, getClient }) {
-		const workspaceId = parseId(args.id);
-		const databaseId = parseId(args["db-id"], "db-id");
-		const schemasFlag = args.schemas;
-		const wait = parseWaitFlags(args);
-		let body;
-		if (schemasFlag !== void 0 && schemasFlag !== "") {
-			const input_schemas = parseSchemasCsv(schemasFlag);
-			body = WorkspaceUpdateDatabaseInput.parse({ input_schemas });
-		} else body = await readBody({
-			flag: args.body,
-			file: args.file
-		}, WorkspaceUpdateDatabaseInput);
-		const client = await getClient();
-		const initial = await client.requestParsed(Workspace, `/api/ee/workspace-manager/${workspaceId}/database/${databaseId}`, {
-			method: "PUT",
-			body
-		});
-		const final = wait.enabled ? await waitForDatabaseProvisioned(client, workspaceId, databaseId, wait.schedule) : initial;
-		renderItem(final, workspaceView, ctx);
-	}
-});
-
-//#endregion
-export { update_default as default };