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

package/dist/is-dirty-B10S6MG0.mjs

@@ -0,0 +1,35 @@
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-DUgFfYkN.mjs";
+import { REMOTE_SYNC_PATHS } from "./poll-task-Byiunmaj.mjs";
+import { z } from "zod";
+
+//#region src/commands/sync/is-dirty.ts
+const IsDirtyResult = z.object({ is_dirty: z.boolean() });
+const isDirtyView = {
+	compactPick: IsDirtyResult,
+	tableColumns: [{
+		key: "is_dirty",
+		label: "Dirty"
+	}]
+};
+var is_dirty_default = defineMetabaseCommand({
+	meta: {
+		name: "is-dirty",
+		description: "Check whether Metabase has unsynced local changes"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags
+	},
+	outputSchema: IsDirtyResult,
+	examples: ["metabase sync is-dirty", "metabase sync is-dirty --json"],
+	async run({ ctx, getClient }) {
+		const client = await getClient();
+		const result = await client.requestParsed(IsDirtyResult, REMOTE_SYNC_PATHS.isDirty);
+		renderItem(result, isDirtyView, ctx);
+	}
+});
+
+//#endregion
+export { IsDirtyResult, is_dirty_default };

package/dist/is-dirty-CUuq-aB6.mjs

@@ -0,0 +1,9 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import "./render-DlBijc5i.mjs";
+import "./runtime-DUgFfYkN.mjs";
+import "./poll-task-Byiunmaj.mjs";
+import "./poll-D2sXM5rc.mjs";
+import { IsDirtyResult, is_dirty_default } from "./is-dirty-B10S6MG0.mjs";
+
+export { is_dirty_default as default };

package/dist/key-CyhOpgWt.mjs

@@ -0,0 +1,12 @@
+import { ConfigError } from "./runtime-DUgFfYkN.mjs";
+
+//#region src/commands/setting/key.ts
+const SETTING_KEY_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
+function parseSettingKey(value) {
+	const trimmed = value.trim();
+	if (!SETTING_KEY_PATTERN.test(trimmed)) throw new ConfigError(`invalid setting key: "${value}" (expected kebab-case identifier)`);
+	return trimmed;
+}
+
+//#endregion
+export { parseSettingKey };

package/dist/license-DtsGJi3l.mjs

@@ -0,0 +1,17 @@
+import { defineCommand } from "citty";
+
+//#region src/commands/license/index.ts
+var license_default = defineCommand({
+	meta: {
+		name: "license",
+		description: "Manage the Metabase license token"
+	},
+	subCommands: {
+		set: () => import("./set-BZnCRL4c.mjs").then((m) => m.default),
+		status: () => import("./status-9KAPIpX8.mjs").then((m) => m.default),
+		remove: () => import("./remove-Bx48o-0S.mjs").then((m) => m.default)
+	}
+});
+
+//#endregion
+export { license_default as default };

package/dist/list-B8s7Qnzk.mjs

@@ -0,0 +1,31 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderList } from "./render-DlBijc5i.mjs";
+import { connectionFlags, defineMetabaseCommand, listEnvelopeSchema, outputFlags, profileFlag, wrapList } from "./runtime-DUgFfYkN.mjs";
+import { Workspace, WorkspaceCompact, workspaceView } from "./workspace-Dr9lWU3D.mjs";
+import { z } from "zod";
+
+//#region src/commands/workspace/list.ts
+const WorkspaceApiList = z.array(Workspace);
+const WorkspaceListEnvelope = listEnvelopeSchema(WorkspaceCompact);
+var list_default = defineMetabaseCommand({
+	meta: {
+		name: "list",
+		description: "List workspaces"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags
+	},
+	outputSchema: WorkspaceListEnvelope,
+	examples: ["metabase workspace list", "metabase workspace list --json"],
+	async run({ ctx, getClient }) {
+		const client = await getClient();
+		const items = await client.requestParsed(WorkspaceApiList, "/api/ee/workspace-manager");
+		renderList(wrapList(items), workspaceView, ctx);
+	}
+});
+
+//#endregion
+export { list_default as default };

package/dist/list-C5MGydGU.mjs

@@ -0,0 +1,31 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderList } from "./render-DlBijc5i.mjs";
+import { connectionFlags, defineMetabaseCommand, listEnvelopeSchema, outputFlags, profileFlag, wrapList } from "./runtime-DUgFfYkN.mjs";
+import { TransformJob, TransformJobCompact, transformJobView } from "./transform-job-DuB_OjhO.mjs";
+import { z } from "zod";
+
+//#region src/commands/transform-job/list.ts
+const TransformJobApiList = z.array(TransformJob);
+const TransformJobListEnvelope = listEnvelopeSchema(TransformJobCompact);
+var list_default = defineMetabaseCommand({
+	meta: {
+		name: "list",
+		description: "List transform jobs"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags
+	},
+	outputSchema: TransformJobListEnvelope,
+	examples: ["metabase transform-job list", "metabase transform-job list --json"],
+	async run({ ctx, getClient }) {
+		const client = await getClient();
+		const items = await client.requestParsed(TransformJobApiList, "/api/transform-job");
+		renderList(wrapList(items), transformJobView, ctx);
+	}
+});
+
+//#endregion
+export { list_default as default };

package/dist/list-DeFGwhhJ.mjs

@@ -0,0 +1,60 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderList } from "./render-DlBijc5i.mjs";
+import { connectionFlags, defineMetabaseCommand, listEnvelopeSchema, outputFlags, profileFlag, wrapList } from "./runtime-DUgFfYkN.mjs";
+import { Card, CardCompact, cardView } from "./card-C31pGtBZ.mjs";
+import { z } from "zod";
+
+//#region src/commands/card/list.ts
+const CardApiList = z.array(Card);
+const CardListFilter = z.enum([
+	"all",
+	"mine",
+	"bookmarked",
+	"database",
+	"table",
+	"archived",
+	"using_model",
+	"using_segment"
+]);
+const CardListEnvelope = listEnvelopeSchema(CardCompact);
+var list_default = defineMetabaseCommand({
+	meta: {
+		name: "list",
+		description: "List cards (questions, models, metrics)"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		filter: {
+			type: "string",
+			description: `Filter preset: ${CardListFilter.options.join("|")}`,
+			default: "all"
+		},
+		modelId: {
+			type: "string",
+			description: "Used by filter database|table|using_model|using_segment",
+			alias: "model-id"
+		}
+	},
+	outputSchema: CardListEnvelope,
+	examples: [
+		"metabase card list",
+		"metabase card list --filter archived --json",
+		"metabase card list --filter using_model --model-id 42 --json"
+	],
+	async run({ args, ctx, getClient }) {
+		const filter = CardListFilter.parse(args.filter);
+		const modelId = args.modelId === void 0 || args.modelId === "" ? void 0 : args.modelId;
+		const client = await getClient();
+		const items = await client.requestParsed(CardApiList, "/api/card", { query: {
+			f: filter,
+			model_id: modelId
+		} });
+		renderList(wrapList(items), cardView, ctx);
+	}
+});
+
+//#endregion
+export { list_default as default };

package/dist/list-OBx5B3gd.mjs

@@ -0,0 +1,39 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderList } from "./render-DlBijc5i.mjs";
+import { connectionFlags, defineMetabaseCommand, listEnvelopeSchema, outputFlags, profileFlag, wrapList } from "./runtime-DUgFfYkN.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import "./field-QwBMAWsq.mjs";
+import { Table, TableCompact, tableView } from "./table-BvAr2ixC.mjs";
+import { z } from "zod";
+
+//#region src/commands/table/list.ts
+const TableApiList = z.array(Table);
+const TableListEnvelope = listEnvelopeSchema(TableCompact);
+var list_default = defineMetabaseCommand({
+	meta: {
+		name: "list",
+		description: "List tables (optionally filtered by database)"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		"db-id": {
+			type: "string",
+			description: "Filter by database id"
+		}
+	},
+	outputSchema: TableListEnvelope,
+	examples: ["metabase table list", "metabase table list --db-id 1 --json"],
+	async run({ args, ctx, getClient }) {
+		const dbIdFilter = args["db-id"] === void 0 ? void 0 : parseId(args["db-id"], "db-id");
+		const client = await getClient();
+		const all = await client.requestParsed(TableApiList, "/api/table");
+		const filtered = dbIdFilter === void 0 ? all : all.filter((row) => row.db_id === dbIdFilter);
+		renderList(wrapList(filtered), tableView, ctx);
+	}
+});
+
+//#endregion
+export { list_default as default };

package/dist/list-Y7iGsOfE.mjs

@@ -0,0 +1,31 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderList } from "./render-DlBijc5i.mjs";
+import { connectionFlags, defineMetabaseCommand, listEnvelopeSchema, outputFlags, profileFlag, wrapList } from "./runtime-DUgFfYkN.mjs";
+import { Setting, SettingCompact, settingView } from "./setting-DM7pm7yh.mjs";
+import { z } from "zod";
+
+//#region src/commands/setting/list.ts
+const SettingApiList = z.array(Setting);
+const SettingListEnvelope = listEnvelopeSchema(SettingCompact);
+var list_default = defineMetabaseCommand({
+	meta: {
+		name: "list",
+		description: "List all settings (admin)"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags
+	},
+	outputSchema: SettingListEnvelope,
+	examples: ["metabase setting list", "metabase setting list --json"],
+	async run({ ctx, getClient }) {
+		const client = await getClient();
+		const settings = await client.requestParsed(SettingApiList, "/api/setting");
+		renderList(wrapList(settings), settingView, ctx);
+	}
+});
+
+//#endregion
+export { list_default as default };

package/dist/list-evtQS7jl.mjs

@@ -0,0 +1,39 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderList } from "./render-DlBijc5i.mjs";
+import { connectionFlags, defineMetabaseCommand, listEnvelopeSchema, outputFlags, profileFlag } from "./runtime-DUgFfYkN.mjs";
+import { Database, DatabaseCompact, databaseView } from "./database-BTX5qbSv.mjs";
+import { z } from "zod";
+
+//#region src/commands/db/list.ts
+const DatabaseApiList = z.object({
+	data: z.array(Database),
+	total: z.number().int().nonnegative()
+}).loose();
+const DatabaseListEnvelope = listEnvelopeSchema(DatabaseCompact);
+var list_default = defineMetabaseCommand({
+	meta: {
+		name: "list",
+		description: "List databases"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags
+	},
+	outputSchema: DatabaseListEnvelope,
+	examples: ["metabase db list", "metabase db list --json"],
+	async run({ ctx, getClient }) {
+		const client = await getClient();
+		const response = await client.requestParsed(DatabaseApiList, "/api/database");
+		const envelope = {
+			data: response.data,
+			returned: response.data.length,
+			total: response.total
+		};
+		renderList(envelope, databaseView, ctx);
+	}
+});
+
+//#endregion
+export { list_default as default };

package/dist/list-qetY9OIN.mjs

@@ -0,0 +1,31 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderList } from "./render-DlBijc5i.mjs";
+import { connectionFlags, defineMetabaseCommand, listEnvelopeSchema, outputFlags, profileFlag, wrapList } from "./runtime-DUgFfYkN.mjs";
+import { Transform, TransformCompact, transformView } from "./transform-DfVkUttP.mjs";
+import { z } from "zod";
+
+//#region src/commands/transform/list.ts
+const TransformApiList = z.array(Transform);
+const TransformListEnvelope = listEnvelopeSchema(TransformCompact);
+var list_default = defineMetabaseCommand({
+	meta: {
+		name: "list",
+		description: "List transforms"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags
+	},
+	outputSchema: TransformListEnvelope,
+	examples: ["metabase transform list", "metabase transform list --json"],
+	async run({ ctx, getClient }) {
+		const client = await getClient();
+		const items = await client.requestParsed(TransformApiList, "/api/transform");
+		renderList(wrapList(items), transformView, ctx);
+	}
+});
+
+//#endregion
+export { list_default as default };

package/dist/login-Dqw9ZtCx.mjs

@@ -0,0 +1,172 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem, warn } from "./render-DlBijc5i.mjs";
+import { ConfigError, HttpError, MetabaseError, connectionFlags, createClient, defineMetabaseCommand, errorMessage, normalizeUrl, outputFlags, profileFlag, readEnvCredentials, resolveProfileName, writeProfile } from "./runtime-DUgFfYkN.mjs";
+import { readInput } from "./input-BNqSFl38.mjs";
+import { promptPassword, promptText } from "./prompt-fXeNtj0M.mjs";
+import { z } from "zod";
+
+//#region src/domain/user.ts
+const CurrentUser = z.object({
+	id: z.number().int(),
+	email: z.email()
+}).loose();
+const CurrentUserCompact = CurrentUser.pick({
+	id: true,
+	email: true
+}).strip();
+
+//#endregion
+//#region src/core/auth/verify.ts
+const VERIFY_TIMEOUT_MS = 15e3;
+async function verifyCredentials(url, apiKey) {
+	const client = createClient({
+		url,
+		apiKey
+	});
+	try {
+		const user = await client.requestParsed(CurrentUser, "/api/user/current", {
+			timeoutMs: VERIFY_TIMEOUT_MS,
+			retries: 0
+		});
+		return {
+			ok: true,
+			user
+		};
+	} catch (error) {
+		return failure(error);
+	}
+}
+function failure(error) {
+	if (error instanceof HttpError) return {
+		ok: false,
+		status: error.status,
+		message: error.userMessage
+	};
+	if (error instanceof MetabaseError) return {
+		ok: false,
+		message: error.userMessage
+	};
+	return {
+		ok: false,
+		message: errorMessage(error)
+	};
+}
+
+//#endregion
+//#region src/commands/auth/login.ts
+const LoginResult = z.object({
+	profile: z.string(),
+	url: z.string(),
+	authenticated: z.boolean(),
+	email: z.string().nullable()
+});
+const loginView = {
+	compactPick: LoginResult,
+	tableColumns: [
+		{
+			key: "profile",
+			label: "Profile"
+		},
+		{
+			key: "url",
+			label: "URL"
+		},
+		{
+			key: "authenticated",
+			label: "Authenticated"
+		},
+		{
+			key: "email",
+			label: "Email"
+		}
+	]
+};
+var login_default = defineMetabaseCommand({
+	meta: {
+		name: "login",
+		description: "Set Metabase credentials for a profile"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		"skip-verify": {
+			type: "boolean",
+			default: false,
+			description: "Save without contacting the server"
+		}
+	},
+	outputSchema: LoginResult,
+	examples: [
+		"metabase auth login --url https://metabase.example.com < key.txt",
+		"echo $METABASE_API_KEY | metabase auth login --url https://metabase.example.com",
+		"metabase auth login --profile staging --url https://staging.example.com"
+	],
+	async run({ args, ctx }) {
+		const profileName = resolveProfileName(args.profile);
+		const env = readEnvCredentials();
+		if (args.apiKey) warn("warning: --api-key is visible in shell history and process listings — pipe the key on stdin or set METABASE_API_KEY instead");
+		const url = await resolveUrl(args.url, env.url);
+		const apiKey = await resolveApiKey(args.apiKey, env.apiKey);
+		let email = null;
+		let authenticated = false;
+		if (!args["skip-verify"]) {
+			const result = await verifyCredentials(url, apiKey);
+			if (!result.ok) throw new ConfigError(`verification failed: ${result.message}`);
+			email = result.user.email;
+			authenticated = true;
+		}
+		const location = await writeProfile({
+			url,
+			apiKey
+		}, profileName);
+		if (location.backend === "file") warn(`warning: OS keychain unavailable; credentials stored as plaintext at ${location.path}`);
+		renderItem({
+			profile: profileName,
+			url,
+			authenticated,
+			email
+		}, loginView, ctx);
+	}
+});
+async function resolveUrl(flagUrl, envUrl) {
+	if (flagUrl) return normalizeUrl(flagUrl);
+	if (envUrl) return normalizeUrl(envUrl);
+	return promptForUrl();
+}
+async function resolveApiKey(flagKey, envKey) {
+	if (flagKey) return flagKey;
+	const piped = (await readInput({ required: false })).trim();
+	if (piped) return piped;
+	if (envKey) return envKey;
+	return promptForApiKey();
+}
+async function promptForUrl() {
+	if (!process.stdin.isTTY) throw new ConfigError("--url is required when stdin is not a TTY (cannot prompt interactively)");
+	const value = await promptText({
+		message: "Metabase URL",
+		placeholder: "https://metabase.example.com",
+		validate(input) {
+			if (!input) return "URL is required";
+			try {
+				normalizeUrl(input);
+			} catch (error) {
+				return errorMessage(error);
+			}
+			return void 0;
+		}
+	});
+	return normalizeUrl(value);
+}
+async function promptForApiKey() {
+	if (!process.stdin.isTTY) throw new ConfigError("--api-key, piped stdin, or METABASE_API_KEY required when stdin is not a TTY");
+	return promptPassword({
+		message: "API key",
+		mask: "•",
+		validate: (input) => input ? void 0 : "API key is required"
+	});
+}
+
+//#endregion
+export { login_default as default };

package/dist/logout-DwYJ5OUi.mjs

@@ -0,0 +1,74 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { ConfigError, clearProfile, defineMetabaseCommand, outputFlags, profileFlag, resolveProfileName } from "./runtime-DUgFfYkN.mjs";
+import { promptConfirm } from "./prompt-fXeNtj0M.mjs";
+import { z } from "zod";
+
+//#region src/commands/auth/logout.ts
+const LogoutResult = z.object({
+	profile: z.string(),
+	cleared: z.boolean(),
+	aborted: z.boolean()
+});
+const logoutView = {
+	compactPick: LogoutResult,
+	tableColumns: [
+		{
+			key: "profile",
+			label: "Profile"
+		},
+		{
+			key: "cleared",
+			label: "Cleared"
+		},
+		{
+			key: "aborted",
+			label: "Aborted"
+		}
+	]
+};
+var logout_default = defineMetabaseCommand({
+	meta: {
+		name: "logout",
+		description: "Clear stored credentials for a profile"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		yes: {
+			type: "boolean",
+			description: "Skip confirmation",
+			default: false
+		}
+	},
+	outputSchema: LogoutResult,
+	examples: ["metabase auth logout --yes", "metabase auth logout --profile staging --yes"],
+	async run({ args, ctx }) {
+		const profileName = resolveProfileName(args.profile);
+		if (!args.yes) {
+			if (!process.stdin.isTTY) throw new ConfigError("--yes required to clear credentials non-interactively");
+			const ok = await promptConfirm({
+				message: `Clear stored credentials for profile "${profileName}"?`,
+				initialValue: false
+			});
+			if (!ok) {
+				renderItem({
+					profile: profileName,
+					cleared: false,
+					aborted: true
+				}, logoutView, ctx);
+				return;
+			}
+		}
+		const cleared = await clearProfile(profileName);
+		renderItem({
+			profile: profileName,
+			cleared,
+			aborted: false
+		}, logoutView, ctx);
+	}
+});
+
+//#endregion
+export { logout_default as default };

package/dist/logs-B_lrY7Js.mjs

@@ -0,0 +1,57 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { ConfigError, defineMetabaseCommand, outputFlags, parseInteger } from "./runtime-DUgFfYkN.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import "./poll-D2sXM5rc.mjs";
+import { checkDockerReady, containerLifecycleStatus, containerNameFor, streamLogs } from "./docker-QWVMG2gl.mjs";
+
+//#region src/commands/workspace/logs.ts
+const DEFAULT_TAIL = 200;
+var logs_default = defineMetabaseCommand({
+	meta: {
+		name: "logs",
+		description: "Stream the local container's logs (passthrough to `docker logs`)"
+	},
+	args: {
+		...outputFlags,
+		id: {
+			type: "positional",
+			description: "Workspace id",
+			required: true
+		},
+		follow: {
+			type: "boolean",
+			alias: "f",
+			description: "Follow log output (stream indefinitely; Ctrl-C to exit)",
+			default: false
+		},
+		tail: {
+			type: "string",
+			description: `Number of lines from the end of the logs (default: ${DEFAULT_TAIL})`,
+			default: String(DEFAULT_TAIL)
+		}
+	},
+	examples: [
+		"metabase workspace logs 1",
+		"metabase workspace logs 1 --follow",
+		"metabase workspace logs 1 --tail 500"
+	],
+	async run({ args }) {
+		const workspaceId = parseId(args.id);
+		const containerName = containerNameFor(workspaceId);
+		const tail = parseInteger(args.tail ?? String(DEFAULT_TAIL), {
+			name: "--tail",
+			min: 0
+		});
+		await checkDockerReady();
+		const status = await containerLifecycleStatus(containerName);
+		if (status === "missing") throw new ConfigError(`no container for workspace ${workspaceId} — run \`metabase workspace start ${workspaceId}\` first`);
+		await streamLogs(containerName, {
+			follow: args.follow === true,
+			tail
+		});
+	}
+});
+
+//#endregion
+export { logs_default as default };