@metabase/cli 0.1.0 → 0.1.1

package/dist/docker-D-ieBsP7.mjs

@@ -0,0 +1,612 @@
+import { ConfigError, MetabaseError, errorMessage, isNotFoundError } from "./predicates-DiIiS3k7.mjs";
+import { parseJson } from "./runtime-D7jihh81.mjs";
+import { pollUntil } from "./poll-DMmmZWvi.mjs";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+
+//#region src/runtime/process.ts
+var ProcessNotFoundError = class extends Error {
+	command;
+	constructor(command) {
+		super(`command not found: ${command}`);
+		this.name = "ProcessNotFoundError";
+		this.command = command;
+	}
+};
+var ProcessTimeoutError = class extends Error {
+	command;
+	timeoutMs;
+	constructor(command, timeoutMs) {
+		super(`command timed out after ${timeoutMs}ms: ${command}`);
+		this.name = "ProcessTimeoutError";
+		this.command = command;
+		this.timeoutMs = timeoutMs;
+	}
+};
+function spawnAndCollect(command, args, options) {
+	const timeoutSignal = options.timeoutMs !== void 0 && options.timeoutMs > 0 ? AbortSignal.timeout(options.timeoutMs) : void 0;
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			env: options.env ?? process.env,
+			...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+			...timeoutSignal !== void 0 ? {
+				signal: timeoutSignal,
+				killSignal: "SIGKILL"
+			} : {}
+		});
+		const stdoutChunks = [];
+		let stderr = "";
+		child.stdout.on("data", (chunk) => {
+			stdoutChunks.push(chunk);
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr += chunk.toString("utf8");
+		});
+		child.on("error", (error) => {
+			if (isNotFoundError(error)) {
+				reject(new ProcessNotFoundError(command));
+				return;
+			}
+			if (timeoutSignal?.aborted) {
+				reject(new ProcessTimeoutError(command, options.timeoutMs ?? 0));
+				return;
+			}
+			reject(error);
+		});
+		child.on("close", (code) => {
+			if (timeoutSignal?.aborted) {
+				reject(new ProcessTimeoutError(command, options.timeoutMs ?? 0));
+				return;
+			}
+			const stdoutBuffer = Buffer.concat(stdoutChunks);
+			resolve({
+				stdout: new Uint8Array(stdoutBuffer.buffer, stdoutBuffer.byteOffset, stdoutBuffer.length),
+				stderr,
+				exitCode: code
+			});
+		});
+		if (options.stdin === void 0) child.stdin.end();
+		else child.stdin.end(options.stdin);
+	});
+}
+const stdoutDecoder = new TextDecoder("utf-8");
+async function runProcess(command, args, options = {}) {
+	const result = await spawnAndCollect(command, args, options);
+	return {
+		stdout: stdoutDecoder.decode(result.stdout),
+		stderr: result.stderr,
+		exitCode: result.exitCode
+	};
+}
+function runProcessBinary(command, args, options = {}) {
+	return spawnAndCollect(command, args, options);
+}
+function streamProcess(command, args) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, { stdio: "inherit" });
+		child.on("error", (error) => {
+			if (isNotFoundError(error)) {
+				reject(new ProcessNotFoundError(command));
+				return;
+			}
+			reject(error);
+		});
+		child.on("close", (code) => resolve(code));
+	});
+}
+
+//#endregion
+//#region src/runtime/tar.ts
+const BLOCK_SIZE = 512;
+const REGULAR_FILE_MODE = 420;
+const DIR_MODE = 493;
+const NAME_FIELD_LENGTH = 100;
+const TYPE_FLAG_REGULAR = "0";
+const TYPE_FLAG_DIRECTORY = "5";
+const textEncoder = new TextEncoder();
+function toBytes(content) {
+	return typeof content === "string" ? textEncoder.encode(content) : content;
+}
+function writeOctal(target, offset, length, value) {
+	const digits = length - 1;
+	const octal = Math.trunc(value).toString(8).padStart(digits, "0");
+	if (octal.length > digits) throw new Error(`tar value ${value} exceeds octal field width ${digits}`);
+	for (let i = 0; i < digits; i++) target[offset + i] = octal.charCodeAt(i);
+	target[offset + length - 1] = 0;
+}
+function writeString(target, offset, length, value) {
+	const bytes = textEncoder.encode(value);
+	if (bytes.length > length) throw new Error(`tar string field of length ${length} cannot hold ${bytes.length} bytes`);
+	target.set(bytes, offset);
+}
+function writeHeader(out, offset, name, size, mode, mtime, typeFlag) {
+	if (textEncoder.encode(name).length > NAME_FIELD_LENGTH) throw new Error(`tar entry name exceeds ${NAME_FIELD_LENGTH} bytes: ${name}`);
+	writeString(out, offset, NAME_FIELD_LENGTH, name);
+	writeOctal(out, offset + 100, 8, mode & 4095);
+	writeOctal(out, offset + 108, 8, 0);
+	writeOctal(out, offset + 116, 8, 0);
+	writeOctal(out, offset + 124, 12, size);
+	writeOctal(out, offset + 136, 12, mtime);
+	for (let i = 148; i < 156; i++) out[offset + i] = 32;
+	out[offset + 156] = typeFlag.charCodeAt(0);
+	writeString(out, offset + 257, 6, "ustar");
+	out[offset + 263] = 48;
+	out[offset + 264] = 48;
+	let sum = 0;
+	for (const byte of out.subarray(offset, offset + BLOCK_SIZE)) sum += byte;
+	const sumOctal = sum.toString(8).padStart(6, "0");
+	for (let i = 0; i < 6; i++) out[offset + 148 + i] = sumOctal.charCodeAt(i);
+	out[offset + 154] = 0;
+	out[offset + 155] = 32;
+}
+function paddedSize(size) {
+	const remainder = size % BLOCK_SIZE;
+	return remainder === 0 ? 0 : BLOCK_SIZE - remainder;
+}
+function resolveEntry(entry, fallbackMtime) {
+	if (entry.type === "directory") {
+		const name = entry.name.endsWith("/") ? entry.name : `${entry.name}/`;
+		return {
+			name,
+			mode: entry.mode ?? DIR_MODE,
+			mtime: entry.mtime ?? fallbackMtime,
+			typeFlag: TYPE_FLAG_DIRECTORY,
+			content: null
+		};
+	}
+	return {
+		name: entry.name,
+		mode: entry.mode ?? REGULAR_FILE_MODE,
+		mtime: entry.mtime ?? fallbackMtime,
+		typeFlag: TYPE_FLAG_REGULAR,
+		content: toBytes(entry.content)
+	};
+}
+var TarParseError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "TarParseError";
+	}
+};
+const SIZE_FIELD_OFFSET = 124;
+const SIZE_FIELD_LENGTH = 12;
+const textDecoder = new TextDecoder("utf-8");
+function readNullTerminatedString(buffer, offset, length) {
+	const slice = buffer.subarray(offset, offset + length);
+	const nul = slice.indexOf(0);
+	const end = nul === -1 ? slice.length : nul;
+	return textDecoder.decode(slice.subarray(0, end));
+}
+function extractSingleFileFromTar(tar, expectedNameSuffix) {
+	if (tar.length < BLOCK_SIZE) throw new TarParseError(`tar is shorter than one block: ${tar.length} bytes`);
+	const nameField = readNullTerminatedString(tar, 0, NAME_FIELD_LENGTH);
+	if (!nameField.endsWith(expectedNameSuffix)) throw new TarParseError(`unexpected tar entry ${JSON.stringify(nameField)}, expected to end with ${JSON.stringify(expectedNameSuffix)}`);
+	const sizeField = readNullTerminatedString(tar, SIZE_FIELD_OFFSET, SIZE_FIELD_LENGTH).trim();
+	const size = Number.parseInt(sizeField, 8);
+	if (!Number.isFinite(size) || size < 0) throw new TarParseError(`tar header has invalid size field: ${JSON.stringify(sizeField)}`);
+	if (tar.length < BLOCK_SIZE + size) throw new TarParseError(`tar truncated: header reports ${size} content bytes but only ${tar.length - BLOCK_SIZE} bytes follow`);
+	return tar.subarray(BLOCK_SIZE, BLOCK_SIZE + size);
+}
+function buildTar(entries) {
+	const fallbackMtime = Math.floor(Date.now() / 1e3);
+	const resolved = entries.map((entry) => resolveEntry(entry, fallbackMtime));
+	let total = BLOCK_SIZE * 2;
+	for (const entry of resolved) {
+		total += BLOCK_SIZE;
+		if (entry.content !== null) total += entry.content.length + paddedSize(entry.content.length);
+	}
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const entry of resolved) {
+		const size = entry.content?.length ?? 0;
+		writeHeader(out, offset, entry.name, size, entry.mode, entry.mtime, entry.typeFlag);
+		offset += BLOCK_SIZE;
+		if (entry.content !== null) {
+			out.set(entry.content, offset);
+			offset += entry.content.length + paddedSize(entry.content.length);
+		}
+	}
+	return out;
+}
+
+//#endregion
+//#region src/core/docker.ts
+const DOCKER_BIN = "docker";
+const CONTAINER_NAME_PREFIX = "metabase-workspace-";
+const VOLUME_NAME_SUFFIX = "-appdb";
+const LABEL_ID = "com.metabase.workspace.id";
+const LABEL_NAME = "com.metabase.workspace.name";
+const LABEL_PROFILE = "com.metabase.workspace.profile";
+const LABEL_PARENT = "com.metabase.workspace.parent";
+const LABEL_IMAGE = "com.metabase.workspace.image";
+const LABEL_HOST_PORT = "com.metabase.workspace.host-port";
+const WORKSPACE_CONTAINER_PORT = 3e3;
+const CONTAINER_CONFIG_DIR = "/mw-config";
+const CONTAINER_CONFIG_DIR_BASENAME = CONTAINER_CONFIG_DIR.replace(/^\//, "");
+const CONTAINER_APP_DB_DIR = "/metabase-app-db";
+const CONTAINER_REPO_DIR = "/mnt/repo";
+const CONFIG_FILENAME = "config.yml";
+const CREDENTIALS_FILENAME = "credentials.json";
+const CONFIG_CONSUMED_MARKER = "Loaded workspace";
+const INIT_FAILED_MARKER = "Metabase Initialization FAILED";
+const CONFIG_CONSUMED_LOG_LINES = 500;
+const CONFIG_CONSUMED_INTERVAL_MS = 1e3;
+const CONFIG_CONSUMED_MAX_INTERVAL_MS = 3e3;
+const INIT_FAILED_TAIL_LINES = 25;
+const BUNDLE_FILE_MODE = 420;
+const NO_SUCH_CONTAINER_PATTERN = /no such container/i;
+const NO_SUCH_VOLUME_PATTERN = /no such volume/i;
+const CONTAINER_STATES = [
+	"running",
+	"exited",
+	"created",
+	"paused",
+	"restarting",
+	"removing",
+	"dead"
+];
+var DockerError = class extends MetabaseError {
+	category = "docker";
+	isRetryable = false;
+	exitCode = 1;
+	developerDetail;
+	stderr;
+	constructor(message, dockerExitCode, stderr) {
+		super(message);
+		this.name = "DockerError";
+		this.developerDetail = {
+			dockerExitCode,
+			stderr
+		};
+		this.stderr = stderr;
+	}
+	get userMessage() {
+		const trimmed = this.stderr.trim();
+		if (trimmed === "") return this.message;
+		return `${this.message}\n${indentLines(trimmed)}`;
+	}
+};
+function indentLines(text) {
+	return text.split("\n").map((line) => `  ${line}`).join("\n");
+}
+var DockerNotInstalledError = class extends Error {
+	constructor() {
+		super("docker is not installed or not on PATH — install Docker Desktop / OrbStack / Colima and retry");
+		this.name = "DockerNotInstalledError";
+	}
+};
+var DockerNotRunningError = class extends Error {
+	stderr;
+	constructor(stderr) {
+		super("docker is installed but the daemon is not responding — start Docker and retry");
+		this.name = "DockerNotRunningError";
+		this.stderr = stderr;
+	}
+};
+const ContainerSummarySchema = z.object({
+	ID: z.string(),
+	Names: z.string(),
+	State: z.string(),
+	Status: z.string(),
+	Image: z.string(),
+	Labels: z.string(),
+	Ports: z.string()
+});
+function containerNameFor(workspaceId) {
+	return `${CONTAINER_NAME_PREFIX}${workspaceId}`;
+}
+function volumeNameFor(workspaceId) {
+	return `${CONTAINER_NAME_PREFIX}${workspaceId}${VOLUME_NAME_SUFFIX}`;
+}
+async function dockerExec(args, options = {}) {
+	try {
+		return await runProcess(DOCKER_BIN, args, options);
+	} catch (error) {
+		if (error instanceof ProcessNotFoundError) throw new DockerNotInstalledError();
+		throw error;
+	}
+}
+async function runDocker(args, failureMessage, options = {}) {
+	const { ignorePattern,...execOptions } = options;
+	const result = await dockerExec(args, execOptions);
+	if (result.exitCode === 0) return result;
+	if (ignorePattern?.test(result.stderr)) return result;
+	throw new DockerError(failureMessage, result.exitCode, result.stderr);
+}
+async function checkDockerReady() {
+	let result;
+	try {
+		result = await runProcess(DOCKER_BIN, [
+			"version",
+			"--format",
+			"{{.Server.Version}}"
+		]);
+	} catch (error) {
+		if (error instanceof ProcessNotFoundError) throw new DockerNotInstalledError();
+		throw error;
+	}
+	if (result.exitCode !== 0) throw new DockerNotRunningError(result.stderr);
+}
+async function pullImage(image) {
+	const code = await streamProcess(DOCKER_BIN, ["pull", image]);
+	if (code !== 0) throw new DockerError(`docker pull ${image} failed`, code, "");
+}
+async function containerLifecycleStatus(containerName) {
+	const result = await runDocker([
+		"ps",
+		"-a",
+		"--filter",
+		`name=^${containerName}$`,
+		"--format",
+		"{{.State}}"
+	], "docker ps failed");
+	const trimmed = result.stdout.trim();
+	if (trimmed.length === 0) return "missing";
+	return parseContainerState(trimmed);
+}
+function parseContainerState(raw) {
+	const lower = raw.toLowerCase();
+	for (const known of CONTAINER_STATES) if (known === lower) return known;
+	throw new DockerError(`unknown docker container state: ${JSON.stringify(raw)}`, null, "");
+}
+async function runWorkspaceContainer(spec) {
+	const containerName = containerNameFor(spec.workspaceId);
+	await createContainer({
+		containerName,
+		image: spec.image,
+		port: {
+			hostPort: spec.hostPort,
+			containerPort: WORKSPACE_CONTAINER_PORT
+		},
+		namedVolumes: [{
+			volume: volumeNameFor(spec.workspaceId),
+			container: CONTAINER_APP_DB_DIR
+		}],
+		bindMounts: spec.bindMounts,
+		envVars: workspaceContainerEnv(spec),
+		labels: workspaceContainerLabels(spec)
+	});
+	try {
+		await copyTarToContainer(containerName, "/", buildBootBundleTar(spec));
+		await startContainer(containerName);
+	} catch (error) {
+		await removeContainer(containerName).catch(() => void 0);
+		throw error;
+	}
+}
+async function scrubContainerConfig(workspaceId) {
+	const containerName = containerNameFor(workspaceId);
+	await runDocker([
+		"exec",
+		containerName,
+		"rm",
+		"-f",
+		`${CONTAINER_CONFIG_DIR}/${CONFIG_FILENAME}`
+	], `docker exec rm config.yml failed for ${containerName}`);
+}
+async function waitForConfigConsumed(workspaceId, timeoutMs) {
+	const containerName = containerNameFor(workspaceId);
+	await pollUntil(async () => {
+		const result = await dockerExec([
+			"logs",
+			"--tail",
+			String(CONFIG_CONSUMED_LOG_LINES),
+			containerName
+		]);
+		const haystack = `${result.stdout}\n${result.stderr}`;
+		if (haystack.includes(INIT_FAILED_MARKER)) {
+			const tail = haystack.split("\n").slice(-INIT_FAILED_TAIL_LINES).join("\n");
+			throw new DockerError(`workspace ${workspaceId} container failed Metabase initialization`, null, tail);
+		}
+		return haystack.includes(CONFIG_CONSUMED_MARKER);
+	}, (consumed) => consumed, {
+		intervalMs: CONFIG_CONSUMED_INTERVAL_MS,
+		maxIntervalMs: CONFIG_CONSUMED_MAX_INTERVAL_MS,
+		backoff: "exponential",
+		timeoutMs
+	});
+}
+async function readContainerCredentialsFile(workspaceId) {
+	const containerName = containerNameFor(workspaceId);
+	const result = await runProcessBinary(DOCKER_BIN, [
+		"cp",
+		`${containerName}:${CONTAINER_CONFIG_DIR}/${CREDENTIALS_FILENAME}`,
+		"-"
+	]);
+	if (result.exitCode !== 0) {
+		if (NO_SUCH_CONTAINER_PATTERN.test(result.stderr)) throw new DockerError(`no container for workspace ${workspaceId}`, result.exitCode, result.stderr);
+		throw new DockerError(`docker cp ${CREDENTIALS_FILENAME} from ${containerName} failed`, result.exitCode, result.stderr);
+	}
+	return extractSingleFileFromTar(result.stdout, CREDENTIALS_FILENAME);
+}
+function buildBootBundleTar(spec) {
+	const entries = [
+		{
+			type: "directory",
+			name: CONTAINER_CONFIG_DIR_BASENAME
+		},
+		{
+			type: "file",
+			name: `${CONTAINER_CONFIG_DIR_BASENAME}/${CONFIG_FILENAME}`,
+			content: spec.configYaml,
+			mode: BUNDLE_FILE_MODE
+		},
+		{
+			type: "file",
+			name: `${CONTAINER_CONFIG_DIR_BASENAME}/${CREDENTIALS_FILENAME}`,
+			content: spec.credentialsJson,
+			mode: BUNDLE_FILE_MODE
+		}
+	];
+	return buildTar(entries);
+}
+function workspaceContainerLabels(spec) {
+	return {
+		[LABEL_ID]: String(spec.workspaceId),
+		[LABEL_NAME]: spec.workspaceName,
+		[LABEL_PROFILE]: spec.profile,
+		[LABEL_PARENT]: spec.parentUrl,
+		[LABEL_IMAGE]: spec.image,
+		[LABEL_HOST_PORT]: String(spec.hostPort)
+	};
+}
+function workspaceContainerEnv(spec) {
+	return {
+		MB_CONFIG_FILE_PATH: `${CONTAINER_CONFIG_DIR}/${CONFIG_FILENAME}`,
+		MB_PREMIUM_EMBEDDING_TOKEN: spec.licenseToken,
+		MB_DB_FILE: `${CONTAINER_APP_DB_DIR}/metabase.db`,
+		MB_DISABLE_SCHEDULER: "true",
+		JAVA_OPTS: "-Xmx2g"
+	};
+}
+async function createContainer(options) {
+	const args = [
+		"create",
+		"--name",
+		options.containerName,
+		"-p",
+		`${options.port.hostPort}:${options.port.containerPort}`
+	];
+	for (const [key, value] of Object.entries(options.labels)) args.push("--label", `${key}=${value}`);
+	for (const mount of options.namedVolumes) args.push("-v", `${mount.volume}:${mount.container}`);
+	for (const bind of options.bindMounts) args.push("-v", `${bind.hostPath}:${bind.containerPath}:${bind.readOnly ? "ro" : "rw"}`);
+	for (const key of Object.keys(options.envVars)) args.push("-e", key);
+	args.push(options.image);
+	const env = {
+		...process.env,
+		...options.envVars
+	};
+	await runDocker(args, `docker create failed for ${options.containerName}`, { env });
+}
+async function copyTarToContainer(containerName, destPath, tarBytes) {
+	await runDocker([
+		"cp",
+		"-",
+		`${containerName}:${destPath}`
+	], `docker cp into ${containerName}:${destPath} failed`, { stdin: tarBytes });
+}
+async function startContainer(containerName) {
+	await runDocker(["start", containerName], `docker start failed for ${containerName}`);
+}
+async function stopContainer(containerName) {
+	await runDocker(["stop", containerName], `docker stop ${containerName} failed`, { ignorePattern: NO_SUCH_CONTAINER_PATTERN });
+}
+async function removeContainer(containerName) {
+	const result = await runDocker([
+		"rm",
+		"-f",
+		containerName
+	], `docker rm ${containerName} failed`, { ignorePattern: NO_SUCH_CONTAINER_PATTERN });
+	return result.exitCode === 0;
+}
+async function removeVolume(volumeName) {
+	const result = await runDocker([
+		"volume",
+		"rm",
+		volumeName
+	], `docker volume rm ${volumeName} failed`, { ignorePattern: NO_SUCH_VOLUME_PATTERN });
+	return result.exitCode === 0;
+}
+async function listWorkspaceContainers() {
+	const result = await runDocker([
+		"ps",
+		"-a",
+		"--filter",
+		`label=${LABEL_ID}`,
+		"--format",
+		"{{json .}}"
+	], "docker ps failed");
+	return parseContainerLines(result.stdout);
+}
+async function inspectWorkspaceContainer(containerName) {
+	const result = await runDocker([
+		"ps",
+		"-a",
+		"--filter",
+		`name=^${containerName}$`,
+		"--filter",
+		`label=${LABEL_ID}`,
+		"--format",
+		"{{json .}}"
+	], "docker ps failed");
+	const summaries = parseContainerLines(result.stdout);
+	return summaries[0] ?? null;
+}
+async function requireWorkspaceContainerLocation(workspaceId) {
+	const containerName = containerNameFor(workspaceId);
+	const summary = await inspectWorkspaceContainer(containerName);
+	if (summary === null) throw new ConfigError(`no container for workspace ${workspaceId} — run \`metabase workspace start ${workspaceId}\` first`);
+	if (summary.hostPort === null) throw new ConfigError(`container ${containerName} is missing the host-port label — likely created by a different tool`);
+	return {
+		containerName,
+		hostPort: summary.hostPort
+	};
+}
+function streamLogs(containerName, options) {
+	const args = [
+		"logs",
+		"--tail",
+		String(options.tail)
+	];
+	if (options.follow) args.push("--follow");
+	args.push(containerName);
+	return streamProcess(DOCKER_BIN, args);
+}
+function parseContainerLines(stdout) {
+	const lines = stdout.split("\n").filter((line) => line.trim().length > 0);
+	const summaries = [];
+	for (const line of lines) {
+		const summary = parseContainerLine(line);
+		if (summary !== null) summaries.push(summary);
+	}
+	return summaries;
+}
+function parseContainerLine(line) {
+	let raw;
+	try {
+		raw = parseJson(line, z.unknown(), { source: "docker" });
+	} catch (error) {
+		throw new DockerError(`could not parse docker output: ${errorMessage(error)}`, null, line);
+	}
+	const parsed = ContainerSummarySchema.safeParse(raw);
+	if (!parsed.success) return null;
+	const labels = parseLabels(parsed.data.Labels);
+	const idLabel = labels[LABEL_ID];
+	const nameLabel = labels[LABEL_NAME];
+	if (idLabel === void 0 || nameLabel === void 0) return null;
+	const idNum = Number.parseInt(idLabel, 10);
+	if (!Number.isFinite(idNum) || idNum < 1) return null;
+	const portLabel = labels[LABEL_HOST_PORT];
+	const portNum = portLabel !== void 0 ? Number.parseInt(portLabel, 10) : Number.NaN;
+	return {
+		containerId: parsed.data.ID,
+		name: parsed.data.Names,
+		state: parseContainerState(parsed.data.State),
+		status: parsed.data.Status,
+		image: parsed.data.Image,
+		workspaceId: idNum,
+		workspaceName: nameLabel,
+		profile: labels[LABEL_PROFILE] ?? null,
+		parentUrl: labels[LABEL_PARENT] ?? null,
+		hostPort: Number.isFinite(portNum) ? portNum : null
+	};
+}
+function parseLabels(raw) {
+	const out = {};
+	for (const pair of raw.split(",")) {
+		const eq = pair.indexOf("=");
+		if (eq === -1) continue;
+		const key = pair.slice(0, eq);
+		const value = pair.slice(eq + 1);
+		if (key.length > 0) out[key] = value;
+	}
+	return out;
+}
+
+//#endregion
+export { CONTAINER_REPO_DIR, CONTAINER_STATES, checkDockerReady, containerLifecycleStatus, containerNameFor, listWorkspaceContainers, pullImage, readContainerCredentialsFile, removeContainer, removeVolume, requireWorkspaceContainerLocation, runProcess, runWorkspaceContainer, scrubContainerConfig, stopContainer, streamLogs, volumeNameFor, waitForConfigConsumed };

package/dist/eid-pvOsEMPZ.mjs

@@ -0,0 +1,13 @@
+import { defineCommand } from "citty";
+
+//#region src/commands/eid/index.ts
+var eid_default = defineCommand({
+	meta: {
+		name: "eid",
+		description: "Translate Metabase entity ids (string EIDs) to numeric ids"
+	},
+	subCommands: { translate: () => import("./translate-DqLlXXUx.mjs").then((mod) => mod.default) }
+});
+
+//#endregion
+export { eid_default as default };

package/dist/{export-QDkuuzSE.mjs → export-BjGhLEOi.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 { 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, warn } 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 { REMOTE_SYNC_PATHS, SyncTask, pollFlags, pollSyncTask, throwIfFailedTask } from "./poll-task-2Ckiwp8U.mjs";
+import "./poll-DMmmZWvi.mjs";
 import { z } from "zod";
 
-//#region src/commands/sync/export.ts
+//#region src/commands/git-sync/export.ts
 const SyncExportKickoff = z.object({
 	message: z.string(),
 	task_id: z.number().int().positive()
@@ -54,9 +56,9 @@ var export_default = defineMetabaseCommand({
 	},
 	outputSchema: SyncExportResult,
 	examples: [
-		"metabase sync export -m \"update dashboards\"",
-		"metabase sync export --branch main --json",
-		"metabase sync export --no-wait"
+		"metabase git-sync export -m \"update dashboards\"",
+		"metabase git-sync export --branch main --json",
+		"metabase git-sync export --no-wait"
 	],
 	async run({ args, ctx, getClient }) {
 		const timeoutMs = parseId(args.timeout, "timeout");
@@ -71,26 +73,31 @@ var export_default = defineMetabaseCommand({
 			body
 		});
 		if (!args.wait) {
-			const result$1 = {
+			const result = {
 				message: kickoff.message,
 				task_id: kickoff.task_id
 			};
-			renderItem(result$1, syncExportView, ctx);
-			return;
+			renderItem(result, syncExportView, ctx);
+		} else {
+			const final = await pollSyncTask(client, {
+				timeoutMs,
+				intervalMs
+			});
+			const result = {
+				message: kickoff.message,
+				task_id: kickoff.task_id,
+				final
+			};
+			renderItem(result, syncExportView, ctx);
+			throwIfFailedTask(final, "export");
 		}
-		const final = await pollSyncTask(client, {
-			timeoutMs,
-			intervalMs
-		});
-		const result = {
-			message: kickoff.message,
-			task_id: kickoff.task_id,
-			final
-		};
-		renderItem(result, syncExportView, ctx);
-		throwIfFailedTask(final, "export");
+		emitRealignHint(ctx);
 	}
 });
+function emitRealignHint(ctx) {
+	if (ctx.format !== "text") return;
+	warn("\nNote: if exporting to a host-bound repo, realign the host working tree with:\n  git -C <repo-path> restore --staged --worktree .");
+}
 
 //#endregion
 export { export_default as default };