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

package/dist/start-xXQypG5L.mjs

@@ -0,0 +1,324 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem, warn } from "./render-DlBijc5i.mjs";
+import { ConfigError, connectionFlags, defineMetabaseCommand, errorMessage, localUrl, outputFlags, parseInteger, parseOptionalInteger, profileFlag, resolveLicenseToken } from "./runtime-DUgFfYkN.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import { pollUntil } from "./poll-D2sXM5rc.mjs";
+import { Workspace } from "./workspace-Dr9lWU3D.mjs";
+import { CONTAINER_REPO_DIR, checkDockerReady, containerLifecycleStatus, containerNameFor, pullImage, removeContainer, runProcess, runWorkspaceContainer, scrubContainerConfig, waitForConfigConsumed } from "./docker-QWVMG2gl.mjs";
+import { REPO_SYNC_MODES, RepoSyncMode, buildCredentialsJson, generateWorkspaceCredentials, injectCredentialsIntoConfig, injectRepoSettingsIntoConfig } from "./workspace-credentials-q5RRFMT8.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, "127.0.0.1");
+	});
+}
+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_HEALTH_TIMEOUT_MS = 18e4;
+const DEFAULT_CONFIG_CONSUMED_TIMEOUT_MS = 6e4;
+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 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 if taken)`
+		},
+		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.",
+			default: false
+		},
+		timeout: {
+			type: "string",
+			description: `Health check deadline in ms (used with --wait; default: ${DEFAULT_HEALTH_TIMEOUT_MS})`,
+			default: String(DEFAULT_HEALTH_TIMEOUT_MS)
+		},
+		pull: {
+			type: "boolean",
+			description: "Pull the image before starting",
+			default: true
+		},
+		metadata: {
+			type: "boolean",
+			description: "Fetch the workspace's warehouse metadata and stage it inside the container",
+			default: true
+		},
+		force: {
+			type: "boolean",
+			description: "If a container for this workspace already exists, remove it first",
+			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 healthTimeoutMs = parseInteger(args.timeout ?? String(DEFAULT_HEALTH_TIMEOUT_MS), {
+			name: "--timeout",
+			min: 1e3
+		});
+		const client = await getClient();
+		const resolved = await getResolvedConfig();
+		const licenseToken = await resolveLicenseToken({});
+		await checkDockerReady();
+		await ensureNoExistingContainer(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,
+			metadataJson,
+			licenseToken,
+			bindMounts: repoOptions === null ? [] : [repoOptions.bindMount]
+		});
+		await waitForConfigConsumed(workspaceId, DEFAULT_CONFIG_CONSUMED_TIMEOUT_MS);
+		try {
+			await scrubContainerConfig(workspaceId);
+		} catch (error) {
+			warn(`could not scrub in-container config.yml: ${errorMessage(error)}`);
+		}
+		if (args.wait) await waitForHealth(hostPort, healthTimeoutMs);
+		const result = {
+			workspace_id: workspaceId,
+			workspace_name: workspace.name,
+			container_name: containerName,
+			state: args.wait ? "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(containerName, force) {
+	if (!force) {
+		const status = await containerLifecycleStatus(containerName);
+		if (status !== "missing") throw new ConfigError(`container ${containerName} already exists (state=${status}). Use --force to recreate, or stop/remove it first.`);
+		return;
+	}
+	await removeContainer(containerName);
+}
+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" });
+	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 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-ZZkmW_V7.mjs

@@ -0,0 +1,106 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { ConfigError, connectionFlags, defineMetabaseCommand, outputFlags, profileFlag } from "./runtime-DUgFfYkN.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import { REMOTE_SYNC_PATHS, SyncTask, pollFlags, pollSyncTask, throwIfFailedTask } from "./poll-task-Byiunmaj.mjs";
+import "./poll-D2sXM5rc.mjs";
+import { z } from "zod";
+
+//#region src/commands/sync/stash.ts
+const SyncStashKickoff = z.object({
+	status: z.literal("success"),
+	message: z.string(),
+	task_id: z.number().int().positive()
+});
+const SyncStashResult = z.object({
+	status: z.literal("success"),
+	message: z.string(),
+	task_id: z.number().int().positive(),
+	final: SyncTask.nullable().optional()
+});
+const syncStashView = {
+	compactPick: SyncStashResult,
+	tableColumns: [
+		{
+			key: "task_id",
+			label: "Task ID"
+		},
+		{
+			key: "status",
+			label: "Status"
+		},
+		{
+			key: "message",
+			label: "Message"
+		}
+	]
+};
+const DEFAULT_STASH_MESSAGE = "Stashed from metabase CLI";
+var stash_default = defineMetabaseCommand({
+	meta: {
+		name: "stash",
+		description: "Export current Metabase state to a new branch on the git remote"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		newBranch: {
+			type: "string",
+			description: "Branch to create and export to",
+			alias: "new-branch",
+			required: true
+		},
+		message: {
+			type: "string",
+			description: "Commit message",
+			alias: "m",
+			default: DEFAULT_STASH_MESSAGE
+		},
+		...pollFlags
+	},
+	outputSchema: SyncStashResult,
+	examples: ["metabase sync stash --new-branch wip", "metabase 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");
+		const message = args.message.trim();
+		if (message === "") throw new ConfigError("invalid message: must not be blank");
+		const timeoutMs = parseId(args.timeout, "timeout");
+		const intervalMs = parseId(args.interval, "interval");
+		const body = {
+			new_branch: newBranch,
+			message
+		};
+		const client = await getClient();
+		const kickoff = await client.requestParsed(SyncStashKickoff, REMOTE_SYNC_PATHS.stash, {
+			method: "POST",
+			body
+		});
+		if (!args.wait) {
+			const result$1 = {
+				status: kickoff.status,
+				message: kickoff.message,
+				task_id: kickoff.task_id
+			};
+			renderItem(result$1, syncStashView, ctx);
+			return;
+		}
+		const final = await pollSyncTask(client, {
+			timeoutMs,
+			intervalMs
+		});
+		const result = {
+			status: kickoff.status,
+			message: kickoff.message,
+			task_id: kickoff.task_id,
+			final
+		};
+		renderItem(result, syncStashView, ctx);
+		throwIfFailedTask(final, "stash");
+	}
+});
+
+//#endregion
+export { stash_default as default };

package/dist/status-9KAPIpX8.mjs

@@ -0,0 +1,31 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { account, credentials, defineMetabaseCommand, outputFlags } from "./runtime-DUgFfYkN.mjs";
+import { z } from "zod";
+
+//#region src/commands/license/status.ts
+const LicenseStatus = z.object({ present: z.boolean() });
+const licenseStatusView = {
+	compactPick: LicenseStatus,
+	tableColumns: [{
+		key: "present",
+		label: "Present"
+	}]
+};
+var status_default = defineMetabaseCommand({
+	meta: {
+		name: "status",
+		description: "Show whether a license token is stored (does not reveal value)"
+	},
+	args: { ...outputFlags },
+	outputSchema: LicenseStatus,
+	examples: ["metabase license status", "metabase license status --json"],
+	async run({ ctx }) {
+		const present = await credentials.has(account.license);
+		renderItem({ present }, licenseStatusView, ctx);
+	}
+});
+
+//#endregion
+export { status_default as default };

package/dist/status-DezF-PIM.mjs

@@ -0,0 +1,63 @@
+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 { REMOTE_SYNC_PATHS, SyncTask, fetchCurrentTask, fetchOptionalParsed } from "./poll-task-Byiunmaj.mjs";
+import "./poll-D2sXM5rc.mjs";
+import { IsDirtyResult } from "./is-dirty-B10S6MG0.mjs";
+import { z } from "zod";
+
+//#region src/commands/sync/status.ts
+const RemoteSyncBranch = z.string().nullable();
+const SyncStatus = z.object({
+	branch: z.string().nullable(),
+	is_dirty: z.boolean(),
+	current_task: SyncTask.nullable()
+});
+const syncStatusView = {
+	compactPick: SyncStatus,
+	tableColumns: [
+		{
+			key: "branch",
+			label: "Branch"
+		},
+		{
+			key: "is_dirty",
+			label: "Dirty"
+		},
+		{
+			key: "current_task",
+			label: "Current task"
+		}
+	]
+};
+var status_default = defineMetabaseCommand({
+	meta: {
+		name: "status",
+		description: "Show current sync state (branch, dirty, current task)"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags
+	},
+	outputSchema: SyncStatus,
+	examples: ["metabase sync status", "metabase sync status --json"],
+	async run({ ctx, getClient }) {
+		const client = await getClient();
+		const [branch, isDirty, currentTask] = await Promise.all([
+			fetchOptionalParsed(client, "/api/setting/remote-sync-branch", RemoteSyncBranch),
+			client.requestParsed(IsDirtyResult, REMOTE_SYNC_PATHS.isDirty),
+			fetchCurrentTask(client)
+		]);
+		const summary = {
+			branch,
+			is_dirty: isDirty.is_dirty,
+			current_task: currentTask
+		};
+		renderItem(summary, syncStatusView, ctx);
+	}
+});
+
+//#endregion
+export { status_default as default };

package/dist/status-JH6BZppo.mjs

@@ -0,0 +1,55 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { account, credentials, defineMetabaseCommand, originOnly, outputFlags, profileFlag, resolveProfileName } from "./runtime-DUgFfYkN.mjs";
+import { z } from "zod";
+
+//#region src/commands/auth/status.ts
+const AuthStatus = z.object({
+	profile: z.string(),
+	present: z.boolean(),
+	url: z.string().nullable()
+});
+const authStatusView = {
+	compactPick: AuthStatus,
+	tableColumns: [
+		{
+			key: "profile",
+			label: "Profile"
+		},
+		{
+			key: "present",
+			label: "Authenticated"
+		},
+		{
+			key: "url",
+			label: "URL"
+		}
+	]
+};
+var status_default = defineMetabaseCommand({
+	meta: {
+		name: "status",
+		description: "Show authentication status for a profile"
+	},
+	args: {
+		...outputFlags,
+		...profileFlag
+	},
+	outputSchema: AuthStatus,
+	examples: ["metabase auth status --json", "metabase auth status --profile staging"],
+	async run({ args, ctx }) {
+		const profileName = resolveProfileName(args.profile);
+		const [url, apiKey] = await Promise.all([credentials.read(account.profileUrl(profileName)), credentials.read(account.profileApiKey(profileName))]);
+		const present = url !== null && apiKey !== null;
+		const payload = {
+			profile: profileName,
+			present,
+			url: url === null ? null : originOnly(url)
+		};
+		renderItem(payload, authStatusView, ctx);
+	}
+});
+
+//#endregion
+export { status_default as default };

package/dist/stop-br-ZOnve.mjs

@@ -0,0 +1,80 @@
+import "./package-t8dKf4m_.mjs";
+import "./command-augment-D9pI9Vbh.mjs";
+import { renderItem } from "./render-DlBijc5i.mjs";
+import { defineMetabaseCommand, outputFlags } from "./runtime-DUgFfYkN.mjs";
+import { parseId } from "./parse-id-C1prc9US.mjs";
+import "./poll-D2sXM5rc.mjs";
+import { checkDockerReady, containerLifecycleStatus, containerNameFor, stopContainer } from "./docker-QWVMG2gl.mjs";
+import { LocalWorkspaceState } from "./ps-BiOrecEe.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/sync-C7VOWD00.mjs

@@ -0,0 +1,26 @@
+import { defineCommand } from "citty";
+
+//#region src/commands/sync/index.ts
+var sync_default = defineCommand({
+	meta: {
+		name: "sync",
+		description: "Remote-sync operations (import, export, status, branches)"
+	},
+	subCommands: {
+		status: () => import("./status-DezF-PIM.mjs").then((mod) => mod.default),
+		"is-dirty": () => import("./is-dirty-CUuq-aB6.mjs").then((mod) => mod.default),
+		"has-remote-changes": () => import("./has-remote-changes-DAL5jetW.mjs").then((mod) => mod.default),
+		dirty: () => import("./dirty-CLjHbz6J.mjs").then((mod) => mod.default),
+		"current-task": () => import("./current-task-BGt1mqaX.mjs").then((mod) => mod.default),
+		"cancel-task": () => import("./cancel-task-BDas45YO.mjs").then((mod) => mod.default),
+		wait: () => import("./wait-Cj_8wu4y.mjs").then((mod) => mod.default),
+		import: () => import("./import-CUMxUfSF.mjs").then((mod) => mod.default),
+		export: () => import("./export-D2Anfu3p.mjs").then((mod) => mod.default),
+		stash: () => import("./stash-ZZkmW_V7.mjs").then((mod) => mod.default),
+		branches: () => import("./branches-BbcoJXfp.mjs").then((mod) => mod.default),
+		"create-branch": () => import("./create-branch-sDttBORB.mjs").then((mod) => mod.default)
+	}
+});
+
+//#endregion
+export { sync_default as default };