@metabase/cli 0.1.18 → 0.2.0

package/dist/capabilities-DrDJo_ng.mjs

@@ -0,0 +1,684 @@
+import { ZodError, core, z } from "zod";
+import { isCancel } from "@clack/prompts";
+import Table from "cli-table3";
+
+//#region src/runtime/citty.ts
+async function resolveCitty(value) {
+	if (value === void 0) return void 0;
+	if (typeof value === "function") return value();
+	return value;
+}
+function toAliasArray(alias) {
+	if (alias === void 0) return [];
+	return Array.isArray(alias) ? alias : [alias];
+}
+function normalizeFlag(value) {
+	return value.replace(/^-+/, "").replace(/-/g, "").toLowerCase();
+}
+function flagConsumesValue(token, argsDef) {
+	if (token.includes("=")) return false;
+	const name$1 = normalizeFlag(token);
+	for (const [key, def] of Object.entries(argsDef)) {
+		if (def.type !== "string" && def.type !== "enum") continue;
+		if (normalizeFlag(key) === name$1) return true;
+		if (toAliasArray(def.alias).some((alias) => normalizeFlag(alias) === name$1)) return true;
+	}
+	return false;
+}
+
+//#endregion
+//#region src/output/types.ts
+const DEFAULT_MAX_BYTES = 24576;
+function listEnvelopeSchema(item) {
+	return z.object({
+		data: z.array(item),
+		returned: z.number().int().nonnegative(),
+		total: z.number().int().nonnegative().nullable().optional(),
+		limit: z.number().int().nonnegative().optional(),
+		truncated: z.object({
+			reason: z.literal("max_bytes"),
+			bytes: z.number().int().nonnegative()
+		}).optional()
+	});
+}
+function wrapList(items) {
+	return {
+		data: items,
+		returned: items.length,
+		total: items.length
+	};
+}
+
+//#endregion
+//#region src/commands/flags.ts
+const outputFlags = {
+	format: {
+		type: "string",
+		description: "auto | json | text",
+		default: "auto"
+	},
+	json: {
+		type: "boolean",
+		description: "Shorthand for --format json"
+	},
+	full: {
+		type: "boolean",
+		description: "Return the full object (default: compact)"
+	},
+	fields: {
+		type: "string",
+		description: "Dot-paths, comma separated (mutually exclusive with --full)"
+	},
+	maxBytes: {
+		type: "string",
+		description: "Output size cap; 0 disables",
+		default: String(DEFAULT_MAX_BYTES),
+		alias: "max-bytes"
+	}
+};
+const profileFlag = { profile: {
+	type: "string",
+	description: "Named profile (default: 'default')",
+	alias: "p"
+} };
+const connectionFlags = {
+	url: {
+		type: "string",
+		description: "Metabase URL"
+	},
+	apiKey: {
+		type: "string",
+		description: "API key",
+		alias: "api-key"
+	},
+	skipPreflight: {
+		type: "boolean",
+		description: "Skip the server version capability check for this command",
+		alias: "skip-preflight"
+	}
+};
+
+//#endregion
+//#region src/core/json-pointer.ts
+function escapeJsonPointerSegment(key) {
+	if (typeof key === "number") return String(key);
+	const segment = typeof key === "symbol" ? key.toString() : key;
+	return segment.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+
+//#endregion
+//#region src/core/errors.ts
+var MetabaseError = class extends Error {
+	get userMessage() {
+		return this.message;
+	}
+};
+var NetworkError = class extends MetabaseError {
+	category = "network";
+	isRetryable = true;
+	exitCode = 1;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "NetworkError";
+		this.developerDetail = developerDetail;
+	}
+};
+var TimeoutError = class extends MetabaseError {
+	category = "timeout";
+	isRetryable = true;
+	exitCode = 1;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "TimeoutError";
+		this.developerDetail = developerDetail;
+	}
+};
+var ValidationError = class extends MetabaseError {
+	category = "validation";
+	isRetryable = false;
+	exitCode = 1;
+	developerDetail;
+	constructor(message, developerDetail) {
+		super(message);
+		this.name = "ValidationError";
+		this.developerDetail = developerDetail;
+	}
+	get userMessage() {
+		const issues = this.developerDetail.zodIssues;
+		if (issues.length === 0) return this.message;
+		return `${this.message}\n${formatIssueLines(issues, VALIDATION_ISSUE_FORMAT)}`;
+	}
+};
+const VALIDATION_MAX_ISSUES = 10;
+const RESPONSE_SHAPE_MAX_ISSUES = 5;
+const VALIDATION_ISSUE_FORMAT = {
+	max: VALIDATION_MAX_ISSUES,
+	formatIssue: (issue) => `${formatZodIssuePointer(issue.path)}: ${issue.message}`
+};
+const RESPONSE_SHAPE_ISSUE_FORMAT = {
+	max: RESPONSE_SHAPE_MAX_ISSUES,
+	formatIssue: formatZodIssue
+};
+function formatIssueLines(issues, format) {
+	const head = issues.slice(0, format.max).map(format.formatIssue);
+	const overflow = issues.length - format.max;
+	if (overflow > 0) head.push(`... and ${overflow} more`);
+	return head.map((line) => `  ${line}`).join("\n");
+}
+function formatZodIssuePointer(path) {
+	if (path.length === 0) return "/";
+	return path.map((key) => `/${escapeJsonPointerSegment(key)}`).join("");
+}
+const RESPONSE_SHAPE_LEAD_UNKNOWN_VERSION = "Metabase returned unexpected response shape";
+var ResponseShapeError = class extends MetabaseError {
+	category = "response-shape";
+	isRetryable = false;
+	exitCode = 1;
+	developerDetail;
+	constructor(developerDetail) {
+		super(formatResponseShapeMessage(developerDetail.zodIssues, developerDetail.serverTag));
+		this.name = "ResponseShapeError";
+		this.developerDetail = developerDetail;
+	}
+};
+function formatResponseShapeMessage(issues, serverTag) {
+	const lead = serverTag === null ? RESPONSE_SHAPE_LEAD_UNKNOWN_VERSION : `On Metabase ${serverTag} the response shape was unexpected`;
+	if (issues.length === 0) return lead;
+	return `${lead}:\n${formatIssueLines(issues, RESPONSE_SHAPE_ISSUE_FORMAT)}`;
+}
+var ConfigError = class extends MetabaseError {
+	category = "config";
+	isRetryable = false;
+	exitCode = 2;
+	developerDetail = null;
+	constructor(message) {
+		super(message);
+		this.name = "ConfigError";
+	}
+};
+var AbortError = class extends MetabaseError {
+	category = "abort";
+	isRetryable = false;
+	exitCode = 130;
+	developerDetail = null;
+	constructor(message = "aborted") {
+		super(message);
+		this.name = "AbortError";
+	}
+};
+var ChainedRequestError = class extends MetabaseError {
+	cause;
+	constructor(message, cause) {
+		super(message);
+		this.name = "ChainedRequestError";
+		this.cause = cause;
+	}
+	get category() {
+		return this.cause.category;
+	}
+	get isRetryable() {
+		return this.cause.isRetryable;
+	}
+	get exitCode() {
+		return this.cause.exitCode;
+	}
+	get developerDetail() {
+		return this.cause.developerDetail;
+	}
+};
+var UnknownError = class extends MetabaseError {
+	category = "unknown";
+	isRetryable = false;
+	exitCode = 1;
+	developerDetail;
+	constructor(input) {
+		super(input.originalMessage);
+		this.name = "UnknownError";
+		this.developerDetail = input;
+	}
+};
+function toMetabaseError(error) {
+	if (error instanceof MetabaseError) return error;
+	if (isCancel(error)) return new AbortError();
+	if (error instanceof ZodError) return new ConfigError(error.issues.map(formatZodIssue).join("; "));
+	if (error instanceof Error) return new UnknownError({
+		originalMessage: error.message,
+		stack: error.stack ?? null
+	});
+	return new UnknownError({
+		originalMessage: String(error),
+		stack: null
+	});
+}
+function formatZodIssue(issue) {
+	const path = core.toDotPath(issue.path);
+	return path === "" ? issue.message : `${path}: ${issue.message}`;
+}
+function isNotFoundError(value) {
+	return value instanceof Error && "code" in value && value.code === "ENOENT";
+}
+function errorMessage(value) {
+	return value instanceof Error ? value.message : String(value);
+}
+
+//#endregion
+//#region package.json
+var name = "@metabase/cli";
+var version = "0.2.0";
+var description = "Metabase CLI";
+var license = "AGPL-3.0";
+var repository = {
+	"type": "git",
+	"url": "git+https://github.com/metabase/mb-cli.git"
+};
+var bin = { "mb": "./dist/cli.mjs" };
+var files = [
+	"dist",
+	"skills",
+	"skill-data",
+	".claude-plugin"
+];
+var type = "module";
+var publishConfig = {
+	"access": "public",
+	"registry": "https://registry.npmjs.org/"
+};
+var scripts = {
+	"build": "tsdown",
+	"dev": "tsdown --watch",
+	"start": "node dist/cli.mjs",
+	"test": "vitest run --project unit",
+	"test:watch": "vitest --project unit",
+	"test:e2e": "vitest run --project e2e",
+	"test:e2e:watch": "vitest --project e2e",
+	"e2e:up": "docker compose -f tests/e2e/docker-compose.yml up -d --wait",
+	"e2e:down": "docker compose -f tests/e2e/docker-compose.yml down -v",
+	"e2e:bootstrap": "bun tests/e2e/setup/bootstrap.ts",
+	"e2e:matrix": "bun scripts/e2e-matrix.ts",
+	"e2e:logs": "docker compose -f tests/e2e/docker-compose.yml logs -f metabase",
+	"typecheck": "tsc --noEmit",
+	"lint": "oxlint",
+	"lint:fix": "oxlint --fix",
+	"lint:skills": "uvx skillsaw lint skill-data/ --strict",
+	"format": "oxfmt",
+	"format:check": "oxfmt --check",
+	"sync:representations": "bun run scripts/sync-representations.ts",
+	"prepublishOnly": "tsdown && publint"
+};
+var dependencies = {
+	"@clack/prompts": "^0.8.2",
+	"@napi-rs/keyring": "^1.3.0",
+	"ajv": "^8.17.1",
+	"ajv-formats": "^3.0.1",
+	"citty": "^0.2.2",
+	"cli-table3": "^0.6.5",
+	"semver": "^7.8.0",
+	"yaml": "^2.8.4",
+	"zod": "^4.0.0"
+};
+var devDependencies = {
+	"@types/js-yaml": "^4.0.9",
+	"@types/node": "^22.10.0",
+	"@types/semver": "^7.7.1",
+	"execa": "^9.5.2",
+	"fast-check": "^4.7.0",
+	"js-yaml": "^4.1.0",
+	"oxfmt": "^0.47.0",
+	"oxlint": "^1.62.0",
+	"publint": "^0.3.0",
+	"tsdown": "^0.9.0",
+	"typescript": "^5.7.2",
+	"vitest": "^2.1.8"
+};
+var engines = { "node": ">=20.6" };
+var package_default = {
+	name,
+	version,
+	description,
+	license,
+	repository,
+	bin,
+	files,
+	type,
+	publishConfig,
+	scripts,
+	dependencies,
+	devDependencies,
+	engines
+};
+
+//#endregion
+//#region src/core/env.ts
+const CANONICAL_PREFIX = "MB_";
+const LEGACY_PREFIX = "METABASE_";
+const ENV_URL = "MB_URL";
+const ENV_API_KEY = "MB_API_KEY";
+const ENV_PROFILE = "MB_PROFILE";
+const ENV_VERBOSE = "MB_VERBOSE";
+const ENV_SKIP_PREFLIGHT = "MB_CLI_SKIP_PREFLIGHT";
+const ENV_DISABLE_KEYRING = "MB_CLI_DISABLE_KEYRING";
+function legacyNameFor(canonical) {
+	return LEGACY_PREFIX + canonical.slice(CANONICAL_PREFIX.length);
+}
+const legacyVarsUsed = new Set();
+function readEnv(canonical) {
+	const direct = process.env[canonical];
+	if (direct !== void 0) return direct;
+	const legacyValue = process.env[legacyNameFor(canonical)];
+	if (legacyValue !== void 0) {
+		legacyVarsUsed.add(canonical);
+		return legacyValue;
+	}
+	return void 0;
+}
+function consumeLegacyEnvWarnings() {
+	if (legacyVarsUsed.size === 0) return [];
+	const messages = [...legacyVarsUsed].map(legacyEnvWarning);
+	legacyVarsUsed.clear();
+	return messages;
+}
+function legacyEnvWarning(canonical) {
+	return `warning: ${legacyNameFor(canonical)} is deprecated; set ${canonical} instead`;
+}
+
+//#endregion
+//#region src/output/notice.ts
+function warn(message) {
+	process.stderr.write(message + "\n");
+}
+function listTruncationNotice(bytes) {
+	return `… cut at ${bytes} bytes; narrow the selection or raise --max-bytes`;
+}
+const ITEM_OVERSIZE_REMEDY = "narrow with --fields or raise the cap with --max-bytes <n>";
+function itemOversizeMessage(bytes, maxBytes, hint) {
+	return `output is ${bytes} bytes, over the ${maxBytes}-byte --max-bytes cap; ${hint ?? ITEM_OVERSIZE_REMEDY}`;
+}
+
+//#endregion
+//#region src/output/cap.ts
+function capListEnvelope(envelope, maxBytes) {
+	if (maxBytes <= 0) return envelope;
+	const fullBytes = jsonByteLength(envelope);
+	if (fullBytes <= maxBytes) return envelope;
+	let lo = 0;
+	let hi = envelope.data.length;
+	while (lo < hi) {
+		const mid = Math.ceil((lo + hi) / 2);
+		if (jsonByteLength(truncate(envelope, mid, fullBytes)) <= maxBytes) lo = mid;
+		else hi = mid - 1;
+	}
+	return truncate(envelope, lo, fullBytes);
+}
+function truncate(envelope, count, originalBytes) {
+	return {
+		...envelope,
+		data: envelope.data.slice(0, count),
+		returned: count,
+		truncated: {
+			reason: "max_bytes",
+			bytes: originalBytes
+		}
+	};
+}
+function jsonByteLength(value) {
+	return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+
+//#endregion
+//#region src/runtime/predicates.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/output/projection.ts
+function applyProjection(value, view, full, fields) {
+	if (fields !== void 0) {
+		if (fields.length === 0) throw new ConfigError("--fields requires at least one path");
+		return projectFields(value, fields);
+	}
+	if (full) return value;
+	const parsed = view.compactPick.safeParse(value);
+	if (parsed.success) return parsed.data;
+	throw new ConfigError(`compact projection failed: ${parsed.error.message}`);
+}
+function projectFields(value, fields) {
+	const out = {};
+	for (const path of fields) {
+		if (path.length === 0) throw new ConfigError(`empty field path`);
+		const parts = path.split(".");
+		if (parts.some((part) => part.length === 0)) throw new ConfigError(`invalid field path: "${path}"`);
+		setPath(out, parts, pickPath(value, parts));
+	}
+	return out;
+}
+function pickPath(value, parts) {
+	let cursor = value;
+	for (const part of parts) {
+		if (!isPlainObject(cursor) || !Object.hasOwn(cursor, part)) throw new ConfigError(`unknown field path: "${parts.join(".")}"`);
+		cursor = Reflect.get(cursor, part);
+	}
+	return cursor;
+}
+function setPath(target, parts, value) {
+	let cursor = target;
+	const lastIndex = parts.length - 1;
+	for (const [index, part] of parts.entries()) {
+		if (index === lastIndex) {
+			cursor[part] = value;
+			return;
+		}
+		const existing = cursor[part];
+		if (isPlainObject(existing)) cursor = existing;
+		else {
+			const next = {};
+			cursor[part] = next;
+			cursor = next;
+		}
+	}
+}
+
+//#endregion
+//#region src/output/table.ts
+const PLAIN_TABLE_STYLE = {
+	head: [],
+	border: []
+};
+function renderTable(rows, columns) {
+	const head = columns.map((column) => column.label ?? column.key);
+	const widths = columns.map((column) => column.width ?? null);
+	const hasWidth = widths.some((width) => width !== null);
+	const table = new Table(hasWidth ? {
+		head,
+		colWidths: widths,
+		style: PLAIN_TABLE_STYLE
+	} : {
+		head,
+		style: PLAIN_TABLE_STYLE
+	});
+	for (const row of rows) table.push(columns.map((column) => formatCell(row, column)));
+	return table.toString();
+}
+function renderRows(head, rows) {
+	const table = new Table({
+		head: [...head],
+		style: PLAIN_TABLE_STYLE
+	});
+	for (const row of rows) table.push([...row]);
+	return table.toString();
+}
+function formatCell(row, column) {
+	const value = row[column.key];
+	if (column.format !== void 0) return column.format(value);
+	return formatScalar(value);
+}
+function formatScalar(value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+}
+
+//#endregion
+//#region src/output/render.ts
+function serializeJson(value, pretty) {
+	return JSON.stringify(value, null, pretty ? 2 : void 0);
+}
+function stdoutPretty() {
+	return process.stdout.isTTY === true;
+}
+function jsonLine(value) {
+	return serializeJson(value, stdoutPretty()) + "\n";
+}
+function writeJson(value) {
+	process.stdout.write(jsonLine(value));
+}
+function writeText(text$1) {
+	process.stdout.write(text$1 + "\n");
+}
+function renderItem(item, view, opts) {
+	const projected = applyProjection(item, view, opts.full, opts.fields);
+	const body = renderItemBody(item, view, projected, opts) + "\n";
+	assertItemWithinMaxBytes(body, opts);
+	process.stdout.write(body);
+}
+function renderSummary(item, view, summaryText, opts) {
+	if (opts.format === "json" || opts.fields !== void 0 || opts.full) {
+		renderItem(item, view, opts);
+		return;
+	}
+	const body = (typeof summaryText === "function" ? summaryText() : summaryText) + "\n";
+	assertItemWithinMaxBytes(body, opts);
+	process.stdout.write(body);
+}
+function renderList(envelope, view, opts) {
+	if (opts.format === "json") {
+		renderJsonEnvelope(envelope, view, opts);
+		return;
+	}
+	if (envelope.data.length === 0) {
+		process.stdout.write("(no results)\n");
+		return;
+	}
+	if (opts.fields !== void 0) {
+		renderProjectedTable(envelope, view, opts.fields, opts.maxBytes);
+		return;
+	}
+	const capped = capListEnvelope(envelope, opts.maxBytes);
+	process.stdout.write(renderTable(capped.data, view.tableColumns) + "\n");
+	if (capped.truncated !== void 0) warn(listTruncationNotice(capped.truncated.bytes));
+}
+function renderProjectedTable(envelope, view, fields, maxBytes) {
+	const projectedItems = projectListItems(envelope.data, view, false, fields);
+	const capped = capListEnvelope({
+		...envelope,
+		data: projectedItems
+	}, maxBytes);
+	const rows = capped.data.map((item) => fields.map((path) => formatScalar(pickPath(item, path.split(".")))));
+	process.stdout.write(renderRows(fields, rows) + "\n");
+	if (capped.truncated !== void 0) warn(listTruncationNotice(capped.truncated.bytes));
+}
+function projectListItems(items, view, full, fields) {
+	try {
+		return items.map((item) => applyProjection(item, view, full, fields));
+	} catch (error) {
+		throw enrichListFieldPathError(error, fields);
+	}
+}
+function enrichListFieldPathError(error, fields) {
+	if (fields === void 0 || !(error instanceof ConfigError) || !error.message.startsWith("unknown field path")) return error;
+	const prefix = "data.";
+	const culprit = fields.find((field) => field === "data" || field.startsWith(prefix));
+	if (culprit === void 0) return error;
+	const suggestion = culprit.startsWith(prefix) ? culprit.slice(prefix.length) : "<field>";
+	return new ConfigError(`${error.message} — on list commands --fields paths are relative to each item in \`data\`, not the envelope. Drop the \`data.\` prefix (e.g. use \`${suggestion}\` instead of \`${culprit}\`).`);
+}
+function renderJsonEnvelope(envelope, view, opts) {
+	const projectedItems = projectListItems(envelope.data, view, opts.full, opts.fields);
+	const projectedEnvelope = {
+		...envelope,
+		data: projectedItems
+	};
+	const capped = capListEnvelope(projectedEnvelope, opts.maxBytes);
+	const ordered = {
+		returned: capped.returned,
+		total: capped.total,
+		limit: capped.limit,
+		truncated: capped.truncated,
+		data: capped.data
+	};
+	process.stdout.write(serializeJson(ordered, stdoutPretty()) + "\n");
+	if (capped.truncated !== void 0) warn(listTruncationNotice(capped.truncated.bytes));
+}
+function renderItemBody(item, view, projected, opts) {
+	if (opts.format === "json") return serializeJson(projected, stdoutPretty());
+	if (opts.fields !== void 0 || opts.full) return renderKeyValueLines(objectPairs(projected));
+	return renderKeyValueLines(columnPairs(item, view.tableColumns));
+}
+function columnPairs(item, columns) {
+	return columns.map((column) => [column.label ?? column.key, formatCell(item, column)]);
+}
+function objectPairs(value) {
+	if (!isPlainObject(value)) {
+		const scalar = formatScalar(value);
+		return scalar === "" ? [] : [["", scalar]];
+	}
+	return Object.entries(value).map(([key, raw]) => [key, formatScalar(raw)]);
+}
+function renderKeyValueLines(pairs) {
+	if (pairs.length === 0) return "";
+	const padding = Math.max(...pairs.map(([label]) => label.length));
+	return pairs.map(([label, value]) => `${label.padEnd(padding)}  ${value}`).join("\n");
+}
+function assertItemWithinMaxBytes(body, opts) {
+	if (opts.maxBytes <= 0) return;
+	const bytes = Buffer.byteLength(body, "utf8");
+	if (bytes <= opts.maxBytes) return;
+	throw new ConfigError(itemOversizeMessage(bytes, opts.maxBytes, opts.oversizeHint));
+}
+
+//#endregion
+//#region src/output/error.ts
+const VERBOSE_BREADCRUMB = "(rerun with MB_VERBOSE=1 for details)";
+function reportError(error, format) {
+	const handled = toMetabaseError(error);
+	const verbose = readEnv(ENV_VERBOSE) === "1";
+	if (format === "json") writeJsonError(handled, verbose);
+	else writeTextError(handled, verbose);
+	for (const message of consumeLegacyEnvWarnings()) warn(message);
+	process.exitCode = handled.exitCode;
+}
+function writeTextError(handled, verbose) {
+	process.stderr.write(handled.userMessage + "\n");
+	if (handled.developerDetail === null) return;
+	if (verbose) process.stderr.write(serializeJson(handled.developerDetail, stderrPretty()) + "\n");
+	else process.stderr.write(VERBOSE_BREADCRUMB + "\n");
+}
+function stderrPretty() {
+	return process.stderr.isTTY === true;
+}
+function writeJsonError(handled, verbose) {
+	const payload = {
+		category: handled.category,
+		message: handled.userMessage,
+		exitCode: handled.exitCode
+	};
+	if (verbose && handled.developerDetail !== null) payload.detail = handled.developerDetail;
+	const envelope = {
+		ok: false,
+		error: payload
+	};
+	process.stderr.write(serializeJson(envelope, stderrPretty()) + "\n");
+}
+
+//#endregion
+//#region src/runtime/capabilities.ts
+const Capabilities = z.object({
+	minVersion: z.number(),
+	tokenFeature: z.string().optional()
+});
+const BASELINE_CAPABILITIES = Object.freeze({ minVersion: 58 });
+
+//#endregion
+export { AbortError, BASELINE_CAPABILITIES, Capabilities, ChainedRequestError, ConfigError, DEFAULT_MAX_BYTES, ENV_API_KEY, ENV_DISABLE_KEYRING, ENV_PROFILE, ENV_SKIP_PREFLIGHT, ENV_URL, MetabaseError, NetworkError, ResponseShapeError, TimeoutError, UnknownError, ValidationError, connectionFlags, consumeLegacyEnvWarnings, errorMessage, escapeJsonPointerSegment, flagConsumesValue, formatScalar, isNotFoundError, isPlainObject, jsonLine, listEnvelopeSchema, listTruncationNotice, normalizeFlag, outputFlags, package_default, profileFlag, readEnv, renderItem, renderList, renderRows, renderSummary, reportError, resolveCitty, toAliasArray, warn, wrapList, writeJson, writeText };