@metabase/cli 0.1.0 → 0.1.1

package/dist/start-BokXnb0V.mjs

@@ -0,0 +1,350 @@
+import "./package-DBsS7a5x.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem, warn } from "./render-DXv-D6fU.mjs";
+import { ConfigError, errorMessage } from "./predicates-DiIiS3k7.mjs";
+import { connectionFlags, createClient, defineMetabaseCommand, localUrl, outputFlags, parseInteger, parseOptionalInteger, profileFlag, resolveLicenseToken } from "./runtime-D7jihh81.mjs";
+import { parseId } from "./parse-id-BUOZQqjp.mjs";
+import { pollUntil } from "./poll-DMmmZWvi.mjs";
+import { Workspace } from "./workspace-DVuqKJGG.mjs";
+import { CONTAINER_REPO_DIR, checkDockerReady, containerLifecycleStatus, containerNameFor, pullImage, removeContainer, runProcess, runWorkspaceContainer, scrubContainerConfig, waitForConfigConsumed } from "./docker-D-ieBsP7.mjs";
+import { REPO_SYNC_MODES, RepoSyncMode, buildCredentialsJson, generateWorkspaceCredentials, injectCredentialsIntoConfig, injectRepoSettingsIntoConfig } from "./workspace-credentials-B6BL-X0d.mjs";
+import { z } from "zod";
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
+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 DEFAULT_IMAGE = "metabase/metabase-dev:feature-workspaces-v2";
+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 MetadataImportResult = z.object({ queued: z.literal(true) });
+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"
+	},
+	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: ${DEFAULT_IMAGE})`,
+			default: DEFAULT_IMAGE
+		},
+		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 and (with --wait) the /api/health probe. 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: [
+		"metabase workspace start 1",
+		"metabase workspace start 1 --wait",
+		"metabase workspace start 1 --port 3100",
+		"metabase workspace start 1 --image metabase/metabase-dev:feature-workspaces-v2 --no-pull",
+		"metabase workspace start 1 --force",
+		"metabase workspace start 1 --repo /path/to/sync-repo --wait",
+		"metabase workspace start 1 --repo /path/to/sync-repo --repo-branch dev --repo-mode read-only"
+	],
+	async run({ args, ctx, getClient, getResolvedConfig }) {
+		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({});
+		await checkDockerReady();
+		await ensureNoExistingContainer(workspaceId, containerName, args.force);
+		const pullPromise = args.pull ? pullImage(args.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 credentials = generateWorkspaceCredentials(workspaceId);
+		const configWithCredentials = injectCredentialsIntoConfig(parentConfigYaml, credentials);
+		const configYaml = repoOptions !== null ? injectRepoSettingsIntoConfig(configWithCredentials, repoOptions.repo) : configWithCredentials;
+		const credentialsJson = buildCredentialsJson(credentials);
+		await pullPromise;
+		await runWorkspaceContainer({
+			workspaceId,
+			workspaceName: workspace.name,
+			profile: resolved.profile,
+			parentUrl: resolved.url,
+			image: args.image,
+			hostPort,
+			configYaml,
+			credentialsJson,
+			licenseToken,
+			bindMounts: repoOptions === null ? [] : [repoOptions.bindMount]
+		});
+		await waitForConfigConsumed(workspaceId, readyTimeoutMs);
+		try {
+			await scrubContainerConfig(workspaceId);
+		} catch (error) {
+			warn(`could not scrub in-container config.yml: ${errorMessage(error)}`);
+		}
+		const needsHealth = args.wait || metadataJson !== null;
+		if (needsHealth) await waitForHealth(hostPort, readyTimeoutMs);
+		if (metadataJson !== null) await importMetadataIntoChild(hostPort, credentials, metadataJson);
+		const result = {
+			workspace_id: workspaceId,
+			workspace_name: workspace.name,
+			container_name: containerName,
+			state: needsHealth ? "running" : "starting",
+			host_port: hostPort,
+			url: localUrl(hostPort),
+			image: args.image
+		};
+		renderItem(result, startResultView, ctx);
+	}
+});
+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 \`metabase 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());
+}
+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) {
+	const childClient = createClient({
+		url: localUrl(hostPort),
+		apiKey: credentials.api_key.key
+	});
+	await childClient.requestParsed(MetadataImportResult, "/api/ee/serialization/metadata/import", {
+		method: "POST",
+		body: metadataJson,
+		timeoutMs: METADATA_IMPORT_TIMEOUT_MS
+	});
+}
+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/{stash-DOBbYozC.mjs → stash-CaGX6PfX.mjs}

@@ -1,12 +1,14 @@
-import "./package-BGfw4ZWJ.mjs";
+import "./package-DBsS7a5x.mjs";
 import "./command-augment-D9pI9Vbh.mjs";
-import { ConfigError, connectionFlags, defineMetabaseCommand, outputFlags, profileFlag, renderItem } from "./runtime-C9CEZhcn.mjs";
-import { parseId } from "./parse-id-BhmmfyCP.mjs";
-import { REMOTE_SYNC_PATHS, SyncTask, pollFlags, pollSyncTask, throwIfFailedTask } from "./poll-task-DbpsiQhl.mjs";
-import "./poll-ILanYysl.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import { ConfigError } from "./predicates-DiIiS3k7.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-D7jihh81.mjs";
+import { parseId } from "./parse-id-BUOZQqjp.mjs";
+import { REMOTE_SYNC_PATHS, SyncTask, pollFlags, pollSyncTask, throwIfFailedTask } from "./poll-task-2Ckiwp8U.mjs";
+import "./poll-DMmmZWvi.mjs";
 import { z } from "zod";
 
-//#region src/commands/sync/stash.ts
+//#region src/commands/git-sync/stash.ts
 const SyncStashKickoff = z.object({
 	status: z.literal("success"),
 	message: z.string(),
@@ -60,7 +62,7 @@ var stash_default = defineMetabaseCommand({
 		...pollFlags
 	},
 	outputSchema: SyncStashResult,
-	examples: ["metabase sync stash --new-branch wip", "metabase sync stash --new-branch wip -m \"work in progress\" --json"],
+	examples: ["metabase git-sync stash --new-branch wip", "metabase git-sync stash --new-branch wip -m \"work in progress\" --json"],
 	async run({ args, ctx, getClient }) {
 		const newBranch = args.newBranch.trim();
 		if (newBranch === "") throw new ConfigError("invalid new-branch: must not be blank");

package/dist/{status-Buf1ZbNR.mjs → status-BaX9vedb.mjs}

@@ -1,12 +1,14 @@
-import "./package-BGfw4ZWJ.mjs";
+import "./package-DBsS7a5x.mjs";
 import "./command-augment-D9pI9Vbh.mjs";
-import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag, renderItem } from "./runtime-C9CEZhcn.mjs";
-import { REMOTE_SYNC_PATHS, SyncTask, fetchCurrentTask, fetchOptionalParsed } from "./poll-task-DbpsiQhl.mjs";
-import "./poll-ILanYysl.mjs";
-import { IsDirtyResult } from "./is-dirty-1Qy7hiHB.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-D7jihh81.mjs";
+import { REMOTE_SYNC_PATHS, SyncTask, fetchCurrentTask, fetchOptionalParsed } from "./poll-task-2Ckiwp8U.mjs";
+import "./poll-DMmmZWvi.mjs";
+import { IsDirtyResult } from "./is-dirty-mgxEwEk4.mjs";
 import { z } from "zod";
 
-//#region src/commands/sync/status.ts
+//#region src/commands/git-sync/status.ts
 const RemoteSyncBranch = z.string().nullable();
 const SyncStatus = z.object({
 	branch: z.string().nullable(),
@@ -33,7 +35,7 @@ const syncStatusView = {
 var status_default = defineMetabaseCommand({
 	meta: {
 		name: "status",
-		description: "Show current sync state (branch, dirty, current task)"
+		description: "Show current git-sync state (branch, dirty, current task)"
 	},
 	args: {
 		...outputFlags,
@@ -41,7 +43,7 @@ var status_default = defineMetabaseCommand({
 		...connectionFlags
 	},
 	outputSchema: SyncStatus,
-	examples: ["metabase sync status", "metabase sync status --json"],
+	examples: ["metabase git-sync status", "metabase git-sync status --json"],
 	async run({ ctx, getClient }) {
 		const client = await getClient();
 		const [branch, isDirty, currentTask] = await Promise.all([

package/dist/{status-CUcs8XBH.mjs → status-CyecXzN4.mjs}

@@ -1,6 +1,8 @@
-import "./package-BGfw4ZWJ.mjs";
+import "./package-DBsS7a5x.mjs";
 import "./command-augment-D9pI9Vbh.mjs";
-import { account, credentials, defineMetabaseCommand, originOnly, outputFlags, profileFlag, renderItem, resolveProfileName } from "./runtime-C9CEZhcn.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { account, credentials, defineMetabaseCommand, originOnly, outputFlags, profileFlag, resolveProfileName } from "./runtime-D7jihh81.mjs";
 import { z } from "zod";
 
 //#region src/commands/auth/status.ts

package/dist/{status-D1F5XHae.mjs → status-RpVyPEty.mjs}

@@ -1,6 +1,8 @@
-import "./package-BGfw4ZWJ.mjs";
+import "./package-DBsS7a5x.mjs";
 import "./command-augment-D9pI9Vbh.mjs";
-import { account, credentials, defineMetabaseCommand, outputFlags, renderItem } from "./runtime-C9CEZhcn.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { account, credentials, defineMetabaseCommand, outputFlags } from "./runtime-D7jihh81.mjs";
 import { z } from "zod";
 
 //#region src/commands/license/status.ts

package/dist/stop-BRuF_Cg1.mjs

@@ -0,0 +1,81 @@
+import "./package-DBsS7a5x.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { defineMetabaseCommand, outputFlags } from "./runtime-D7jihh81.mjs";
+import { parseId } from "./parse-id-BUOZQqjp.mjs";
+import "./poll-DMmmZWvi.mjs";
+import { checkDockerReady, containerLifecycleStatus, containerNameFor, stopContainer } from "./docker-D-ieBsP7.mjs";
+import { LocalWorkspaceState } from "./ps-Yv0JjLVN.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)"
+	},
+	args: {
+		...outputFlags,
+		id: {
+			type: "positional",
+			description: "Workspace id",
+			required: true
+		}
+	},
+	outputSchema: StopResult,
+	examples: ["metabase workspace stop 1", "metabase 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/summary-CpEOiOlZ.mjs

@@ -0,0 +1,41 @@
+import "./package-DBsS7a5x.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-D7jihh81.mjs";
+import { parseId } from "./parse-id-BUOZQqjp.mjs";
+import { FieldSummary, FieldSummaryRaw, fieldSummaryView } from "./field-DciLbuv-.mjs";
+
+//#region src/commands/field/summary.ts
+var summary_default = defineMetabaseCommand({
+	meta: {
+		name: "summary",
+		description: "Get the row count and distinct count for a field"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		id: {
+			type: "positional",
+			description: "Field id",
+			required: true
+		}
+	},
+	outputSchema: FieldSummary,
+	examples: ["metabase field summary 100", "metabase field summary 100 --json"],
+	async run({ args, ctx, getClient }) {
+		const id = parseId(args.id);
+		const client = await getClient();
+		const [[, count], [, distincts]] = await client.requestParsed(FieldSummaryRaw, `/api/field/${id}/summary`);
+		const summary = {
+			field_id: id,
+			count,
+			distincts
+		};
+		renderItem(summary, fieldSummaryView, ctx);
+	}
+});
+
+//#endregion
+export { summary_default as default };

package/dist/sync-schema-4Cl4h8Jn.mjs

@@ -0,0 +1,43 @@
+import "./package-DBsS7a5x.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DXv-D6fU.mjs";
+import "./predicates-DiIiS3k7.mjs";
+import { connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-D7jihh81.mjs";
+import { parseId } from "./parse-id-BUOZQqjp.mjs";
+import "./field-DciLbuv-.mjs";
+import "./table-jljEqZ0R.mjs";
+import { DatabaseSyncResult, databaseSyncResultView } from "./database-Dvkfy3JM.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"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		id: {
+			type: "positional",
+			description: "Database id",
+			required: true
+		}
+	},
+	outputSchema: DatabaseSyncResult,
+	examples: ["metabase db sync-schema 1", "metabase 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" });
+		renderItem({
+			id,
+			status: response.status
+		}, databaseSyncResultView, ctx);
+	}
+});
+
+//#endregion
+export { sync_schema_default as default };

package/dist/table-BeMWuvzO.mjs

@@ -0,0 +1,19 @@
+import { defineCommand } from "citty";
+
+//#region src/commands/table/index.ts
+var table_default = defineCommand({
+	meta: {
+		name: "table",
+		description: "Inspect Metabase tables"
+	},
+	subCommands: {
+		list: () => import("./list-DD8CQx8l.mjs").then((m) => m.default),
+		get: () => import("./get-DczxeETg.mjs").then((m) => m.default),
+		metadata: () => import("./metadata-CLIALntn.mjs").then((m) => m.default),
+		fields: () => import("./fields-Do8HHm_T.mjs").then((m) => m.default),
+		update: () => import("./update-BCXKQi2n.mjs").then((m) => m.default)
+	}
+});
+
+//#endregion
+export { table_default as default };