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

package/dist/manifest-wzEFG0JB.mjs

@@ -0,0 +1,124 @@
+import { getMetabaseAugment } from "./command-augment-D9pI9Vbh.mjs";
+import { defineCommand } from "citty";
+import { z } from "zod";
+
+//#region src/output/manifest.ts
+function writeManifest(manifest) {
+	process.stdout.write(JSON.stringify(manifest, null, 2) + "\n");
+}
+
+//#endregion
+//#region src/runtime/manifest.ts
+const ManifestArg = z.object({
+	name: z.string(),
+	type: z.enum([
+		"string",
+		"boolean",
+		"positional",
+		"enum"
+	]),
+	required: z.boolean(),
+	description: z.string().optional(),
+	default: z.union([
+		z.string(),
+		z.boolean(),
+		z.number()
+	]).optional(),
+	alias: z.array(z.string()).optional(),
+	options: z.array(z.string()).optional()
+});
+const ManifestEntry = z.object({
+	command: z.string(),
+	description: z.string(),
+	examples: z.array(z.string()),
+	args: z.array(ManifestArg),
+	outputSchema: z.unknown().nullable()
+});
+const Manifest = z.object({
+	version: z.literal(1),
+	commands: z.array(ManifestEntry)
+});
+async function buildManifest(root) {
+	return {
+		version: 1,
+		commands: await walk(root, [])
+	};
+}
+async function walk(cmd, path) {
+	const meta = await resolveCitty(cmd.meta);
+	if (meta?.hidden === true) return [];
+	const subCommands = await resolveCitty(cmd.subCommands);
+	if (subCommands && Object.keys(subCommands).length > 0) {
+		const groups = await Promise.all(Object.entries(subCommands).map(async ([name, lazy]) => {
+			const sub = await resolveCitty(lazy);
+			return sub ? walk(sub, [...path, name]) : [];
+		}));
+		return groups.flat();
+	}
+	const args = await resolveCitty(cmd.args) ?? {};
+	const augment = getMetabaseAugment(cmd);
+	return [{
+		command: path.join(" "),
+		description: readDescription(meta),
+		examples: augment ? Array.from(augment.examples) : [],
+		args: convertArgs(args),
+		outputSchema: augment?.outputSchema ? z.toJSONSchema(augment.outputSchema) : null
+	}];
+}
+function readDescription(meta) {
+	if (meta === void 0) return "";
+	return typeof meta.description === "string" ? meta.description : "";
+}
+function convertArgs(args) {
+	return Object.entries(args).map(([name, def]) => convertArg(name, def));
+}
+function convertArg(name, def) {
+	const arg = {
+		name,
+		type: def.type ?? "string",
+		required: def.required === true && def.default === void 0
+	};
+	if (def.description) arg.description = def.description;
+	if (isPrimitiveDefault(def.default)) arg.default = def.default;
+	const alias = readAlias(def);
+	if (alias.length > 0) arg.alias = alias;
+	const options = readOptions(def);
+	if (options.length > 0) arg.options = options;
+	return arg;
+}
+function readOptions(def) {
+	if (!("options" in def) || !Array.isArray(def.options)) return [];
+	return [...def.options];
+}
+function readAlias(def) {
+	if (!("alias" in def) || def.alias === void 0) return [];
+	return Array.isArray(def.alias) ? def.alias : [def.alias];
+}
+function isPrimitiveDefault(value) {
+	return typeof value === "string" || typeof value === "boolean" || typeof value === "number";
+}
+async function resolveCitty(value) {
+	if (value === void 0) return void 0;
+	if (typeof value === "function") return value();
+	return value;
+}
+
+//#endregion
+//#region src/commands/manifest.ts
+function createManifestCommand(root) {
+	return defineCommand({
+		meta: {
+			name: "__manifest",
+			description: "Emit machine-readable command manifest as JSON (for agents)",
+			hidden: true
+		},
+		args: {},
+		async run() {
+			const manifest = await buildManifest(root);
+			writeManifest(manifest);
+		}
+	});
+}
+
+//#endregion
+export { createManifestCommand };

package/dist/package-t8dKf4m_.mjs

@@ -0,0 +1,73 @@
+//#region package.json
+var name = "@metabase/cli";
+var version = "0.1.0-alpha.workspaces-commands.818a8f1";
+var description = "Metabase CLI";
+var license = "AGPL-3.0";
+var repository = {
+	"type": "git",
+	"url": "git+https://github.com/metabase/mb-cli.git"
+};
+var bin = { "metabase": "./dist/cli.mjs" };
+var files = ["dist"];
+var type = "module";
+var publishConfig = {
+	"access": "public",
+	"registry": "https://registry.npmjs.org/"
+};
+var scripts = {
+	"build": "tsdown",
+	"dev": "tsdown --watch",
+	"start": "node dist/cli.mjs",
+	"test": "vitest run --project unit",
+	"test:watch": "vitest --project unit",
+	"test:e2e": "vitest run --project e2e",
+	"test:e2e:watch": "vitest --project e2e",
+	"e2e:up": "docker compose -f tests/e2e/docker-compose.yml up -d --wait",
+	"e2e:down": "docker compose -f tests/e2e/docker-compose.yml down -v",
+	"e2e:bootstrap": "bun tests/e2e/setup/bootstrap.ts",
+	"e2e:logs": "docker compose -f tests/e2e/docker-compose.yml logs -f metabase",
+	"typecheck": "tsc --noEmit",
+	"lint": "oxlint",
+	"lint:fix": "oxlint --fix",
+	"format": "oxfmt",
+	"format:check": "oxfmt --check",
+	"prepublishOnly": "tsdown && publint"
+};
+var dependencies = {
+	"@clack/prompts": "^0.8.2",
+	"@napi-rs/keyring": "^1.3.0",
+	"citty": "^0.2.2",
+	"cli-table3": "^0.6.5",
+	"yaml": "^2.8.4",
+	"zod": "^4.0.0"
+};
+var devDependencies = {
+	"@types/node": "^22.10.0",
+	"execa": "^9.5.2",
+	"fast-check": "^4.7.0",
+	"oxfmt": "^0.47.0",
+	"oxlint": "^1.62.0",
+	"publint": "^0.3.0",
+	"tsdown": "^0.9.0",
+	"typescript": "^5.7.2",
+	"vitest": "^2.1.8"
+};
+var engines = { "node": ">=20.6" };
+var package_default = {
+	name,
+	version,
+	description,
+	license,
+	repository,
+	bin,
+	files,
+	type,
+	publishConfig,
+	scripts,
+	dependencies,
+	devDependencies,
+	engines
+};
+
+//#endregion
+export { package_default };

package/dist/parse-id-C1prc9US.mjs

@@ -0,0 +1,12 @@
+import { parseInteger } from "./runtime-DUgFfYkN.mjs";
+
+//#region src/commands/parse-id.ts
+function parseId(value, name = "id") {
+	return parseInteger(value, {
+		name,
+		min: 1
+	});
+}
+
+//#endregion
+export { parseId };

package/dist/poll-D2sXM5rc.mjs

@@ -0,0 +1,49 @@
+import { TimeoutError, combineAborts, throwIfAborted } from "./runtime-DUgFfYkN.mjs";
+import { setTimeout } from "node:timers/promises";
+
+//#region src/runtime/poll.ts
+const DEFAULT_INTERVAL_MS = 2e3;
+const DEFAULT_MAX_INTERVAL_MS = 3e4;
+const DEFAULT_TIMEOUT_MS = 6e5;
+async function pollUntil(fn, done, opts = {}) {
+	const intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
+	const maxIntervalMs = opts.maxIntervalMs ?? DEFAULT_MAX_INTERVAL_MS;
+	const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const backoff = opts.backoff ?? "fixed";
+	const timeoutSignal = AbortSignal.timeout(timeoutMs);
+	const { combined, processSignal } = combineAborts(timeoutSignal, opts.signal);
+	let interval = intervalMs;
+	let attempts = 0;
+	while (true) {
+		throwIfAborted(processSignal);
+		if (combined.aborted) throw pollTimeout(timeoutMs, attempts);
+		let value;
+		try {
+			value = await fn(combined);
+		} catch (error) {
+			throwIfAborted(processSignal);
+			if (combined.aborted) throw pollTimeout(timeoutMs, attempts);
+			throw error;
+		}
+		attempts += 1;
+		if (done(value)) return value;
+		try {
+			await setTimeout(interval, void 0, { signal: combined });
+		} catch (error) {
+			throwIfAborted(processSignal);
+			if (combined.aborted) throw pollTimeout(timeoutMs, attempts);
+			throw error;
+		}
+		if (backoff === "exponential") interval = Math.min(interval * 2, maxIntervalMs);
+	}
+}
+function pollTimeout(timeoutMs, attempts) {
+	return new TimeoutError(`Polling timed out after ${timeoutMs}ms`, {
+		kind: "polling",
+		timeoutMs,
+		attempts
+	});
+}
+
+//#endregion
+export { DEFAULT_INTERVAL_MS, DEFAULT_TIMEOUT_MS, pollUntil };

package/dist/poll-task-Byiunmaj.mjs

@@ -0,0 +1,194 @@
+import { parseJson } from "./runtime-DUgFfYkN.mjs";
+import { DEFAULT_INTERVAL_MS, DEFAULT_TIMEOUT_MS, pollUntil } from "./poll-D2sXM5rc.mjs";
+import { z } from "zod";
+
+//#region src/domain/remote-sync.ts
+const SyncTaskStatus = z.enum([
+	"running",
+	"successful",
+	"errored",
+	"cancelled",
+	"timed-out",
+	"conflict"
+]);
+const SyncTaskType = z.enum(["import", "export"]);
+const SyncTask = z.object({
+	id: z.number().int().positive(),
+	sync_task_type: SyncTaskType,
+	status: SyncTaskStatus,
+	progress: z.number().min(0).max(1).nullable(),
+	started_at: z.string(),
+	ended_at: z.string().nullable().optional(),
+	last_progress_report_at: z.string().nullable().optional(),
+	version: z.string().nullable().optional(),
+	initiated_by: z.number().int().positive().nullable().optional(),
+	cancelled: z.boolean().nullable().optional(),
+	error_message: z.string().nullable().optional(),
+	conflicts: z.array(z.string()).nullable().optional()
+}).loose();
+const SyncTaskCompact = SyncTask.pick({
+	id: true,
+	sync_task_type: true,
+	status: true,
+	progress: true,
+	version: true,
+	error_message: true
+}).strip();
+const syncTaskView = {
+	compactPick: SyncTaskCompact,
+	tableColumns: [
+		{
+			key: "id",
+			label: "ID"
+		},
+		{
+			key: "sync_task_type",
+			label: "Type"
+		},
+		{
+			key: "status",
+			label: "Status"
+		},
+		{
+			key: "progress",
+			label: "Progress"
+		},
+		{
+			key: "version",
+			label: "Version"
+		},
+		{
+			key: "error_message",
+			label: "Error"
+		}
+	]
+};
+const SyncDirtyItem = z.object({
+	id: z.number().int(),
+	name: z.string().nullable(),
+	model: z.string(),
+	sync_status: z.string(),
+	collection_id: z.number().int().positive().nullable().optional(),
+	description: z.string().nullable().optional(),
+	display: z.string().nullable().optional(),
+	query_type: z.string().nullable().optional(),
+	table_id: z.number().int().positive().nullable().optional(),
+	table_name: z.string().nullable().optional()
+}).loose();
+const SyncDirtyItemCompact = SyncDirtyItem.pick({
+	id: true,
+	name: true,
+	model: true,
+	sync_status: true,
+	collection_id: true
+}).strip();
+const syncDirtyItemView = {
+	compactPick: SyncDirtyItemCompact,
+	tableColumns: [
+		{
+			key: "id",
+			label: "ID"
+		},
+		{
+			key: "model",
+			label: "Model"
+		},
+		{
+			key: "name",
+			label: "Name"
+		},
+		{
+			key: "sync_status",
+			label: "Status"
+		},
+		{
+			key: "collection_id",
+			label: "Collection"
+		}
+	]
+};
+
+//#endregion
+//#region src/commands/sync/poll-task.ts
+const TERMINAL_STATUSES = new Set([
+	"successful",
+	"errored",
+	"cancelled",
+	"timed-out",
+	"conflict"
+]);
+const FAILURE_STATUSES = new Set([
+	"errored",
+	"timed-out",
+	"conflict"
+]);
+const REMOTE_SYNC_PATHS = {
+	currentTask: "/api/ee/remote-sync/current-task",
+	cancelTask: "/api/ee/remote-sync/current-task/cancel",
+	isDirty: "/api/ee/remote-sync/is-dirty",
+	hasRemoteChanges: "/api/ee/remote-sync/has-remote-changes",
+	dirty: "/api/ee/remote-sync/dirty",
+	import: "/api/ee/remote-sync/import",
+	export: "/api/ee/remote-sync/export",
+	stash: "/api/ee/remote-sync/stash",
+	branches: "/api/ee/remote-sync/branches",
+	createBranch: "/api/ee/remote-sync/create-branch"
+};
+const SyncTaskIdle = z.object({ status: z.literal("idle") });
+const SyncTaskOrIdle = z.union([SyncTask, SyncTaskIdle]);
+const syncTaskIdleView = {
+	compactPick: SyncTaskIdle,
+	tableColumns: [{
+		key: "status",
+		label: "Status"
+	}]
+};
+const pollFlags = {
+	wait: {
+		type: "boolean",
+		description: "Poll the resulting task until it reaches a terminal status",
+		default: true
+	},
+	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)
+	}
+};
+function isTerminal(status) {
+	return TERMINAL_STATUSES.has(status);
+}
+function isFailure(status) {
+	return FAILURE_STATUSES.has(status);
+}
+async function fetchOptionalParsed(client, path, schema) {
+	const response = await client.requestRaw(path, {
+		method: "GET",
+		expectContentType: "binary"
+	});
+	if (response.status === 204) return null;
+	const text = await response.text();
+	return parseJson(text, schema, { source: response.url });
+}
+async function fetchCurrentTask(client) {
+	return await fetchOptionalParsed(client, REMOTE_SYNC_PATHS.currentTask, SyncTask);
+}
+async function pollSyncTask(client, opts) {
+	return await pollUntil(async () => fetchCurrentTask(client), (task) => task === null || isTerminal(task.status), {
+		backoff: "exponential",
+		...opts
+	});
+}
+function throwIfFailedTask(final, verb) {
+	if (final === null || !isFailure(final.status)) return;
+	const detail = final.error_message ? `: ${final.error_message}` : "";
+	throw new Error(`sync ${verb} ${final.status}${detail}`);
+}
+
+//#endregion
+export { REMOTE_SYNC_PATHS, SyncDirtyItem, SyncDirtyItemCompact, SyncTask, SyncTaskOrIdle, fetchCurrentTask, fetchOptionalParsed, pollFlags, pollSyncTask, syncDirtyItemView, syncTaskIdleView, syncTaskView, throwIfFailedTask };

package/dist/prompt-fXeNtj0M.mjs

@@ -0,0 +1,40 @@
+import { AbortError, ConfigError } from "./runtime-DUgFfYkN.mjs";
+import { confirm, isCancel, password, text } from "@clack/prompts";
+
+//#region src/output/prompt.ts
+async function promptText(opts) {
+	requireTty(opts.message);
+	const value = await text({
+		message: opts.message,
+		...opts.placeholder !== void 0 && { placeholder: opts.placeholder },
+		...opts.initialValue !== void 0 && { initialValue: opts.initialValue },
+		...opts.validate !== void 0 && { validate: opts.validate }
+	});
+	if (isCancel(value)) throw new AbortError();
+	return value;
+}
+async function promptPassword(opts) {
+	requireTty(opts.message);
+	const value = await password({
+		message: opts.message,
+		...opts.mask !== void 0 && { mask: opts.mask },
+		...opts.validate !== void 0 && { validate: opts.validate }
+	});
+	if (isCancel(value)) throw new AbortError();
+	return value;
+}
+async function promptConfirm(opts) {
+	requireTty(opts.message);
+	const value = await confirm({
+		message: opts.message,
+		...opts.initialValue !== void 0 && { initialValue: opts.initialValue }
+	});
+	if (isCancel(value)) throw new AbortError();
+	return value;
+}
+function requireTty(prompt) {
+	if (!process.stdin.isTTY) throw new ConfigError(`cannot prompt "${prompt}" — stdin is not a TTY`);
+}
+
+//#endregion
+export { promptConfirm, promptPassword, promptText };

package/dist/provision-DC4_HWZD.mjs

@@ -0,0 +1,80 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { ConfigError, connectionFlags, defineMetabaseCommand, outputFlags, parseCsv, profileFlag } from "./runtime-DUgFfYkN.mjs";
+import "./input-BNqSFl38.mjs";
+import { readBody } from "./body-DwU2s6Pg.mjs";
+import { bodyInputFlags } from "./body-flags-7oqLhu5j.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import "./poll-D2sXM5rc.mjs";
+import { parseWaitFlags, waitFlags } from "./wait-flags-CjW4ogUJ.mjs";
+import { Workspace, WorkspaceProvisionInput, workspaceView } from "./workspace-Dr9lWU3D.mjs";
+import { waitForDatabaseProvisioned } from "./wait-DwZN3ZwR.mjs";
+
+//#region src/commands/workspace/database/provision.ts
+var provision_default = defineMetabaseCommand({
+	meta: {
+		name: "provision",
+		description: "Provision a database into a workspace"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		...bodyInputFlags,
+		...waitFlags,
+		"database-id": {
+			type: "string",
+			description: "Database id (alternative to --body / --file)"
+		},
+		schemas: {
+			type: "string",
+			description: "Comma-separated input schemas (alternative to --body / --file)"
+		},
+		id: {
+			type: "positional",
+			description: "Workspace id",
+			required: true
+		}
+	},
+	outputSchema: Workspace,
+	examples: [
+		"metabase workspace database provision 1 --database-id 5 --schemas analytics,github",
+		"metabase workspace database provision 1 --database-id 5 --schemas analytics --wait",
+		"metabase workspace database provision 1 --file provision.json"
+	],
+	async run({ args, ctx, getClient }) {
+		const workspaceId = parseId(args.id);
+		const databaseIdFlag = args["database-id"];
+		const schemasFlag = args.schemas;
+		const wait = parseWaitFlags(args);
+		let body;
+		if (databaseIdFlag !== void 0 && databaseIdFlag !== "") {
+			const databaseId = parseId(databaseIdFlag, "--database-id");
+			const schemas = parseSchemas(schemasFlag);
+			body = WorkspaceProvisionInput.parse({
+				database_id: databaseId,
+				input_schemas: schemas
+			});
+		} else body = await readBody({
+			flag: args.body,
+			file: args.file
+		}, WorkspaceProvisionInput);
+		const client = await getClient();
+		const initial = await client.requestParsed(Workspace, `/api/ee/workspace-manager/${workspaceId}/database`, {
+			method: "POST",
+			body
+		});
+		const final = wait.enabled ? await waitForDatabaseProvisioned(client, workspaceId, body.database_id, wait.schedule) : initial;
+		renderItem(final, workspaceView, ctx);
+	}
+});
+function parseSchemas(raw) {
+	if (raw === void 0 || raw === "") throw new ConfigError("--schemas is required when using --database-id");
+	const parts = parseCsv(raw);
+	if (parts.length === 0) throw new ConfigError("--schemas must contain at least one schema name");
+	return parts;
+}
+
+//#endregion
+export { provision_default as default };

package/dist/ps-1bZKIwWh.mjs

@@ -0,0 +1,9 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import "./render-DlBijc5i.mjs";
+import "./runtime-DUgFfYkN.mjs";
+import "./poll-D2sXM5rc.mjs";
+import "./docker-QWVMG2gl.mjs";
+import { LocalWorkspace, LocalWorkspaceCompact, LocalWorkspaceListEnvelope, LocalWorkspaceState, localWorkspaceView, ps_default } from "./ps-BiOrecEe.mjs";
+
+export { ps_default as default };

package/dist/ps-BiOrecEe.mjs

@@ -0,0 +1,78 @@
+import { renderList } from "./render-DlBijc5i.mjs";
+import { defineMetabaseCommand, listEnvelopeSchema, localUrl, outputFlags, wrapList } from "./runtime-DUgFfYkN.mjs";
+import { CONTAINER_STATES, checkDockerReady, listWorkspaceContainers } from "./docker-QWVMG2gl.mjs";
+import { z } from "zod";
+
+//#region src/commands/workspace/ps.ts
+const LocalWorkspaceState = z.enum(CONTAINER_STATES);
+const LocalWorkspace = z.object({
+	workspace_id: z.number().int().positive(),
+	workspace_name: z.string(),
+	container_name: z.string(),
+	state: LocalWorkspaceState,
+	status: z.string(),
+	image: z.string(),
+	profile: z.string().nullable(),
+	parent_url: z.string().nullable(),
+	host_port: z.number().int().positive().nullable(),
+	url: z.string().nullable()
+});
+const LocalWorkspaceCompact = LocalWorkspace.pick({
+	workspace_id: true,
+	workspace_name: true,
+	state: true,
+	url: true
+}).strip();
+const localWorkspaceView = {
+	compactPick: LocalWorkspaceCompact,
+	tableColumns: [
+		{
+			key: "workspace_id",
+			label: "ID"
+		},
+		{
+			key: "workspace_name",
+			label: "Name"
+		},
+		{
+			key: "state",
+			label: "State"
+		},
+		{
+			key: "url",
+			label: "URL",
+			format: (value) => typeof value === "string" ? value : "—"
+		}
+	]
+};
+const LocalWorkspaceListEnvelope = listEnvelopeSchema(LocalWorkspaceCompact);
+var ps_default = defineMetabaseCommand({
+	meta: {
+		name: "ps",
+		description: "List workspaces with a local container (running or stopped)"
+	},
+	args: { ...outputFlags },
+	outputSchema: LocalWorkspaceListEnvelope,
+	examples: ["metabase workspace ps", "metabase workspace ps --json"],
+	async run({ ctx }) {
+		await checkDockerReady();
+		const summaries = await listWorkspaceContainers();
+		const items = summaries.map((summary) => ({
+			workspace_id: summary.workspaceId,
+			workspace_name: summary.workspaceName,
+			container_name: summary.name,
+			state: summary.state,
+			status: summary.status,
+			image: summary.image,
+			profile: summary.profile,
+			parent_url: summary.parentUrl,
+			host_port: summary.hostPort,
+			url: summary.hostPort !== null && summary.state === "running" ? localUrl(summary.hostPort) : null
+		}));
+		items.sort((a, b) => a.workspace_id - b.workspace_id);
+		renderList(wrapList(items), localWorkspaceView, ctx);
+	}
+});
+
+//#endregion
+export { LocalWorkspace, LocalWorkspaceCompact, LocalWorkspaceListEnvelope, LocalWorkspaceState, localWorkspaceView, ps_default };