@metabase/cli 0.1.12 → 0.1.14

package/dist/login-BF6LkxPI.mjs

@@ -0,0 +1,453 @@
+import { ConfigError, errorMessage, warn } from "./command-augment-CAur0XOQ.mjs";
+import { connectionFlags, outputFlags, profileFlag } from "./error-BOi_ux9O.mjs";
+import { DEFAULT_PROFILE, OAUTH_SCOPE, ParsedVersionSchema, ProbedUser, consumeKeychainResidualWarning, consumeKeyringDowngradeWarning, defineMetabaseCommand, discoverMetadata, exchangeCode, explicitProfileName, keyringFallbackWarning, normalizeUrl, oauthCredentialFromTokens, readEnvCredentials, registerClient, revokeOAuthCredential, tryDiscoverMetadata, writeOAuthProfile, writeProbeFailure, writeProbeResult, writeProfile } from "./runtime-7JTC-usO.mjs";
+import { verifyAndProbe } from "./verify-BLUei79N.mjs";
+import { renderSummary } from "./capabilities-BX1rnVuH.mjs";
+import { EMPTY_CELL, renderUserName, renderUserRole, renderVersionTag } from "./render-CkuFkWlQ.mjs";
+import { promptPassword, promptSelect, promptText } from "./prompt-Bc_bHSD0.mjs";
+import { openBrowser } from "./process-DsGf7Mg5.mjs";
+import { readInput } from "./input-BXWgdKiS.mjs";
+import { z } from "zod";
+import { createServer } from "node:http";
+import { createHash, randomBytes } from "node:crypto";
+
+//#region src/core/auth/callback-server.ts
+const LOOPBACK_HOST = "127.0.0.1";
+const CALLBACK_PATH = "/callback";
+const DEFAULT_TIMEOUT_MS = 3e5;
+function parseCallbackQuery(rawUrl) {
+	const queryStart = rawUrl.indexOf("?");
+	const params = new URLSearchParams(queryStart === -1 ? "" : rawUrl.slice(queryStart + 1));
+	return {
+		code: params.get("code"),
+		state: params.get("state"),
+		error: params.get("error"),
+		errorDescription: params.get("error_description")
+	};
+}
+function isCallbackPath(rawUrl) {
+	const queryStart = rawUrl.indexOf("?");
+	const path = queryStart === -1 ? rawUrl : rawUrl.slice(0, queryStart);
+	return path === CALLBACK_PATH;
+}
+function escapeHtml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function htmlPage(title, message) {
+	return "<!DOCTYPE html><html><head><meta charset=\"utf-8\"><title>" + escapeHtml(title) + "</title></head><body style=\"font-family:system-ui;text-align:center;padding-top:4rem;color:#4c5773\"><h1>" + escapeHtml(title) + "</h1><p>" + escapeHtml(message) + "</p><p>You can close this tab and return to your terminal.</p></body></html>";
+}
+function respond(res, status, title, message) {
+	res.writeHead(status, {
+		"content-type": "text/html; charset=utf-8",
+		connection: "close"
+	});
+	res.end(htmlPage(title, message));
+}
+function serverPort(server) {
+	const address = server.address();
+	if (address === null || typeof address === "string") throw new ConfigError("could not determine loopback callback port");
+	const info = address;
+	return info.port;
+}
+function startCallbackServer(expectedState, timeoutMs = DEFAULT_TIMEOUT_MS) {
+	return new Promise((resolveServer, rejectServer) => {
+		let settle = null;
+		let fail = null;
+		let outcome = null;
+		const server = createServer((req, res) => {
+			const rawUrl = req.url ?? "";
+			if (!isCallbackPath(rawUrl)) {
+				respond(res, 404, "Not found", "Unexpected request.");
+				return;
+			}
+			const query = parseCallbackQuery(rawUrl);
+			if (query.state !== expectedState) {
+				respond(res, 400, "Login failed", "Invalid or missing state.");
+				return;
+			}
+			if (query.error !== null) {
+				const detail = query.errorDescription ?? query.error;
+				respond(res, 400, "Login failed", detail);
+				deliver(new ConfigError(`authorization denied: ${detail}`));
+				return;
+			}
+			if (query.code === null) {
+				respond(res, 400, "Login failed", "Missing authorization code.");
+				deliver(new ConfigError("authorization callback missing code"));
+				return;
+			}
+			respond(res, 200, "Login complete", "Metabase CLI is now authorized.");
+			deliver({
+				code: query.code,
+				state: query.state
+			});
+		});
+		function deliver(result) {
+			if (outcome !== null) return;
+			outcome = result;
+			if (result instanceof Error) fail?.(result);
+			else settle?.(result);
+		}
+		const timer = setTimeout(() => {
+			deliver(new ConfigError(`timed out waiting for browser login after ${timeoutMs}ms`));
+		}, timeoutMs);
+		timer.unref();
+		server.on("error", (error) => {
+			rejectServer(error);
+			deliver(error);
+		});
+		server.listen(0, LOOPBACK_HOST, () => {
+			const port = serverPort(server);
+			resolveServer({
+				redirectUri: `http://${LOOPBACK_HOST}:${port}${CALLBACK_PATH}`,
+				waitForCallback() {
+					return new Promise((resolve, reject) => {
+						if (outcome !== null) {
+							if (outcome instanceof Error) reject(outcome);
+							else resolve(outcome);
+							return;
+						}
+						settle = resolve;
+						fail = reject;
+					});
+				},
+				close() {
+					clearTimeout(timer);
+					server.close();
+					server.closeAllConnections();
+				}
+			});
+		});
+	});
+}
+
+//#endregion
+//#region src/core/auth/pkce.ts
+const VERIFIER_BYTES = 32;
+const STATE_BYTES = 16;
+function base64Url(buffer) {
+	return buffer.toString("base64url");
+}
+function generatePkce() {
+	const verifier = base64Url(randomBytes(VERIFIER_BYTES));
+	const challenge = base64Url(createHash("sha256").update(verifier).digest());
+	return {
+		verifier,
+		challenge
+	};
+}
+function randomState() {
+	return base64Url(randomBytes(STATE_BYTES));
+}
+
+//#endregion
+//#region src/core/auth/oauth-login.ts
+const CLIENT_NAME = "Metabase CLI";
+function buildAuthorizeUrl(authorizationEndpoint, params) {
+	const separator = authorizationEndpoint.includes("?") ? "&" : "?";
+	return `${authorizationEndpoint}${separator}${new URLSearchParams(params).toString()}`;
+}
+async function resolveClientId(registrationEndpoint, redirectUri, provided) {
+	if (provided !== void 0) return provided;
+	if (registrationEndpoint === void 0) throw new ConfigError("this Metabase has dynamic client registration disabled; pass --client-id with a pre-registered native client");
+	const registered = await registerClient({
+		registrationEndpoint,
+		redirectUri,
+		clientName: CLIENT_NAME
+	});
+	return registered.client_id;
+}
+async function oauthLogin(input, deps) {
+	const metadata = input.metadata ?? await discoverMetadata(input.baseUrl);
+	const pkce = generatePkce();
+	const state = randomState();
+	const server = await startCallbackServer(state, input.timeoutMs);
+	try {
+		const clientId = await resolveClientId(metadata.registration_endpoint, server.redirectUri, input.clientId);
+		const authorizeUrl = buildAuthorizeUrl(metadata.authorization_endpoint, {
+			response_type: "code",
+			client_id: clientId,
+			redirect_uri: server.redirectUri,
+			code_challenge: pkce.challenge,
+			code_challenge_method: "S256",
+			state,
+			scope: OAUTH_SCOPE
+		});
+		const opened = await deps.openBrowser(authorizeUrl);
+		deps.onAuthorizeUrl(authorizeUrl, opened);
+		const callback = await server.waitForCallback();
+		const tokens = await exchangeCode({
+			tokenEndpoint: metadata.token_endpoint,
+			code: callback.code,
+			redirectUri: server.redirectUri,
+			clientId,
+			codeVerifier: pkce.verifier
+		});
+		if (tokens.refresh_token === void 0) throw new ConfigError("token endpoint did not return a refresh token");
+		return oauthCredentialFromTokens(tokens, tokens.refresh_token, clientId, deps.now());
+	} finally {
+		server.close();
+	}
+}
+
+//#endregion
+//#region src/commands/auth/login.ts
+const LoginResult = z.object({
+	profile: z.string(),
+	url: z.string(),
+	authenticated: z.boolean(),
+	user: ProbedUser.nullable(),
+	version: ParsedVersionSchema.nullable()
+});
+const loginView = {
+	compactPick: LoginResult,
+	tableColumns: [
+		{
+			key: "profile",
+			label: "Profile"
+		},
+		{
+			key: "url",
+			label: "Metabase URL"
+		},
+		{
+			key: "authenticated",
+			label: "Authenticated",
+			format: (value) => value === true ? "credentials verified" : "saved without verification"
+		},
+		{
+			key: "user",
+			label: "Logged in as",
+			format: (value) => renderUserName(value)
+		},
+		{
+			key: "user",
+			label: "Role",
+			format: (value) => renderUserRole(value)
+		},
+		{
+			key: "version",
+			label: "Version",
+			format: (value) => renderVersionTag(value)
+		}
+	]
+};
+var login_default = defineMetabaseCommand({
+	meta: {
+		name: "login",
+		description: "Log in to a Metabase instance for a profile"
+	},
+	details: "Interactive login offers browser OAuth (recommended; Metabase v63+) or an API key — older servers fall back to the API key prompt automatically. Browser login opens Metabase, you sign in (password or SSO) and approve, and the CLI stores a refreshing access token. For CI/non-interactive use, supply an API key via --api-key, piped stdin, or $MB_API_KEY (first non-empty wins); any of these skips the browser flow, even on a TTY. The URL comes from --url or $MB_URL, prompted when stdin is a TTY.",
+	capabilities: { minVersion: 58 },
+	args: {
+		...outputFlags,
+		...profileFlag,
+		...connectionFlags,
+		clientId: {
+			type: "string",
+			description: "Pre-registered OAuth client id (when dynamic registration is disabled)",
+			alias: "client-id"
+		},
+		"skip-verify": {
+			type: "boolean",
+			default: false,
+			description: "Save without contacting the server"
+		}
+	},
+	outputSchema: LoginResult,
+	examples: [
+		"mb auth login --url https://metabase.example.com",
+		"echo $MB_API_KEY | mb auth login --url https://metabase.example.com",
+		"mb auth login --profile staging --url https://staging.example.com"
+	],
+	async run({ args, ctx }) {
+		const profileName = await resolveLoginProfile(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 MB_API_KEY instead");
+		const url = await resolveUrl(args.url, env.url);
+		const apiKey = await nonInteractiveApiKey(args.apiKey, env.apiKey);
+		if (apiKey !== null) {
+			await completeLogin(profileName, url, {
+				kind: "apiKey",
+				apiKey
+			}, args["skip-verify"], ctx, () => writeProfile({
+				url,
+				apiKey
+			}, profileName));
+			return;
+		}
+		if (!process.stdin.isTTY) throw new ConfigError("interactive login requires a TTY; pass --api-key or set MB_API_KEY for non-interactive login");
+		const metadata = await probeOAuthSupport(url);
+		const method = await chooseLoginMethod(metadata, args.clientId);
+		if (method === "apiKey") {
+			const promptedKey = await promptForApiKey();
+			await completeLogin(profileName, url, {
+				kind: "apiKey",
+				apiKey: promptedKey
+			}, args["skip-verify"], ctx, () => writeProfile({
+				url,
+				apiKey: promptedKey
+			}, profileName));
+			return;
+		}
+		const credential = await oauthLogin({
+			baseUrl: url,
+			...metadata !== null && { metadata },
+			...args.clientId !== void 0 && { clientId: args.clientId }
+		}, {
+			openBrowser,
+			onAuthorizeUrl: announceAuthorizeUrl,
+			now: () => Date.now()
+		});
+		await completeLogin(profileName, url, credential, args["skip-verify"], ctx, () => writeOAuthProfile(url, credential, profileName));
+	}
+});
+async function probeOAuthSupport(url) {
+	try {
+		return await tryDiscoverMetadata(url);
+	} catch (error) {
+		if (error instanceof ConfigError) throw error;
+		throw new ConfigError(`could not reach ${url}: ${errorMessage(error)}`);
+	}
+}
+async function chooseLoginMethod(metadata, clientId) {
+	if (metadata === null) {
+		if (clientId !== void 0) throw new ConfigError("--client-id was given but this Metabase does not support OAuth login (requires Metabase v63 or newer)");
+		warn("This Metabase does not support browser login (requires Metabase v63 or newer); using an API key instead.");
+		return "apiKey";
+	}
+	if (clientId !== void 0) return "oauth";
+	return promptSelect({
+		message: "How do you want to log in?",
+		choices: [{
+			value: "oauth",
+			label: "In your browser (recommended)",
+			hint: "sign in to Metabase with password or SSO and approve the CLI"
+		}, {
+			value: "apiKey",
+			label: "With an API key",
+			hint: "paste a key from Admin settings → Authentication → API keys"
+		}],
+		initialValue: "oauth"
+	});
+}
+async function promptForApiKey() {
+	return promptPassword({
+		message: "API key",
+		mask: "•",
+		validate: (input) => input ? void 0 : "API key is required"
+	});
+}
+async function completeLogin(profileName, url, credential, skipVerify, ctx, persist) {
+	if (skipVerify) {
+		await persistWithWarning(persist);
+		renderSummary({
+			profile: profileName,
+			url,
+			authenticated: false,
+			user: null,
+			version: null
+		}, loginView, `Saved credentials for profile "${profileName}" (${url}) without verifying.`, ctx);
+		return;
+	}
+	const result = await verifyAndProbe(url, credential);
+	if (!result.ok) {
+		await writeProbeFailure(profileName, {
+			kind: result.kind,
+			reason: result.message
+		});
+		await revokeUnsavedOAuthCredential(url, credential);
+		throw new ConfigError(formatVerifyFailureMessage(profileName, result));
+	}
+	await persistWithWarning(persist);
+	await writeProbeResult(profileName, {
+		user: result.user,
+		server: result.server
+	});
+	const who = renderUserName(result.user);
+	const role = renderUserRole(result.user);
+	const versionTag = renderVersionTag(result.server.version);
+	const serverClause = versionTag === EMPTY_CELL ? "" : ` Server ${versionTag}.`;
+	renderSummary({
+		profile: profileName,
+		url,
+		authenticated: true,
+		user: result.user,
+		version: result.server.version
+	}, loginView, `Logged in to ${url} as ${who} (${role}). Saved to profile "${profileName}".${serverClause}`, ctx);
+}
+async function revokeUnsavedOAuthCredential(url, credential) {
+	if (credential.kind !== "oauth") return;
+	try {
+		const revoked = await revokeOAuthCredential(url, credential);
+		if (!revoked) warn("server does not advertise a revocation endpoint; the unsaved tokens remain valid until they expire");
+	} catch (error) {
+		warn(`could not revoke the unsaved tokens server-side: ${errorMessage(error)}`);
+	}
+}
+async function persistWithWarning(persist) {
+	const location = await persist();
+	if (location.backend === "file") warn(keyringFallbackWarning(location));
+	const residual = consumeKeychainResidualWarning();
+	if (residual !== null) warn(residual);
+	consumeKeyringDowngradeWarning();
+}
+function announceAuthorizeUrl(url, opened) {
+	if (opened) {
+		warn(`Opening your browser to finish login. If it didn't open, visit:\n  ${url}`);
+		return;
+	}
+	warn(`Open this URL in your browser to finish login:\n  ${url}`);
+}
+function formatVerifyFailureMessage(profileName, failure) {
+	const which = failure.which === "user" ? "/api/user/current" : "/api/session/properties";
+	return `verification failed (${which}): ${failure.message} — credentials were not saved for profile "${profileName}"`;
+}
+async function resolveLoginProfile(flagProfile) {
+	const explicit = explicitProfileName(flagProfile);
+	if (explicit !== null) return explicit;
+	if (!process.stdin.isTTY) return DEFAULT_PROFILE;
+	const entered = (await promptText({
+		message: "Profile name",
+		placeholder: DEFAULT_PROFILE,
+		defaultValue: DEFAULT_PROFILE
+	})).trim();
+	return entered === "" ? DEFAULT_PROFILE : entered;
+}
+async function resolveUrl(flagUrl, envUrl) {
+	if (flagUrl) return normalizeUrl(flagUrl);
+	if (envUrl) return normalizeUrl(envUrl);
+	return promptForUrl();
+}
+async function nonInteractiveApiKey(flagKey, envKey) {
+	if (flagKey) return flagKey;
+	if (!process.stdin.isTTY) {
+		const piped = (await readInput({ required: false })).trim();
+		if (piped) return piped;
+	}
+	if (envKey) {
+		if (process.stdin.isTTY) warn("using the API key from $MB_API_KEY; unset it to choose browser login");
+		return envKey;
+	}
+	return null;
+}
+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);
+}
+
+//#endregion
+export { login_default as default };

package/dist/{logout-BUgUTFol.mjs → logout-Cg8Z_XD_.mjs}

@@ -1,8 +1,8 @@
-import "./command-augment-BH9qgQ5u.mjs";
-import { outputFlags, profileFlag } from "./error-BGH4gxGN.mjs";
-import { clearProfile, defineMetabaseCommand, resolveProfileName } from "./runtime-DgHh4T6t.mjs";
-import { renderSummary } from "./capabilities-7L9GVMd_.mjs";
-import { promptConfirm } from "./prompt-u4WhE4T5.mjs";
+import { errorMessage, warn } from "./command-augment-CAur0XOQ.mjs";
+import { outputFlags, profileFlag } from "./error-BOi_ux9O.mjs";
+import { clearProfile, consumeKeychainResidualWarning, defineMetabaseCommand, readProfileCredential, resolveProfileName, revokeOAuthCredential } from "./runtime-7JTC-usO.mjs";
+import { renderSummary } from "./capabilities-BX1rnVuH.mjs";
+import { promptConfirm } from "./prompt-Bc_bHSD0.mjs";
 import { z } from "zod";
 
 //#region src/commands/auth/logout.ts
@@ -33,7 +33,7 @@ var logout_default = defineMetabaseCommand({
 		name: "logout",
 		description: "Clear stored credentials for a profile"
 	},
-	capabilities: null,
+	capabilities: { minVersion: 58 },
 	args: {
 		...outputFlags,
 		...profileFlag,
@@ -61,7 +61,16 @@ var logout_default = defineMetabaseCommand({
 				return;
 			}
 		}
+		const resolved = await readProfileCredential(profileName);
 		const cleared = await clearProfile(profileName);
+		const residual = consumeKeychainResidualWarning();
+		if (residual !== null) warn(residual);
+		if (resolved !== null && resolved.credential.kind === "oauth") try {
+			const revoked = await revokeOAuthCredential(resolved.url, resolved.credential);
+			if (!revoked) warn("server does not advertise a revocation endpoint; tokens remain valid until they expire");
+		} catch (error) {
+			warn(`could not revoke tokens server-side: ${errorMessage(error)}`);
+		}
 		const message = cleared ? `Cleared stored credentials for profile "${profileName}".` : `No stored credentials for profile "${profileName}".`;
 		renderSummary({
 			profile: profileName,

package/dist/{manifest-BPHqF5LY.mjs → manifest-DYeLri80.mjs}

@@ -1,5 +1,5 @@
-import { getMetabaseAugment, resolveCitty, toAliasArray } from "./command-augment-BH9qgQ5u.mjs";
-import { Capabilities, writeJson } from "./capabilities-7L9GVMd_.mjs";
+import { getMetabaseAugment, resolveCitty, toAliasArray } from "./command-augment-CAur0XOQ.mjs";
+import { Capabilities, writeJson } from "./capabilities-BX1rnVuH.mjs";
 import { defineCommand } from "citty";
 import { z } from "zod";
 

package/dist/measure-BRzkMY5y.mjs

@@ -0,0 +1,19 @@
+import { defineCommand } from "citty";
+
+//#region src/commands/measure/index.ts
+var measure_default = defineCommand({
+	meta: {
+		name: "measure",
+		description: "Manage Metabase measures"
+	},
+	subCommands: {
+		list: () => import("./list-BkEFHJe8.mjs").then((mod) => mod.default),
+		get: () => import("./get-B2-RLrYJ.mjs").then((mod) => mod.default),
+		create: () => import("./create-Bbe2EM9f.mjs").then((mod) => mod.default),
+		update: () => import("./update-BuJjTYAx.mjs").then((mod) => mod.default),
+		archive: () => import("./archive-DTN6Anme.mjs").then((mod) => mod.default)
+	}
+});
+
+//#endregion
+export { measure_default as default };

package/dist/{metadata-B1EmV1l5.mjs → metadata-B15u_YYT.mjs}

@@ -1,10 +1,10 @@
-import "./command-augment-BH9qgQ5u.mjs";
-import { connectionFlags, outputFlags, profileFlag } from "./error-BGH4gxGN.mjs";
-import { defineMetabaseCommand } from "./runtime-DgHh4T6t.mjs";
-import { renderItem } from "./capabilities-7L9GVMd_.mjs";
-import "./field-MGxpNQUH.mjs";
-import { parseId } from "./parse-id-sKNP6yu5.mjs";
-import { TableQueryMetadata, tableView } from "./table-CkWja2UH.mjs";
+import "./command-augment-CAur0XOQ.mjs";
+import { connectionFlags, outputFlags, profileFlag } from "./error-BOi_ux9O.mjs";
+import { defineMetabaseCommand } from "./runtime-7JTC-usO.mjs";
+import { renderItem } from "./capabilities-BX1rnVuH.mjs";
+import "./field-E0IBy4Uw.mjs";
+import { parseId } from "./parse-id-DMs04KM3.mjs";
+import { TableQueryMetadata, tableView } from "./table-qDD2kApF.mjs";
 
 //#region src/commands/table/metadata.ts
 var metadata_default = defineMetabaseCommand({

package/dist/{metadata-Dwkcsa1c.mjs → metadata-CmvvOpKI.mjs}

@@ -1,11 +1,11 @@
-import "./command-augment-BH9qgQ5u.mjs";
-import { connectionFlags, outputFlags, profileFlag } from "./error-BGH4gxGN.mjs";
-import { defineMetabaseCommand } from "./runtime-DgHh4T6t.mjs";
-import { renderItem } from "./capabilities-7L9GVMd_.mjs";
-import "./field-MGxpNQUH.mjs";
-import { parseId } from "./parse-id-sKNP6yu5.mjs";
-import "./table-CkWja2UH.mjs";
-import { Database, databaseView } from "./database-Dsv4QBs0.mjs";
+import "./command-augment-CAur0XOQ.mjs";
+import { connectionFlags, outputFlags, profileFlag } from "./error-BOi_ux9O.mjs";
+import { defineMetabaseCommand } from "./runtime-7JTC-usO.mjs";
+import { renderItem } from "./capabilities-BX1rnVuH.mjs";
+import "./field-E0IBy4Uw.mjs";
+import { parseId } from "./parse-id-DMs04KM3.mjs";
+import "./table-qDD2kApF.mjs";
+import { Database, databaseView } from "./database-BmsxuRmO.mjs";
 
 //#region src/commands/db/metadata.ts
 var metadata_default = defineMetabaseCommand({

package/dist/{parse-enum-Dr7ACrTR.mjs → parse-enum-BatHQ-Gs.mjs}

@@ -1,4 +1,4 @@
-import { ConfigError } from "./command-augment-BH9qgQ5u.mjs";
+import { ConfigError } from "./command-augment-CAur0XOQ.mjs";
 
 //#region src/commands/parse-enum.ts
 function parseEnumFlag(value, schema, name) {

package/dist/{parse-id-sKNP6yu5.mjs → parse-id-DMs04KM3.mjs}

@@ -1,4 +1,4 @@
-import { parseInteger } from "./runtime-DgHh4T6t.mjs";
+import { parseInteger } from "./runtime-7JTC-usO.mjs";
 
 //#region src/commands/parse-id.ts
 function parseId(value, name = "id") {

package/dist/{parse-ref-BiETXmvm.mjs → parse-ref-CZr1bYIl.mjs}

@@ -1,4 +1,4 @@
-import { ConfigError } from "./command-augment-BH9qgQ5u.mjs";
+import { ConfigError } from "./command-augment-CAur0XOQ.mjs";
 
 //#region src/commands/collection/parse-ref.ts
 const SPECIAL_TOKENS = new Set(["root", "trash"]);

package/dist/{path-BZJR7YLR.mjs → path-YsfpMb_h.mjs}

@@ -1,8 +1,8 @@
-import "./command-augment-BH9qgQ5u.mjs";
-import { listEnvelopeSchema, outputFlags, wrapList } from "./error-BGH4gxGN.mjs";
-import { defineMetabaseCommand } from "./runtime-DgHh4T6t.mjs";
-import { renderList } from "./capabilities-7L9GVMd_.mjs";
-import { findSkillByName, loadAllSkills, loadVisibleSkills } from "./skills-CY_FmaPo.mjs";
+import "./command-augment-CAur0XOQ.mjs";
+import { listEnvelopeSchema, outputFlags, wrapList } from "./error-BOi_ux9O.mjs";
+import { defineMetabaseCommand } from "./runtime-7JTC-usO.mjs";
+import { renderList } from "./capabilities-BX1rnVuH.mjs";
+import { findSkillByName, loadAllSkills, loadVisibleSkills } from "./skills-CJ8g8fhQ.mjs";
 import { z } from "zod";
 
 //#region src/commands/skills/path.ts

package/dist/{poll-Cyw-dQi4.mjs → poll-13tgWrN_.mjs}

@@ -1,5 +1,5 @@
-import { TimeoutError } from "./command-augment-BH9qgQ5u.mjs";
-import { combineAborts, throwIfAborted } from "./runtime-DgHh4T6t.mjs";
+import { TimeoutError } from "./command-augment-CAur0XOQ.mjs";
+import { combineAborts, throwIfAborted } from "./runtime-7JTC-usO.mjs";
 import { setTimeout } from "node:timers/promises";
 
 //#region src/runtime/poll.ts

package/dist/{poll-task-BG0oVnfZ.mjs → poll-task-BuAHsDEK.mjs}

@@ -1,5 +1,5 @@
-import { parseJsonOrPlain } from "./runtime-DgHh4T6t.mjs";
-import { pollUntil } from "./poll-Cyw-dQi4.mjs";
+import { parseJsonOrPlain } from "./runtime-7JTC-usO.mjs";
+import { pollUntil } from "./poll-13tgWrN_.mjs";
 import { z } from "zod";
 
 //#region src/domain/git-sync.ts

package/dist/{preflight-BjR63JnX.mjs → preflight-wCSgVqbX.mjs}

@@ -1,7 +1,7 @@
-import { ChainedRequestError, ConfigError, MetabaseError } from "./command-augment-BH9qgQ5u.mjs";
-import { HttpError } from "./runtime-DgHh4T6t.mjs";
-import { writeJson } from "./capabilities-7L9GVMd_.mjs";
-import { Card } from "./card-DnIeMmUn.mjs";
+import { ChainedRequestError, ConfigError, MetabaseError } from "./command-augment-CAur0XOQ.mjs";
+import { HttpError } from "./runtime-7JTC-usO.mjs";
+import { writeJson } from "./capabilities-BX1rnVuH.mjs";
+import { Card } from "./card-wCPcuKSi.mjs";
 import { z } from "zod";
 
 //#region src/commands/dashboard/preflight.ts