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

package/dist/search-4wKx5ug2.mjs

@@ -0,0 +1,171 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderList } from "./render-DlBijc5i.mjs";
+import { ConfigError, connectionFlags, defineMetabaseCommand, listEnvelopeSchema, outputFlags, parseCsv, profileFlag } from "./runtime-DUgFfYkN.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import { z } from "zod";
+
+//#region src/domain/search.ts
+const SEARCH_MODELS = [
+	"card",
+	"dataset",
+	"metric",
+	"dashboard",
+	"collection",
+	"database",
+	"table",
+	"segment",
+	"measure",
+	"snippet",
+	"document",
+	"action",
+	"transform",
+	"indexed-entity"
+];
+const SearchModel = z.enum(SEARCH_MODELS);
+const SearchResultCollection = z.object({
+	id: z.union([
+		z.number().int(),
+		z.string(),
+		z.null()
+	]),
+	name: z.string().nullable(),
+	authority_level: z.string().nullable(),
+	type: z.string().nullable()
+}).loose();
+const SearchResult = z.object({
+	id: z.union([z.number().int(), z.string()]),
+	name: z.string(),
+	model: SearchModel,
+	description: z.string().nullable(),
+	archived: z.boolean().nullable(),
+	collection: SearchResultCollection.nullable()
+}).loose();
+const SearchResultCompact = SearchResult.pick({
+	id: true,
+	name: true,
+	model: true,
+	description: true,
+	archived: true
+}).strip();
+const searchResultView = {
+	compactPick: SearchResultCompact,
+	tableColumns: [
+		{
+			key: "id",
+			label: "ID"
+		},
+		{
+			key: "model",
+			label: "Model"
+		},
+		{
+			key: "name",
+			label: "Name"
+		},
+		{
+			key: "archived",
+			label: "Archived"
+		}
+	]
+};
+
+//#endregion
+//#region src/commands/search.ts
+const DEFAULT_LIMIT = 20;
+const SEARCH_MODELS_DESCRIPTION = `Comma-separated model filter: ${SEARCH_MODELS.join(",")}`;
+const SearchApiResponse = z.object({
+	data: z.array(SearchResult),
+	total: z.number().int().nonnegative(),
+	limit: z.number().int().nullable()
+}).loose();
+const SearchListEnvelope = listEnvelopeSchema(SearchResultCompact);
+var search_default = defineMetabaseCommand({
+	meta: {
+		name: "search",
+		description: "Search Metabase content (cards, dashboards, collections, …)"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		query: {
+			type: "positional",
+			description: "Search query string",
+			required: false
+		},
+		models: {
+			type: "string",
+			description: SEARCH_MODELS_DESCRIPTION,
+			alias: "m"
+		},
+		archived: {
+			type: "boolean",
+			description: "Include archived items",
+			default: false
+		},
+		limit: {
+			type: "string",
+			description: "Max results to return",
+			default: String(DEFAULT_LIMIT)
+		},
+		"table-db-id": {
+			type: "string",
+			description: "Restrict to items on a given database id"
+		},
+		verified: {
+			type: "boolean",
+			description: "Only verified content"
+		}
+	},
+	outputSchema: SearchListEnvelope,
+	examples: [
+		"metabase search orders",
+		"metabase search --models card,dashboard --limit 10 --json",
+		"metabase search products --archived"
+	],
+	async run({ args, ctx, getClient }) {
+		const limit = parseId(args.limit, "--limit");
+		const tableDbIdRaw = args["table-db-id"];
+		const tableDbId = tableDbIdRaw ? parseId(tableDbIdRaw, "--table-db-id") : void 0;
+		const models = parseModels(args.models);
+		const client = await getClient();
+		const response = await client.requestParsed(SearchApiResponse, "/api/search", { query: {
+			q: nonEmpty(args.query),
+			models,
+			archived: args.archived ? true : void 0,
+			limit,
+			table_db_id: tableDbId,
+			verified: args.verified ? true : void 0
+		} });
+		const envelope = {
+			data: response.data,
+			returned: response.data.length,
+			total: response.total,
+			limit: response.limit ?? void 0
+		};
+		renderList(envelope, searchResultView, ctx);
+	}
+});
+function nonEmpty(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? void 0 : trimmed;
+}
+function parseModels(raw) {
+	if (raw === void 0 || raw === "") return void 0;
+	const parts = parseCsv(raw);
+	if (parts.length === 0) return void 0;
+	const accepted = [];
+	const rejected = [];
+	for (const part of parts) {
+		const result = SearchModel.safeParse(part);
+		if (result.success) accepted.push(result.data);
+		else rejected.push(part);
+	}
+	if (rejected.length > 0) throw new ConfigError(`invalid --models value: ${rejected.join(", ")} (expected one of: ${SEARCH_MODELS.join(", ")})`);
+	return accepted;
+}
+
+//#endregion
+export { search_default as default };

package/dist/set-BZnCRL4c.mjs

@@ -0,0 +1,66 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem, warn } from "./render-DlBijc5i.mjs";
+import { ConfigError, defineMetabaseCommand, outputFlags, readEnvLicenseToken, writeLicense } from "./runtime-DUgFfYkN.mjs";
+import { readInput } from "./input-BNqSFl38.mjs";
+import { promptPassword } from "./prompt-fXeNtj0M.mjs";
+import { z } from "zod";
+
+//#region src/commands/license/set.ts
+const LicenseSetResult = z.object({ stored: z.literal(true) });
+const licenseSetView = {
+	compactPick: LicenseSetResult,
+	tableColumns: [{
+		key: "stored",
+		label: "Stored"
+	}]
+};
+var set_default = defineMetabaseCommand({
+	meta: {
+		name: "set",
+		description: "Store a Metabase license token"
+	},
+	args: {
+		...outputFlags,
+		token: {
+			type: "positional",
+			description: "License token (visible in shell history; pipe on stdin instead)",
+			required: false
+		}
+	},
+	outputSchema: LicenseSetResult,
+	examples: [
+		"echo $METABASE_LICENSE_TOKEN | metabase license set",
+		"metabase license set < token.txt",
+		"metabase license set $METABASE_LICENSE_TOKEN"
+	],
+	async run({ args, ctx }) {
+		const token = await resolveToken(args.token);
+		const location = await writeLicense(token);
+		if (location.backend === "file") warn(`warning: OS keychain unavailable; license stored as plaintext at ${location.path}`);
+		const result = { stored: true };
+		renderItem(result, licenseSetView, ctx);
+	}
+});
+async function resolveToken(positional) {
+	if (positional) {
+		warn("warning: license token passed as positional is visible in shell history and process listings — pipe the token on stdin or set METABASE_LICENSE_TOKEN instead");
+		return positional;
+	}
+	const piped = (await readInput({ required: false })).trim();
+	if (piped) return piped;
+	const envToken = readEnvLicenseToken();
+	if (envToken) return envToken;
+	return promptForToken();
+}
+async function promptForToken() {
+	if (!process.stdin.isTTY) throw new ConfigError("license token, piped stdin, or METABASE_LICENSE_TOKEN required when stdin is not a TTY");
+	return promptPassword({
+		message: "License token",
+		mask: "•",
+		validate: (input) => input ? void 0 : "License token is required"
+	});
+}
+
+//#endregion
+export { set_default as default };

package/dist/set-DCjrmTFm.mjs

@@ -0,0 +1,66 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-DUgFfYkN.mjs";
+import "./input-BNqSFl38.mjs";
+import { readBody } from "./body-DwU2s6Pg.mjs";
+import { SettingValue, settingValueView } from "./setting-DM7pm7yh.mjs";
+import { parseSettingKey } from "./key-CyhOpgWt.mjs";
+import { z } from "zod";
+
+//#region src/commands/setting/set.ts
+var set_default = defineMetabaseCommand({
+	meta: {
+		name: "set",
+		description: "Set a setting value (parsed strictly as JSON)"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		file: {
+			type: "string",
+			description: "Path to a file containing the JSON value"
+		},
+		key: {
+			type: "positional",
+			description: "Setting key",
+			required: true
+		},
+		value: {
+			type: "positional",
+			description: "JSON-encoded value",
+			required: false
+		}
+	},
+	outputSchema: SettingValue,
+	examples: [
+		`metabase setting set remote-sync-branch '"main"'`,
+		`metabase setting set anon-tracking-enabled true`,
+		`echo '"main"' | metabase setting set remote-sync-branch`,
+		`metabase setting set remote-sync-branch --file value.json`,
+		`metabase setting set remote-sync-branch null`
+	],
+	async run({ args, ctx, getClient }) {
+		const key = parseSettingKey(args.key);
+		const value = await readBody({
+			file: args.file,
+			positional: args.value,
+			source: `setting ${key} value`
+		}, z.unknown());
+		const client = await getClient();
+		await client.requestRaw(`/api/setting/${encodeURIComponent(key)}`, {
+			method: "PUT",
+			body: { value },
+			expectContentType: "binary"
+		});
+		const item = {
+			key,
+			value
+		};
+		renderItem(item, settingValueView, ctx);
+	}
+});
+
+//#endregion
+export { set_default as default };

package/dist/setting-C4vQSqer.mjs

@@ -0,0 +1,18 @@
+import { defineCommand } from "citty";
+
+//#region src/commands/setting/index.ts
+var setting_default = defineCommand({
+	meta: {
+		name: "setting",
+		description: "Inspect and update Metabase settings",
+		alias: "settings"
+	},
+	subCommands: {
+		list: () => import("./list-Y7iGsOfE.mjs").then((m) => m.default),
+		get: () => import("./get-CAVVmdMX.mjs").then((m) => m.default),
+		set: () => import("./set-DCjrmTFm.mjs").then((m) => m.default)
+	}
+});
+
+//#endregion
+export { setting_default as default };

package/dist/setting-DM7pm7yh.mjs

@@ -0,0 +1,55 @@
+import { z } from "zod";
+
+//#region src/domain/setting.ts
+const Setting = z.object({
+	key: z.string(),
+	value: z.unknown(),
+	is_env_setting: z.boolean(),
+	env_name: z.string(),
+	description: z.string(),
+	default: z.unknown()
+}).loose();
+const SettingCompact = Setting.pick({
+	key: true,
+	value: true,
+	is_env_setting: true,
+	env_name: true
+}).strip();
+const settingView = {
+	compactPick: SettingCompact,
+	tableColumns: [
+		{
+			key: "key",
+			label: "Key"
+		},
+		{
+			key: "value",
+			label: "Value"
+		},
+		{
+			key: "is_env_setting",
+			label: "From env"
+		},
+		{
+			key: "env_name",
+			label: "Env name"
+		}
+	]
+};
+const SettingValue = z.object({
+	key: z.string(),
+	value: z.unknown()
+});
+const settingValueView = {
+	compactPick: SettingValue,
+	tableColumns: [{
+		key: "key",
+		label: "Key"
+	}, {
+		key: "value",
+		label: "Value"
+	}]
+};
+
+//#endregion
+export { Setting, SettingCompact, SettingValue, settingValueView, settingView };

package/dist/setup-Dqh9hN6l.mjs

@@ -0,0 +1,70 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-DUgFfYkN.mjs";
+import "./input-BNqSFl38.mjs";
+import { readBody } from "./body-DwU2s6Pg.mjs";
+import { bodyInputFlags } from "./body-flags-7oqLhu5j.mjs";
+import { z } from "zod";
+
+//#region src/domain/setup.ts
+const SetupUserInput = z.object({
+	first_name: z.string().nullable().optional(),
+	last_name: z.string().nullable().optional(),
+	email: z.string().min(1),
+	password: z.string().min(1)
+}).loose();
+const SetupPrefsInput = z.object({
+	site_name: z.string().min(1),
+	site_locale: z.string().min(1).nullable().optional()
+}).loose();
+const SetupInput = z.object({
+	token: z.string().min(1),
+	user: SetupUserInput,
+	prefs: SetupPrefsInput
+}).loose();
+const SetupResult = z.object({ id: z.string() }).loose();
+const SetupResultCompact = SetupResult.pick({ id: true }).strip();
+const setupResultView = {
+	compactPick: SetupResultCompact,
+	tableColumns: [{
+		key: "id",
+		label: "Session"
+	}]
+};
+
+//#endregion
+//#region src/commands/setup.ts
+var setup_default = defineMetabaseCommand({
+	meta: {
+		name: "setup",
+		description: "Complete the initial Metabase setup wizard with a default user"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		...bodyInputFlags
+	},
+	outputSchema: SetupResult,
+	examples: [
+		"cat setup.json | metabase setup",
+		"metabase setup --file setup.json",
+		"metabase setup --body '{\"token\":\"...\",\"user\":{\"email\":\"a@b.c\",\"password\":\"...\"}}'"
+	],
+	async run({ args, ctx, getClient }) {
+		const body = await readBody({
+			flag: args.body,
+			file: args.file
+		}, SetupInput);
+		const client = await getClient();
+		const result = await client.requestParsed(SetupResult, "/api/setup", {
+			method: "POST",
+			body
+		});
+		renderItem(result, setupResultView, ctx);
+	}
+});
+
+//#endregion
+export { setup_default as default };