better-supabase 0.7.1 → 0.9.0

package/dist/cli/run-CM_2g6KQ.js

@@ -0,0 +1,684 @@
+import { c as COMMANDS, d as GROUPS, f as RESERVED_NAMES, h as runCommand, i as joinRepeated, m as parseArgs$2, o as listArgs, s as runsWithInvalidConfig, t as GLOBAL_ARGS, u as DOCS_ORIGIN } from "./command-CK9Cn8HV.js";
+import { n as highlight, r as painter } from "./style-2JfIPVMQ.js";
+import { t as VERSION } from "./version-DNRW4DAP.js";
+import { n as CliError, o as toCliError } from "./errors-Caiz_0so.js";
+import { a as resolveAgent, i as missingInputNext, t as checkConsent } from "./agent-CCt_aXpJ.js";
+import { a as globalFlags, c as resolveCommand, i as commandTree, n as closestName, o as isVariadic, r as commandArgs, t as checkArgs } from "./parse-DE59XyWt.js";
+import { n as movedCommand, r as movedFlag } from "./moved-D9OT_Uyy.js";
+import { n as HTTP_CHANNEL, t as EXEC_CHANNEL } from "./trace-VbdO6bcN.js";
+import { stripVTControlCharacters } from "node:util";
+import { subscribe, unsubscribe } from "node:diagnostics_channel";
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+//#region src/cli/builtin-commands.ts
+/**
+* The module behind each built-in command, by its path in the manifest.
+* Each loads on demand, so `--version` and `--help` import no command.
+*/
+const LOADERS = [
+	["init", () => import("./init-B1dL-RZL.js").then((m) => m.initCommand)],
+	["add", () => import("./add-CT6p5psO.js").then((m) => m.addCommand)],
+	["apply", () => import("./apply-Dxk8AUNU.js").then((m) => m.applyCommand)],
+	["adopt", () => import("./adopt-C9jl8z0h.js").then((m) => m.adoptCommand)],
+	["preset decode", () => import("./preset-DmcC4nWE.js").then((m) => m.presetDecodeCommand)],
+	["preset info", () => import("./preset-DmcC4nWE.js").then((m) => m.presetInfoCommand)],
+	["blocks list", () => import("./blocks-Bzz326nn.js").then((m) => m.blocksListCommand)],
+	["blocks view", () => import("./blocks-Bzz326nn.js").then((m) => m.blocksViewCommand)],
+	["blocks search", () => import("./blocks-Bzz326nn.js").then((m) => m.blocksSearchCommand)],
+	["skills list", () => import("./skills-v34NDb2D.js").then((m) => m.skillsListCommand)],
+	["skills install", () => import("./skills-v34NDb2D.js").then((m) => m.skillsInstallCommand)],
+	["completion", () => import("./completion-J3dqnNoW.js").then((m) => m.completionCommand)],
+	["env", () => import("./env-D3gZ-OHj.js").then((m) => m.envCommand)],
+	["keys", () => import("./keys-jsxCNJdz.js").then((m) => m.keysCommand)],
+	["gen", () => import("./gen-B344S1Oy.js").then((m) => m.genCommand)],
+	["introspect", () => import("./introspect-BPcFi8ow.js").then((m) => m.introspectCommand)],
+	["spec emit", () => import("./spec-De0cfceR.js").then((m) => m.specEmitCommand)],
+	["spec validate", () => import("./spec-De0cfceR.js").then((m) => m.specValidateCommand)],
+	["scaffold api", () => import("./scaffold-Dsjr7sOT.js").then((m) => m.scaffoldApiCommand)],
+	["scaffold screens", () => import("./scaffold-Dsjr7sOT.js").then((m) => m.scaffoldScreensCommand)],
+	["seed", () => import("./seed-DtRFysBe.js").then((m) => m.seedCommand)],
+	["doctor", () => import("./doctor-SGw36h1D.js").then((m) => m.doctorCommand)],
+	["config", () => import("./config-MuKY9kUj.js").then((m) => m.configCommand)],
+	["sql list", () => import("./sql-0I1EQ3JG.js").then((m) => m.sqlListCommand)],
+	["sql add", () => import("./sql-0I1EQ3JG.js").then((m) => m.sqlAddCommand)],
+	["sql sync", () => import("./sql-0I1EQ3JG.js").then((m) => m.sqlSyncCommand)],
+	["sql upgrade", () => import("./sql-0I1EQ3JG.js").then((m) => m.sqlUpgradeCommand)],
+	["sql data", () => import("./sql-0I1EQ3JG.js").then((m) => m.sqlDataCommand)],
+	["sql print", () => import("./sql-0I1EQ3JG.js").then((m) => m.sqlPrintCommand)],
+	["codemod 0.4", () => import("./codemod-woL4cVe0.js").then((m) => m.codemodCommand("0.4"))],
+	["codemod 0.5", () => import("./codemod-woL4cVe0.js").then((m) => m.codemodCommand("0.5"))],
+	["codemod 0.6", () => import("./codemod-woL4cVe0.js").then((m) => m.codemodCommand("0.6"))],
+	["codemod 0.9", () => import("./codemod-woL4cVe0.js").then((m) => m.codemodCommand("0.9"))]
+];
+/** The built-in commands, for `createCli`. */
+function builtinCommands() {
+	return {
+		commands: COMMANDS,
+		loaders: new Map(LOADERS)
+	};
+}
+//#endregion
+//#region src/cli/core/help.ts
+const COMMANDS_SCHEMA_URL = "https://unpkg.com/better-supabase/schemas/cli-commands-v1.json";
+/** Help-only flags `run()` answers itself, listed with the global options. */
+const HELP_ARGS = { help: {
+	type: "boolean",
+	alias: "h",
+	description: "Show help"
+} };
+const ROOT_ARGS = { version: {
+	type: "boolean",
+	description: "Print the version"
+} };
+/** Two columns, the first padded to its widest cell, with no trailing spaces. */
+function table(rows) {
+	const width = Math.max(0, ...rows.map(([left]) => left.length));
+	return rows.map(([left, right]) => `  ${left.padEnd(width)}  ${right}`.trimEnd());
+}
+function section(title, lines, paint) {
+	return lines.length === 0 ? [] : [
+		"",
+		paint("bold", title),
+		...lines
+	];
+}
+const docsUrl = (path) => `${DOCS_ORIGIN}${path}`;
+/** A list option's hint ends in `,...`, unless the command already wrote it. */
+const listHint = (hint, list) => list && !hint.endsWith("...") ? `${hint},...` : hint;
+function optionName(name, definition, list) {
+	const aliases = "alias" in definition ? [definition.alias].flat().map((alias) => alias.length === 1 ? `-${alias}` : `--${alias}`) : [];
+	const hint = definition.type === "enum" && definition.options ? `<${definition.options.join("|")}>` : definition.type === "string" ? `<${listHint(definition.valueHint ?? name, list)}>` : "";
+	const flag = negated(definition) ? `no-${name}` : name;
+	return [...aliases, `--${flag}${hint ? ` ${hint}` : ""}`].join(", ");
+}
+/** A boolean that is on by default, so the flag a person types is `--no-<name>`. */
+const negated = (definition) => definition.type === "boolean" && definition.default === true;
+function optionDescription(definition) {
+	const fallback = definition.default === void 0 || definition.default === false || negated(definition) ? "" : ` (default: ${String(definition.default)})`;
+	return `${(negated(definition) && "negativeDescription" in definition ? definition.negativeDescription : definition.description) ?? ""}${fallback}`;
+}
+function optionRows(args, lists) {
+	return Object.entries(args).flatMap(([name, definition]) => definition.type === "positional" ? [] : [[optionName(name, definition, lists.has(name)), optionDescription(definition)]]);
+}
+/** citty requires a positional unless it is `required: false` or has a default. */
+const isRequired = (definition) => definition.required !== false && definition.default === void 0;
+function positionalName(name, definition) {
+	const label = `${name}${isVariadic(definition) ? "..." : ""}`;
+	return isRequired(definition) ? `<${label}>` : `[${label}]`;
+}
+function ownArgs(args) {
+	return Object.fromEntries(Object.entries(args).filter(([name]) => !(name in GLOBAL_ARGS)));
+}
+function effectText(effect) {
+	const base = (() => {
+		switch (effect.kind) {
+			case "files": return "writes files";
+			case "database": return effect.access === "read" ? "reads the database" : "writes to the database";
+			case "network": switch (effect.target) {
+				case "supabase-api": return "calls the Supabase Management API";
+				case "github": return "downloads from GitHub";
+				default: return effect.target;
+			}
+			default: return effect;
+		}
+	})();
+	return effect.when ? `${base} with ${effect.when}` : base;
+}
+/** The Side effects line: "Writes files, reads the database." */
+function effectsLine(effects) {
+	if (effects.length === 0) return "None.";
+	const text = effects.map(effectText).join(", ");
+	return `${text.charAt(0).toUpperCase()}${text.slice(1)}.`;
+}
+function exampleLines(examples, options) {
+	return (examples ?? []).flatMap((example) => [`  ${options.paint("dim", `# ${example.description}`)}`, `  $ ${example.command.replace(/^better-supabase\b/, options.bin)}`]);
+}
+const GLOBAL_ROWS = () => optionRows({
+	...GLOBAL_ARGS,
+	...HELP_ARGS
+}, /* @__PURE__ */ new Set());
+/** The root usage: the commands by group, then the global options. */
+function rootHelp(tree, options) {
+	const { bin, paint } = options;
+	const nodes = [...tree.values()];
+	const groups = [...GROUPS, [void 0, "Other commands"]];
+	return `${[
+		`${paint("bold", bin)} ${paint("dim", `v${options.version}`)}`,
+		options.description,
+		"",
+		`${paint("bold", "Usage:")} ${bin} <command> [options]`,
+		...groups.flatMap(([group, title]) => section(title, table(nodes.filter((node) => node.spec.group === group).map((node) => [node.spec.name, node.spec.description])), paint)),
+		...section("Global options", table([...GLOBAL_ROWS(), ...optionRows(ROOT_ARGS, /* @__PURE__ */ new Set())]), paint),
+		"",
+		`Run ${bin} <command> --help for a command's options.`,
+		`Docs: ${docsUrl("/docs/cli")}`
+	].join("\n")}\n`;
+}
+/** One command's usage: its arguments, options, the global options, examples and the docs link. */
+async function commandHelp(node, options) {
+	const { bin, paint } = options;
+	const name = [bin, ...node.path].join(" ");
+	const command = node.load ? await node.load() : void 0;
+	const args = command ? ownArgs(await commandArgs(command)) : {};
+	const lists = new Set(command ? listArgs(command) : []);
+	const positionals = Object.entries(args).filter(([, definition]) => definition.type === "positional");
+	const subcommands = [...node.children.values()];
+	const usage = [
+		name,
+		...subcommands.length > 0 ? [command ? "[command]" : "<command>"] : [],
+		"[options]",
+		...positionals.map(([arg, definition]) => positionalName(arg, definition))
+	].join(" ");
+	const lines = [
+		`${paint("bold", "Usage:")} ${usage}`,
+		"",
+		node.spec.description,
+		...section("Commands", table(subcommands.map((child) => [child.spec.name, child.spec.description])), paint),
+		...section("Arguments", table(positionals.map(([arg, definition]) => [positionalName(arg, definition), definition.description ?? ""])), paint),
+		...section("Options", table(optionRows(args, lists)), paint),
+		...section("Global options", table(GLOBAL_ROWS()), paint),
+		...section("Examples", exampleLines(node.spec.examples, options), paint)
+	];
+	const footer = [...command && node.spec.effects ? [`Side effects: ${effectsLine(node.spec.effects)}`] : [], ...node.spec.docs ? [`Docs: ${docsUrl(node.spec.docs)}`] : []];
+	if (footer.length > 0) lines.push("", ...footer);
+	return `${lines.join("\n")}\n`;
+}
+function optionJson(name, definition, list) {
+	if (definition.type === "positional") return;
+	const aliases = "alias" in definition ? [definition.alias].flat() : [];
+	return {
+		name,
+		...aliases.length > 0 ? { aliases } : {},
+		type: definition.type ?? "boolean",
+		...definition.description ? { description: definition.description } : {},
+		...definition.valueHint ? { valueHint: definition.valueHint } : {},
+		...definition.default === void 0 ? {} : { default: definition.default },
+		...definition.type === "enum" && definition.options ? { choices: definition.options } : {},
+		...list ? { list: true } : {}
+	};
+}
+function optionsJson(args, lists) {
+	return Object.entries(args).flatMap(([name, definition]) => {
+		const option = optionJson(name, definition, lists.has(name));
+		return option ? [option] : [];
+	});
+}
+/** One command and its subcommands as `cli-commands-v1.json` describes them. Loads every leaf. */
+async function commandJson(node) {
+	const command = node.load ? await node.load() : void 0;
+	const args = command ? ownArgs(await commandArgs(command)) : {};
+	const lists = new Set(command ? listArgs(command) : []);
+	const children = await Promise.all([...node.children.values()].map(commandJson));
+	return {
+		name: node.spec.name,
+		path: node.path.join(" "),
+		description: node.spec.description,
+		...node.spec.group ? { group: node.spec.group } : {},
+		...node.spec.docs ? { docs: docsUrl(node.spec.docs) } : {},
+		...node.spec.examples ? { examples: node.spec.examples } : {},
+		...node.spec.effects ? { effects: node.spec.effects } : {},
+		arguments: Object.entries(args).flatMap(([name, definition]) => definition.type === "positional" ? [{
+			name,
+			...definition.description ? { description: definition.description } : {},
+			required: isRequired(definition),
+			variadic: isVariadic(definition)
+		}] : []),
+		options: optionsJson(args, lists),
+		...children.length > 0 ? { commands: children } : {}
+	};
+}
+/** The whole command tree for `--help --json`. */
+async function treeJson(tree, version) {
+	return {
+		$schema: COMMANDS_SCHEMA_URL,
+		name: "better-supabase",
+		version,
+		options: optionsJson({
+			...GLOBAL_ARGS,
+			...HELP_ARGS,
+			...ROOT_ARGS
+		}, /* @__PURE__ */ new Set()),
+		commands: await Promise.all([...tree.values()].map(commandJson))
+	};
+}
+//#endregion
+//#region src/cli/core/log.ts
+const milliseconds = (start, end) => `${Math.round(end - start)}ms`;
+function createLog(options) {
+	const { write, paint, debug, spinner } = options;
+	const now = options.now ?? (() => performance.now());
+	const line = (text) => {
+		write(text.endsWith("\n") ? text : `${text}\n`);
+	};
+	return {
+		info: line,
+		warn: (text) => {
+			line(`${paint("yellow", "Warning:")} ${text}`);
+		},
+		error: (text) => {
+			line(paint("red", text));
+		},
+		debug: (text) => {
+			if (debug) line(paint("dim", `debug ${text}`));
+		},
+		progress: async (message, task) => {
+			const stop = spinner?.(message);
+			const start = now();
+			try {
+				return await task();
+			} finally {
+				stop?.();
+				if (debug) line(paint("dim", `debug ${message}: ${milliseconds(start, now())}`));
+			}
+		}
+	};
+}
+//#endregion
+//#region src/cli/core/output.ts
+const RESULT_SCHEMA_URL = "https://unpkg.com/better-supabase/schemas/cli-result-v1.json";
+const statusOf = (exitCode) => {
+	if (exitCode === 0) return "success";
+	return exitCode === 3 ? "action_required" : "error";
+};
+function defaultErrorCode(exitCode) {
+	switch (exitCode) {
+		case 2: return "usage";
+		case 3: return "input_required";
+		case 130: return "cancelled";
+		default: return "failed";
+	}
+}
+/** The `--json` envelope for a run that ended with `exitCode`. */
+function envelope(exitCode, parts = {}) {
+	return {
+		$schema: RESULT_SCHEMA_URL,
+		status: statusOf(exitCode),
+		...parts.data === void 0 ? {} : { data: parts.data },
+		...parts.error ? { error: parts.error } : {},
+		...parts.next && parts.next.length > 0 ? { next: parts.next } : {}
+	};
+}
+const document = (value) => JSON.stringify(value, null, 2);
+function nextText(next, paint) {
+	const width = Math.max(...next.map((step) => step.command.length));
+	return ["Next:", ...next.map((step) => `  ${paint("cyan", step.command.padEnd(width))}  ${step.when}`)].join("\n");
+}
+/**
+* A command's result. Under `--json`, stdout gets the envelope with the
+* command's `data`, its `next` steps, and Problem Details when it failed;
+* the text output moves to stderr as a diagnostic.
+*/
+function renderResult(result, options) {
+	const next = result.next ?? [];
+	const errorPaint = options.errorPaint ?? options.paint;
+	if (result.streamed === true) return {};
+	if (result.raw !== void 0) return { raw: result.raw };
+	if (!options.json) {
+		const stdout = [...result.output ? [highlight(result.output, options.paint)] : [], ...next.length > 0 && result.code === 0 ? [nextText(next, options.paint)] : []].join("\n\n");
+		return {
+			...stdout ? { stdout } : {},
+			...result.error ? { stderr: errorPaint("red", result.error) } : {}
+		};
+	}
+	const failed = result.code !== 0;
+	const problem = failed ? new CliError(result.errorCode ?? defaultErrorCode(result.code), result.error ?? result.output ?? "The command failed.", { exitCode: result.code }).problem : void 0;
+	const diagnostics = [...result.output ? [result.output] : [], ...result.error && !failed ? [result.error] : []];
+	const shown = envelope(result.code, {
+		...result.data === void 0 ? {} : { data: result.data },
+		...problem ? { error: problem } : {},
+		next
+	});
+	return {
+		stdout: options.compact === true ? JSON.stringify(shown) : document(shown),
+		...diagnostics.length > 0 ? { stderr: diagnostics.join("\n") } : {}
+	};
+}
+/** An error that stopped the run, with the usage text for usage errors. */
+function renderError(error, options) {
+	if (options.json) return { stdout: document(envelope(error.exitCode, {
+		error: error.problem,
+		next: error.next
+	})) };
+	return { stderr: [
+		error.message,
+		...error.next.length > 0 ? [nextText(error.next, options.errorPaint ?? options.paint)] : [],
+		...options.usage ? [options.usage] : []
+	].join("\n\n") };
+}
+//#endregion
+//#region src/cli/core/run.ts
+const ROOT_DESCRIPTION = "Typed Supabase: codegen, doctor, the SQL modules and project setup";
+const DEFAULT_BIN = "better-supabase";
+function isCommandResult(value) {
+	return typeof value === "object" && value !== null && "code" in value && typeof value.code === "number";
+}
+const SHOWS_USAGE = /* @__PURE__ */ new Set([
+	"usage",
+	"unknown_command",
+	"unknown_flag",
+	"invalid_value"
+]);
+/** The stack of `cause` and of each error in its `cause` chain, for `--debug`. */
+function stackText(cause) {
+	const stacks = [];
+	let current = cause;
+	while (current instanceof Error && stacks.length < 10) {
+		stacks.push(current.stack ?? `${current.name}: ${current.message}`);
+		current = current.cause;
+	}
+	return stacks.length === 0 ? String(cause) : stacks.join("\nCaused by: ");
+}
+/** `--cwd` resolved against `base`; it has to name an existing directory. */
+function projectDirectory(base, flag) {
+	if (flag === void 0) return resolve(base);
+	if (flag.trim() === "") throw new CliError("missing_value", "--cwd needs a directory.", { flag: "--cwd" });
+	const directory = resolve(base, flag);
+	if (!statSync(directory, { throwIfNoEntry: false })?.isDirectory()) throw new CliError("invalid_value", `--cwd ${flag} is not a directory.`, { flag: "--cwd" });
+	return directory;
+}
+/** `--force` on a run that writes: not under `--dry-run` or `--check`. */
+function forcesOverwrite(rest) {
+	const end = rest.indexOf("--");
+	const options = new Set(end === -1 ? rest : rest.slice(0, end));
+	return (options.has("--force") || options.has("--force=true")) && !options.has("--dry-run") && !options.has("--check");
+}
+function withoutPrompts(io) {
+	const { prompts: _prompts, ...rest } = io;
+	return rest;
+}
+function metaDescription(command) {
+	const { meta } = command;
+	return typeof meta === "object" && !(meta instanceof Promise) ? meta.description ?? "" : "";
+}
+/** The tree node for one of the app's own commands, after checking its contract and name. */
+function extraCommand(tree, name, command) {
+	if (command.apiVersion !== 1) throw new CliError("usage", `Command "${name}" has no CLI command API version; define it with defineCliCommand.`);
+	if (tree.has(name) || RESERVED_NAMES.includes(name)) throw new CliError("usage", `Command "${name}" is taken by a better-supabase command; pick another name.`);
+	return {
+		spec: {
+			name,
+			description: metaDescription(command)
+		},
+		path: [name],
+		load: () => Promise.resolve(command),
+		children: /* @__PURE__ */ new Map()
+	};
+}
+/** A CLI over its own command tree, so tests and embedders don't share state through the module. */
+function cliFromTree(init, extra = {}) {
+	const tree = commandTree(init.commands, init.loaders);
+	for (const [name, command] of Object.entries(extra)) tree.set(name, extraCommand(tree, name, command));
+	const helpText = async (path, bin, color) => {
+		const paint = painter(color);
+		const options = {
+			bin,
+			version: VERSION,
+			description: ROOT_DESCRIPTION,
+			paint
+		};
+		const resolution = resolveCommand(tree, path);
+		return resolution.kind === "command" ? commandHelp(resolution.node, options) : rootHelp(tree, options);
+	};
+	const help = async (command, color = false) => {
+		const text = await helpText(command === void 0 ? [] : command.split(" "), DEFAULT_BIN, color);
+		return color ? text : stripVTControlCharacters(text);
+	};
+	const run = async (argv, options = {}) => {
+		const stdout = [];
+		const stderr = [];
+		const bin = options.bin ?? DEFAULT_BIN;
+		const io = options.io ?? {
+			stdout: (text) => {
+				stdout.push(text);
+			},
+			stderr: (text) => {
+				stderr.push(text);
+			}
+		};
+		const out = (text) => {
+			const line = text.endsWith("\n") ? text : `${text}\n`;
+			if (options.io) stdout.push(line);
+			io.stdout(line);
+		};
+		const fail = (text) => {
+			const line = text.endsWith("\n") ? text : `${text}\n`;
+			if (options.io) stderr.push(line);
+			io.stderr(line);
+		};
+		if (argv[0] === "__complete") {
+			const words = argv[1] === "--" ? argv.slice(2) : argv.slice(1);
+			const lines = await import("./completion-BO5UK6bG.js").then(async ({ complete, completionLines }) => completionLines(await complete(tree, words))).catch(() => "");
+			if (lines !== "") out(lines);
+			return {
+				code: 0,
+				stdout: stdout.join(""),
+				stderr: stderr.join("")
+			};
+		}
+		const flags = globalFlags(argv);
+		const { debug, color } = flags;
+		let agent;
+		let agentError;
+		try {
+			agent = resolveAgent(flags.agent, options.env ?? {}, {
+				stdoutIsTty: io.stdoutIsTty === true,
+				exists: io.exists ?? (() => false)
+			});
+		} catch (cause) {
+			agentError = cause;
+		}
+		const json = flags.json || agent !== void 0 && !flags.noJson;
+		const paint = painter(io.color === true && color);
+		const errorPaint = painter((io.stderrColor ?? io.color) === true && color);
+		const log = createLog({
+			write: fail,
+			paint: errorPaint,
+			debug,
+			...io.spinner ? { spinner: io.spinner } : {}
+		});
+		const started = performance.now();
+		const usage = (path = []) => helpText(path, bin, io.color === true && color);
+		const finish = (code) => {
+			log.debug(`exit ${code} after ${milliseconds(started, performance.now())}`);
+			return {
+				code,
+				stdout: stdout.join(""),
+				stderr: stderr.join("")
+			};
+		};
+		let resolution = resolveCommand(tree, argv);
+		if (resolution.kind === "unknown" && resolution.parent.length === 0 && resolution.name === "help") {
+			const topic = resolveCommand(tree, resolution.rest);
+			resolution = topic.kind === "command" ? {
+				...topic,
+				rest: [...topic.rest, "--help"]
+			} : topic.kind === "root" ? {
+				kind: "root",
+				rest: ["--help"]
+			} : topic;
+		}
+		const path = resolution.kind === "command" ? resolution.node.path : [];
+		const { help: wantsHelp } = globalFlags(resolution.rest);
+		const report = (rendered) => {
+			if (rendered.raw !== void 0) {
+				if (options.io) stdout.push(rendered.raw);
+				io.stdout(rendered.raw);
+			}
+			if (rendered.stdout) out(rendered.stdout);
+			if (rendered.stderr) fail(rendered.stderr);
+		};
+		const reportError = async (cause, usagePath = path) => {
+			const thrown = toCliError(cause);
+			const { type: _type, title: _title, detail: _detail, code: _code, ...extensions } = thrown.problem;
+			const error = thrown.code === "input_required" && thrown.next.length === 0 && extensions.missing ? new CliError(thrown.code, thrown.message, {
+				...extensions,
+				cause: thrown,
+				next: [missingInputNext(argv, extensions.missing, extensions.choices)]
+			}) : thrown;
+			if (debug) log.debug(stackText(cause));
+			const shown = error.code === "usage" ? new CliError("usage", stripVTControlCharacters(error.message), {
+				...error.problem.flag ? { flag: error.problem.flag } : {},
+				...error.problem.suggestion ? { suggestion: error.problem.suggestion } : {},
+				...error.problem.choices ? { choices: error.problem.choices } : {}
+			}) : error;
+			report(renderError(shown, {
+				json,
+				paint,
+				errorPaint,
+				...SHOWS_USAGE.has(error.code) ? { usage: await usage(usagePath) } : {}
+			}));
+			return finish(error.exitCode);
+		};
+		const printHelp = async (node) => {
+			if (flags.json) {
+				const document = await treeJson(node ? /* @__PURE__ */ new Map([[node.spec.name, node]]) : tree, VERSION);
+				out(JSON.stringify(document, null, 2));
+			} else out(await usage(node?.path));
+			return finish(0);
+		};
+		if (resolution.kind === "unknown") {
+			const { parent, name, candidates } = resolution;
+			if (parent.length === 0 && name === "version") {
+				out(flags.json ? document(envelope(0, { data: { version: VERSION } })) : VERSION);
+				return finish(0);
+			}
+			const moved = movedCommand(argv, bin);
+			if (moved) return reportError(moved, parent);
+			const suggestion = await closestName(name, candidates);
+			const full = [...parent, name].join(" ");
+			const suggested = suggestion ? [...parent, suggestion].join(" ") : "";
+			return reportError(new CliError("unknown_command", `Unknown command "${full}".${suggestion ? ` Did you mean "${suggested}"?` : ""}`, suggestion ? { suggestion: suggested } : {}), parent);
+		}
+		if (resolution.kind === "root") {
+			const end = resolution.rest.indexOf("--");
+			if ((end === -1 ? resolution.rest : resolution.rest.slice(0, end)).includes("--version")) {
+				out(flags.json ? document(envelope(0, { data: { version: VERSION } })) : VERSION);
+				return finish(0);
+			}
+			if (wantsHelp) return printHelp();
+			if (agentError !== void 0) return reportError(agentError);
+			if (json) return reportError(new CliError("usage", "Name a command.", { choices: { "<command>": [...tree.keys()] } }));
+			fail(await usage());
+			return finish(2);
+		}
+		const { node, rest } = resolution;
+		if (wantsHelp) return printHelp(node);
+		if (!node.load) {
+			const names = [...node.children.keys()];
+			return reportError(new CliError("usage", `Name a ${node.path.join(" ")} subcommand: ${names.join(", ")}.`, { choices: { "<command>": names } }));
+		}
+		const movedOption = movedFlag(node.path, rest, bin);
+		if (movedOption) return reportError(movedOption);
+		if (agentError !== void 0) return reportError(agentError);
+		let context;
+		let command;
+		let rawArgs;
+		try {
+			const [loaded, { defaultConfig, discoverConfig, loadConfig }, { configEnvironment, isCi, parseEnv }] = await Promise.all([
+				node.load(),
+				import("./config-C1d-mbUA.js"),
+				import("./env-DJ4ZaJpe.js")
+			]);
+			command = loaded;
+			rawArgs = joinRepeated(rest, listArgs(command));
+			if (command.args !== void 0) await checkArgs(await commandArgs(command), rawArgs, [bin, ...node.path].join(" "));
+			const globals = parseArgs$2([...rest], GLOBAL_ARGS);
+			const cwd = projectDirectory(options.cwd ?? ".", globals.cwd);
+			const env = parseEnv(options.env ?? {});
+			const environment = configEnvironment(globals.env, env);
+			const configFile = discoverConfig(cwd, globals.config);
+			const loadWith = (path) => loadConfig(cwd, globals.config, environment, path).catch((cause) => {
+				throw cause instanceof CliError ? cause : new CliError("config_invalid", toCliError(cause).message, { cause });
+			});
+			const reloadConfig = () => loadWith();
+			const config = await loadWith(configFile).catch((cause) => {
+				if (runsWithInvalidConfig(command) && toCliError(cause).code === "config_invalid") return defaultConfig(cwd, globals.config, environment, configFile);
+				throw cause;
+			});
+			const interactive = !json && globals.yes !== true && !isCi(env) && agent === void 0;
+			const requireConsent = (request) => {
+				if (agent !== void 0) checkConsent(argv, request, globals.confirm);
+			};
+			context = {
+				cwd,
+				config,
+				...configFile ? { configFile } : {},
+				reloadConfig,
+				io: interactive ? io : withoutPrompts(io),
+				env,
+				json,
+				signal: options.signal,
+				log,
+				paint,
+				emit: (result) => {
+					report(renderResult(result, {
+						json,
+						paint,
+						errorPaint,
+						compact: true
+					}));
+				},
+				agent,
+				requireConsent
+			};
+			if (forcesOverwrite(rest)) requireConsent({
+				effect: "overwrite",
+				detail: `${node.path.join(" ")} --force overwrites files better-supabase did not write`
+			});
+		} catch (cause) {
+			return reportError(cause);
+		}
+		const traceExec = (message) => {
+			const event = message;
+			log.debug(`exec ${[event.command, ...event.args].join(" ")} (in ${event.cwd}): exit ${event.code} after ${event.milliseconds}ms`);
+		};
+		const traceHttp = (message) => {
+			const event = message;
+			log.debug(`http ${event.method} ${event.url}: ${event.status ?? "no response"} after ${event.milliseconds}ms`);
+		};
+		if (debug) {
+			subscribe(EXEC_CHANNEL, traceExec);
+			subscribe(HTTP_CHANNEL, traceHttp);
+		}
+		try {
+			const { result } = await runCommand(command, {
+				rawArgs,
+				data: context
+			});
+			if (!isCommandResult(result)) return finish(0);
+			report(renderResult(result, {
+				json,
+				paint,
+				errorPaint
+			}));
+			return finish(result.code);
+		} catch (cause) {
+			return await reportError(cause);
+		} finally {
+			if (debug) {
+				unsubscribe(EXEC_CHANNEL, traceExec);
+				unsubscribe(HTTP_CHANNEL, traceHttp);
+			}
+		}
+	};
+	return {
+		run,
+		help,
+		commandNames: () => [...tree.keys()]
+	};
+}
+/**
+* A CLI with every built-in command plus `options.commands`. Each one has to
+* come from `defineCliCommand` (`apiVersion: 1`) and take a free name.
+*/
+function createCli(options = {}) {
+	return cliFromTree(builtinCommands(), options.commands);
+}
+/** The CLI the `better-supabase` bin runs, with every built-in command. */
+const defaultCli = cliFromTree(builtinCommands());
+const run = (argv, options) => defaultCli.run(argv, options);
+const help = (command, color) => defaultCli.help(command, color);
+/** The names `run()` dispatches. */
+const commandNames = () => defaultCli.commandNames();
+//#endregion
+export { run as i, createCli as n, help as r, commandNames as t };