better-supabase 0.9.0 → 0.10.0

package/dist/cli/mcp-Bdm2oGmL.js

@@ -0,0 +1,237 @@
+import { p as commandMeta, r as defineCliCommand } from "./command-D_HI1mp1.js";
+import { a as envelope, i as run } from "./run-BLJj7SuM.js";
+import { t as VERSION } from "./version-D1wM9DNb.js";
+import { n as CliError } from "./errors-Caiz_0so.js";
+import { n as consentToken } from "./agent-CCrTYK3W.js";
+import { A as string$1, E as record, M as unknown, O as safeParse, S as optional, a as array, b as object, d as is, o as boolean, t as PROCESS_ENV } from "./env-Cf5OTqbK.js";
+import { createInterface } from "node:readline";
+import { answerLine } from "better-supabase/mcp";
+//#region src/cli/mcp/server.ts
+/**
+* The dev-time MCP server behind `better-supabase mcp`: each tool runs one
+* CLI command in process with `--json` and returns its result envelope.
+* Tools that write files exist only with `--allow-writes`, and each call
+* needs a consent token the user agreed to (ADR 0047, ADR 0049).
+*/
+const Input = object({
+	category: optional(string$1()),
+	block: optional(string$1()),
+	blocks: optional(array(string$1())),
+	text: optional(string$1()),
+	preset: optional(string$1()),
+	allow_breaking: optional(boolean()),
+	confirm: optional(string$1())
+});
+const string = (description) => ({
+	type: "string",
+	description
+});
+const CONFIRM = string("The consent token from the last call's error, once the user agreed to the change");
+const schema = (properties, required = []) => ({
+	type: "object",
+	properties,
+	...required.length > 0 ? { required } : {},
+	additionalProperties: false
+});
+const read = (name, description, inputSchema, argv) => ({
+	info: {
+		name,
+		description,
+		inputSchema,
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: false
+		}
+	},
+	writes: false,
+	argv
+});
+const write = (name, description, properties, required, argv) => ({
+	info: {
+		name,
+		description: `${description} Writes files: the first call returns a consent token; call again with confirm once the user agrees.`,
+		inputSchema: schema({
+			...properties,
+			confirm: CONFIRM
+		}, required),
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			openWorldHint: false
+		}
+	},
+	writes: true,
+	argv
+});
+const PRESET = string("A named preset, a code from /create or a Create URL");
+const TOOLS = [
+	read("doctor", "Checks RLS, indexes, drift, auth config, env files and migration safety, and lists the findings.", schema({}), () => ["doctor"]),
+	read("blocks_list", "Lists the blocks the project can add, optionally in one category.", schema({ category: string("One block category") }), ({ category }) => [
+		"blocks",
+		"list",
+		...category === void 0 ? [] : ["--category", category]
+	]),
+	read("blocks_view", "Shows a block: its tables, the blocks it requires and its options.", schema({ block: string("The block's name") }, ["block"]), ({ block }) => [
+		"blocks",
+		"view",
+		block ?? ""
+	]),
+	read("blocks_search", "Finds blocks by name, description or category.", schema({ text: string("Words to find") }, ["text"]), ({ text }) => [
+		"blocks",
+		"search",
+		...(text ?? "").split(/\s+/)
+	]),
+	read("config", "Prints the resolved config with every option and its default, credentials redacted.", schema({}), () => ["config"]),
+	read("preset_info", "Shows the config's preset and how the config differs from it.", schema({}), () => ["preset", "info"]),
+	read("sql_list", "Lists the SQL modules and which ones the project has.", schema({}), () => ["sql", "list"]),
+	read("gen_check", "Reports the generated files that are out of date, writing nothing.", schema({}), () => ["gen", "--check"]),
+	read("apply_dry_run", "Shows the config diff and the design changes a preset or Create URL makes, with their severity, writing nothing.", schema({ preset: PRESET }, ["preset"]), ({ preset }) => [
+		"apply",
+		"--preset",
+		preset ?? "",
+		"--dry-run"
+	]),
+	write("gen", "Regenerates the typed client and every other generated file.", {}, [], () => ["gen"]),
+	write("sql_sync", "Writes the SQL module files for the blocks the config lists and removes the others.", {}, [], () => ["sql", "sync"]),
+	write("apply", "Applies a preset or Create URL: edits the config and writes the blocks' modules.", {
+		preset: PRESET,
+		allow_breaking: {
+			type: "boolean",
+			description: "Write breaking app table changes such as a rename"
+		}
+	}, ["preset"], ({ preset, allow_breaking: allowBreaking }) => [
+		"apply",
+		"--preset",
+		preset ?? "",
+		...allowBreaking === true ? ["--allow-breaking"] : []
+	]),
+	write("add", "Adds blocks with the blocks they require.", { blocks: {
+		type: "array",
+		items: { type: "string" },
+		minItems: 1
+	} }, ["blocks"], ({ blocks }) => ["add", ...blocks ?? []])
+];
+const INSTRUCTIONS = "Tools for the better-supabase project in this directory. Each returns the CLI's JSON envelope (status, data, error, next). Read with doctor, config, blocks_* and the dry runs first. Tools that write files ask for consent: show the user the error's detail, and call again with confirm set to its token only after they agree.";
+function parsedEnvelope(stdout) {
+	try {
+		const value = JSON.parse(stdout);
+		return is(record(string$1(), unknown()), value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
+function consentResult(name, detail, token) {
+	const error = new CliError("consent_required", `${detail}. Ask the user first, then call ${name} again with confirm "${token}".`, {
+		token,
+		next: [{
+			command: `${name} ${JSON.stringify({ confirm: token })}`,
+			when: "after the user agrees"
+		}]
+	});
+	const body = envelope(error.exitCode, {
+		error: error.problem,
+		next: error.next
+	});
+	return {
+		content: [{
+			type: "text",
+			text: JSON.stringify(body)
+		}],
+		structuredContent: { ...body },
+		isError: true
+	};
+}
+/** The dev MCP server for one project directory. */
+function createDevMcp(options) {
+	const tools = TOOLS.filter((tool) => options.allowWrites === true || !tool.writes);
+	const byName = new Map(tools.map((tool) => [tool.info.name, tool]));
+	const globals = options.globals ?? [];
+	const callTool = async (name, args) => {
+		const tool = byName.get(name);
+		if (!tool) return;
+		const parsed = safeParse(Input, args ?? {});
+		if (!parsed.success) return {
+			content: [{
+				type: "text",
+				text: `Invalid arguments: ${parsed.issues.map((issue) => issue.message).join("; ")}`
+			}],
+			isError: true
+		};
+		const argv = [...tool.argv(parsed.output), ...globals];
+		if (tool.writes) {
+			const detail = `${name} writes files in ${options.cwd}`;
+			const token = consentToken(argv, {
+				effect: "mcp-write",
+				detail
+			});
+			if (parsed.output.confirm !== token) return consentResult(name, detail, token);
+		}
+		const result = await options.run([
+			...argv,
+			"--json",
+			"--agent",
+			"no"
+		], {
+			cwd: options.cwd,
+			env: options.env
+		});
+		const body = parsedEnvelope(result.stdout);
+		const diagnostics = result.stderr.trim();
+		return {
+			content: [{
+				type: "text",
+				text: body ? JSON.stringify(body) : result.stdout
+			}, ...diagnostics === "" ? [] : [{
+				type: "text",
+				text: diagnostics
+			}]],
+			...body ? { structuredContent: body } : {},
+			...result.code === 0 ? {} : { isError: true }
+		};
+	};
+	return {
+		info: {
+			name: "better-supabase",
+			version: VERSION
+		},
+		instructions: INSTRUCTIONS,
+		listTools: () => Promise.resolve(tools.map((tool) => tool.info)),
+		callTool
+	};
+}
+/** Answers each newline-delimited JSON-RPC message in turn, writing one line per response. */
+async function serveLines(lines, server, write) {
+	for await (const line of lines) {
+		if (line.trim() === "") continue;
+		const response = await answerLine(line, server);
+		if (response !== void 0) write(`${JSON.stringify(response)}\n`);
+	}
+}
+const mcpCommand = defineCliCommand({
+	meta: commandMeta("mcp"),
+	args: { "allow-writes": {
+		type: "boolean",
+		description: "Add the tools that write files (gen, sql_sync, apply, add); each call still needs the user's consent token"
+	} },
+	runsWithInvalidConfig: true,
+	run: async (args, { cwd, configFile, config, env, io, log }) => {
+		const server = createDevMcp({
+			run,
+			cwd,
+			env: env[PROCESS_ENV] ?? {},
+			allowWrites: args["allow-writes"] === true,
+			globals: [...configFile ? ["--config", configFile] : [], ...config.environment ? ["--env", config.environment] : []]
+		});
+		log.info(`better-supabase MCP server on stdio for ${cwd}${args["allow-writes"] === true ? " (writes allowed with consent)" : " (read-only)"}`);
+		await serveLines(createInterface({
+			input: process.stdin,
+			crlfDelay: Infinity
+		}), server, io.stdout);
+		return {
+			code: 0,
+			streamed: true
+		};
+	}
+});
+//#endregion
+export { mcpCommand };

package/dist/cli/{metadata-CxBZo4KM.js → metadata-DikbSOE0.js}

@@ -1,8 +1,8 @@
 import { n as CliError, r as errorText } from "./errors-Caiz_0so.js";
 import { i as readStdin } from "./io-BiPX-_J1.js";
 import { a as parseMetadataDocument, t as MetadataRejectedError } from "./typegen--TfvOPLh.js";
-import { i as metaPaths } from "./emit-ZAYeh4Yn.js";
-import { i as generationNotices, k as render, n as runGen, o as fromMetadata, r as UNFORMATTED, t as refuseRowConditionedBuckets } from "./run-DaHfUUO9.js";
+import { i as metaPaths } from "./emit-j0zZ6NE_.js";
+import { b as render, i as generationNotices, n as runGen, o as fromMetadata, r as UNFORMATTED, t as refuseRowConditionedBuckets } from "./run-DliGNdjI.js";
 import { basename, join, relative, resolve, sep } from "node:path";
 import { readFile } from "node:fs/promises";
 import { jsonSchema, standardSchema, valibot, zod } from "better-supabase/config";

package/dist/cli/migration-safety-LaGVPPuD.js

@@ -0,0 +1,206 @@
+import { c as splitStatements } from "./shared-CNcvDOLt.js";
+import { join } from "node:path";
+import { readdir } from "node:fs/promises";
+//#region src/cli/doctor/migration-safety.ts
+const NAME = String.raw`(?:"[^"]+"|[\w$]+)`;
+const TABLE = String.raw`(${NAME}(?:\s*\.\s*${NAME})?)`;
+const CREATE_TABLE = new RegExp(String.raw`^create\s+(?:(?:global\s+|local\s+)?(?:temporary|temp|unlogged)\s+)?table\s+(?:if\s+not\s+exists\s+)?${TABLE}`, "iu");
+const ALTER_TABLE = new RegExp(String.raw`^alter\s+table\s+(?:if\s+exists\s+)?(?:only\s+)?${TABLE}`, "iu");
+const CREATE_INDEX = new RegExp(String.raw`^create\s+(?:unique\s+)?index\s+(concurrently\s+)?(?:if\s+not\s+exists\s+)?(?:${NAME}\s+)?on\s+(?:only\s+)?${TABLE}`, "iu");
+const ADD_CONSTRAINT = /\badd\s+(?:constraint\s+(?:"[^"]+"|[\w$]+)\s+)?(foreign\s+key|check)\b/iu;
+const NOT_VALID = /\bnot\s+valid\b/iu;
+const ALTER_TYPE = /\balter\s+(?:column\s+)?(?:"[^"]+"|[\w$]+)\s+(?:set\s+data\s+)?type\b/iu;
+const SET_NOT_NULL = /\bset\s+not\s+null\b/iu;
+const VALIDATE = /\bvalidate\s+constraint\b/iu;
+const ADD_COLUMN_DEFAULT = /\badd\s+(?:column\s+)?(?:if\s+not\s+exists\s+)?(?:"[^"]+"|[\w$]+)\s[^,]*?\bdefault\s+([^,]+)/giu;
+const VOLATILE = /\b(?:gen_random_uuid|uuid_generate_v[14]|clock_timestamp|timeofday|random|nextval|statement_timestamp)\s*\(/iu;
+const LOCK_TIMEOUT = /^set\s+(?:local\s+)?lock_timeout\b/iu;
+const EXCLUSIVE = /^(?:drop\s+table|truncate|vacuum\s+full|reindex\b(?!.*\bconcurrently\b)|lock\s+table|cluster\b)/iu;
+const DROP = /^drop\s+table\b|\bdrop\s+(?:column\s+)?(?!constraint\b|default\b|not\b|identity\b|expression\b)(?:if\s+exists\s+)?(?:"[^"]+"|[\w$]+)/iu;
+const RENAME = /\brename\s+(?!constraint\b)(?:column\s+)?(?:(?:"[^"]+"|[\w$]+)\s+)?to\b/iu;
+/** `name` without quotes and with `public.` for an unqualified name, lower-cased. */
+function tableKey(name) {
+	const parts = name.split(".").map((part) => part.trim().replaceAll("\"", "").toLowerCase());
+	return parts.length === 1 ? `public.${parts[0] ?? ""}` : parts.join(".");
+}
+/** The version a migration file name or a `since` value starts with. */
+function migrationVersion(name) {
+	const base = name.slice(name.lastIndexOf("/") + 1);
+	return base.replace(/\.sql$/u, "").split("_")[0] ?? base;
+}
+/**
+* The newest migration under `<root>/<supabaseDir>/migrations`, which `init`
+* and `adopt` write to `doctor.migrationSafety.since` so the migrations that
+* already ran aren't checked offline.
+*/
+async function latestMigrationVersion(root, supabaseDir = "supabase") {
+	return (await readdir(join(root, supabaseDir, "migrations")).catch(() => [])).filter((name) => name.endsWith(".sql")).map(migrationVersion).toSorted().at(-1);
+}
+const statementsCache = /* @__PURE__ */ new WeakMap();
+function parse(file) {
+	let parsed = statementsCache.get(file);
+	if (parsed === void 0) {
+		const statements = splitStatements(file.text);
+		parsed = {
+			file,
+			statements,
+			created: new Set(statements.flatMap((statement) => {
+				const match = CREATE_TABLE.exec(statement.text);
+				return match?.[1] === void 0 ? [] : [tableKey(match[1])];
+			}))
+		};
+		statementsCache.set(file, parsed);
+	}
+	return parsed;
+}
+const pending = /* @__PURE__ */ new WeakMap();
+/**
+* The migrations to check: with a database, the ones it hasn't applied;
+* offline, the ones after `doctor.migrationSafety.since`, or the newest one
+* without it.
+*/
+function unappliedMigrations(context) {
+	let files = pending.get(context);
+	if (files === void 0) {
+		files = findUnapplied(context);
+		pending.set(context, files);
+	}
+	return files;
+}
+async function findUnapplied(context) {
+	const dir = `${context.configToml?.dir ?? "supabase"}/migrations/`;
+	const migrations = (context.sqlFiles ?? []).filter((file) => file.path.startsWith(dir)).toSorted((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+	const db = context.database;
+	if (db !== void 0 && !("skipped" in db)) try {
+		const rows = await db.query("select version from supabase_migrations.schema_migrations");
+		const applied = new Set(rows.map((row) => row.version));
+		return migrations.filter((file) => !applied.has(migrationVersion(file.path)));
+	} catch {}
+	const since = context.config.doctor.migrationSafety?.since;
+	if (since === void 0) return migrations.slice(-1);
+	const after = migrationVersion(since);
+	return migrations.filter((file) => migrationVersion(file.path) > after);
+}
+/** A rule that runs `check` on each statement of the unapplied migrations. */
+function perStatement(check) {
+	return async (context) => (await unappliedMigrations(context)).flatMap((file) => {
+		const parsed = parse(file);
+		return parsed.statements.flatMap((statement) => {
+			const message = check(parsed, statement);
+			return message === void 0 ? [] : [{
+				message: `${file.path}:${String(statement.line)}: ${message}`,
+				target: `${file.path}:${String(statement.line)}`,
+				location: {
+					file: file.path,
+					line: statement.line
+				}
+			}];
+		});
+	});
+}
+/** The table an `alter table` statement changes, unless the same file created it. */
+function alteredTable(parsed, statement) {
+	const match = ALTER_TABLE.exec(statement.text);
+	const table = match?.[1] === void 0 ? void 0 : tableKey(match[1]);
+	return table === void 0 || parsed.created.has(table) ? void 0 : table;
+}
+const indexWithoutConcurrently = (parsed, statement) => {
+	const match = CREATE_INDEX.exec(statement.text);
+	if (match === null || match[1] !== void 0 || match[2] === void 0) return;
+	const table = tableKey(match[2]);
+	return parsed.created.has(table) ? void 0 : `creates an index on ${table} without concurrently, which blocks writes to it until the index is built.`;
+};
+const constraintWithoutNotValid = (parsed, statement) => {
+	const table = alteredTable(parsed, statement);
+	const kind = ADD_CONSTRAINT.exec(statement.text)?.[1];
+	if (table === void 0 || kind === void 0 || NOT_VALID.test(statement.text)) return;
+	return `adds a ${kind.toLowerCase().replace(/\s+/u, " ")} to ${table} without not valid, which scans every row while it holds a lock.`;
+};
+const rewriteOrScan = (parsed, statement) => {
+	const table = alteredTable(parsed, statement);
+	if (table === void 0) return;
+	if (ALTER_TYPE.test(statement.text)) return `changes a column type of ${table}, which can rewrite the table under an access exclusive lock.`;
+	const validated = parsed.statements.some((each) => each.line < statement.line && VALIDATE.test(each.text) && alteredTable(parsed, each) === table);
+	return SET_NOT_NULL.test(statement.text) && !validated ? `sets not null on a column of ${table}, which scans every row under an access exclusive lock.` : void 0;
+};
+const volatileDefault = (parsed, statement) => {
+	const table = alteredTable(parsed, statement);
+	if (table === void 0) return;
+	for (const match of statement.text.matchAll(ADD_COLUMN_DEFAULT)) if (VOLATILE.test(match[1] ?? "")) return `adds a column to ${table} with a volatile default (${(match[1] ?? "").trim()}), which rewrites every row.`;
+};
+/** Whether `statement` takes an access exclusive lock on a table others use. */
+function takesExclusiveLock(parsed, statement) {
+	if (EXCLUSIVE.test(statement.text)) return true;
+	const match = CREATE_INDEX.exec(statement.text);
+	if (match?.[2] !== void 0 && match[1] === void 0) return !parsed.created.has(tableKey(match[2]));
+	return alteredTable(parsed, statement) !== void 0;
+}
+async function missingLockTimeout(context) {
+	return (await unappliedMigrations(context)).flatMap((file) => {
+		const parsed = parse(file);
+		const first = parsed.statements.find((statement) => takesExclusiveLock(parsed, statement));
+		if (first === void 0) return [];
+		return parsed.statements.some((statement) => statement.line <= first.line && LOCK_TIMEOUT.test(statement.text)) ? [] : [{
+			message: `${file.path} locks tables it didn't create (line ${String(first.line)}) without setting lock_timeout, so a long query ahead of it queues every read and write behind the migration.`,
+			target: file.path,
+			location: {
+				file: file.path,
+				line: first.line
+			}
+		}];
+	});
+}
+const dropOrRename = (parsed, statement) => {
+	const isDropTable = /^drop\s+table\b/iu.test(statement.text);
+	const table = alteredTable(parsed, statement);
+	if (isDropTable) return "drops a table; app code that still reads it fails once this runs.";
+	if (table === void 0) return;
+	if (RENAME.test(statement.text)) return `renames ${table} or one of its columns; app code that uses the old name fails once this runs.`;
+	return DROP.test(statement.text) ? `drops a column of ${table}; app code that still reads it fails once this runs.` : void 0;
+};
+const MIGRATION_SAFETY_RULES = [
+	{
+		code: "BS229",
+		severity: "warning",
+		title: "Index created without concurrently",
+		description: "A migration creates an index on an existing table without `concurrently`. The build holds a lock that blocks inserts, updates and deletes on the table until it finishes. Use `create index concurrently`, in a migration file of its own: the statement can't run inside a transaction block.",
+		check: perStatement(indexWithoutConcurrently)
+	},
+	{
+		code: "BS230",
+		severity: "warning",
+		title: "Constraint added without not valid",
+		description: "A migration adds a foreign key or check to an existing table without `not valid`, so Postgres checks every row while it holds the lock. Add it with `not valid`, then run `alter table ... validate constraint` in a later statement, which takes a lighter lock.",
+		check: perStatement(constraintWithoutNotValid)
+	},
+	{
+		code: "BS231",
+		severity: "warning",
+		title: "Column type change or set not null",
+		description: "A migration changes a column type or sets `not null` on an existing table. A type change can rewrite the table, and `set not null` scans every row, both under an access exclusive lock. For `not null`, add `check (column is not null) not valid`, validate it, then set not null. For a type, add a new column and backfill it.",
+		check: perStatement(rewriteOrScan)
+	},
+	{
+		code: "BS232",
+		severity: "warning",
+		title: "Column added with a volatile default",
+		description: "A migration adds a column with a volatile default, such as `gen_random_uuid()` or `clock_timestamp()`, to an existing table. Postgres writes the value into every row under an access exclusive lock. Add the column without a default, backfill it in batches, then set the default.",
+		check: perStatement(volatileDefault)
+	},
+	{
+		code: "BS233",
+		severity: "warning",
+		title: "Migration without lock_timeout",
+		description: "A migration takes an access exclusive lock on an existing table without `set lock_timeout`. While it waits behind a long query, every read and write of the table queues behind it. Start the file with `set lock_timeout = '5s';` and retry the migration when it times out.",
+		check: missingLockTimeout
+	},
+	{
+		code: "BS234",
+		severity: "info",
+		title: "Migration drops or renames",
+		description: `A migration drops or renames a table or column. App code deployed before it still uses the old name and fails once it runs. Expand and contract: add the new shape, deploy app code that uses it, then remove the old one in a later migration.`,
+		check: perStatement(dropOrRename)
+	}
+];
+//#endregion
+export { latestMigrationVersion as n, MIGRATION_SAFETY_RULES as t };

package/dist/cli/{module-migration-YFFdWC5X.js → module-migration-CLkZ8jpw.js}

@@ -171,7 +171,7 @@ function moduleKeyProblems(provider, keys) {
 		const problem = unsafeKey(provider, entry.key);
 		if (!problem) return [];
 		const fn = entry.scope === "platform" ? "authorization.functions.isPlatform" : "authorization.functions.idsWith";
-		const setting = `blocks.${entry.module}.permissions.${entry.action}`;
+		const setting = entry.setting ?? `blocks.${entry.module}.permissions.${entry.action}`;
 		const fix = problem.status === "incomplete" ? `The provider's SQL functions check role and scope, not the key's other conditions, so the module would grant it everywhere in the scope. Set ${setting} to a permission marked sqlComplete: true.` : `${problem.fix} If the provider doesn't define it, set ${setting} to a key it lists.`;
 		return [{
 			target: setting,

package/dist/cli/{moved-D9OT_Uyy.js → moved-B7UFO_OM.js}

@@ -1,5 +1,5 @@
 import { n as CliError } from "./errors-Caiz_0so.js";
-import { s as positionalIndex } from "./parse-DE59XyWt.js";
+import { s as positionalIndex } from "./parse-CwV5a6dA.js";
 //#region src/cli/core/moved.ts
 /** Commands renamed in 0.9, longest prefix first. */
 const MOVED_COMMANDS = [

package/dist/cli/{parse-DE59XyWt.js → parse-CwV5a6dA.js}

@@ -1,5 +1,5 @@
 import { r as __toESM } from "./rolldown-runtime-kJ_i4yPo.js";
-import { t as GLOBAL_ARGS } from "./command-CK9Cn8HV.js";
+import { t as GLOBAL_ARGS } from "./command-D_HI1mp1.js";
 import { n as CliError } from "./errors-Caiz_0so.js";
 //#region src/cli/core/parse.ts
 /** Global options that take a value, so a command name is never the token after them. */

package/dist/cli/{preset-DmcC4nWE.js → preset-DQ1DxMtI.js}

@@ -1,4 +1,4 @@
-import { p as commandMeta, r as defineCliCommand } from "./command-CK9Cn8HV.js";
+import { p as commandMeta, r as defineCliCommand } from "./command-D_HI1mp1.js";
 import { n as CliError } from "./errors-Caiz_0so.js";
 import { PRESET_FIELDS, decodePreset, encodePreset, isPresetCode, listNames, presetConfig, presetOf, resolvePreset } from "better-supabase/preset";
 //#region src/cli/commands/preset.ts

package/dist/cli/{run-CM_2g6KQ.js → run-BLJj7SuM.js}

@@ -1,10 +1,10 @@
-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 { 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-D_HI1mp1.js";
 import { n as highlight, r as painter } from "./style-2JfIPVMQ.js";
-import { t as VERSION } from "./version-DNRW4DAP.js";
+import { t as VERSION } from "./version-D1wM9DNb.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 { a as missingInputNext, o as resolveAgent, t as checkConsent } from "./agent-CCrTYK3W.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-CwV5a6dA.js";
+import { n as movedCommand, r as movedFlag } from "./moved-B7UFO_OM.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";
@@ -16,39 +16,40 @@ import { resolve } from "node:path";
 * 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"))]
+	["init", () => import("./init-BwLTO6XG.js").then((m) => m.initCommand)],
+	["add", () => import("./add-ojbcMxyp.js").then((m) => m.addCommand)],
+	["apply", () => import("./apply-DBXC0Z5I.js").then((m) => m.applyCommand)],
+	["adopt", () => import("./adopt-D0ASVx2G.js").then((m) => m.adoptCommand)],
+	["preset decode", () => import("./preset-DQ1DxMtI.js").then((m) => m.presetDecodeCommand)],
+	["preset info", () => import("./preset-DQ1DxMtI.js").then((m) => m.presetInfoCommand)],
+	["blocks list", () => import("./blocks-BXeqIzWN.js").then((m) => m.blocksListCommand)],
+	["blocks view", () => import("./blocks-BXeqIzWN.js").then((m) => m.blocksViewCommand)],
+	["blocks search", () => import("./blocks-BXeqIzWN.js").then((m) => m.blocksSearchCommand)],
+	["skills list", () => import("./skills-CaxIQhzW.js").then((m) => m.skillsListCommand)],
+	["skills install", () => import("./skills-CaxIQhzW.js").then((m) => m.skillsInstallCommand)],
+	["completion", () => import("./completion-En43UcyJ.js").then((m) => m.completionCommand)],
+	["env", () => import("./env-DkBe35Rv.js").then((m) => m.envCommand)],
+	["keys", () => import("./keys-hwtdwdkT.js").then((m) => m.keysCommand)],
+	["gen", () => import("./gen-BhquLu7l.js").then((m) => m.genCommand)],
+	["introspect", () => import("./introspect-B-gXAIqs.js").then((m) => m.introspectCommand)],
+	["spec emit", () => import("./spec-DRDaIq8f.js").then((m) => m.specEmitCommand)],
+	["spec validate", () => import("./spec-DRDaIq8f.js").then((m) => m.specValidateCommand)],
+	["scaffold api", () => import("./scaffold-DUz5fa-k.js").then((m) => m.scaffoldApiCommand)],
+	["scaffold screens", () => import("./scaffold-DUz5fa-k.js").then((m) => m.scaffoldScreensCommand)],
+	["seed", () => import("./seed-ClGWseBT.js").then((m) => m.seedCommand)],
+	["doctor", () => import("./doctor-wACp5w6N.js").then((m) => m.doctorCommand)],
+	["config", () => import("./config-DyJgo2d9.js").then((m) => m.configCommand)],
+	["mcp", () => import("./mcp-Bdm2oGmL.js").then((m) => m.mcpCommand)],
+	["sql list", () => import("./sql-BCQt5TDs.js").then((m) => m.sqlListCommand)],
+	["sql add", () => import("./sql-BCQt5TDs.js").then((m) => m.sqlAddCommand)],
+	["sql sync", () => import("./sql-BCQt5TDs.js").then((m) => m.sqlSyncCommand)],
+	["sql upgrade", () => import("./sql-BCQt5TDs.js").then((m) => m.sqlUpgradeCommand)],
+	["sql data", () => import("./sql-BCQt5TDs.js").then((m) => m.sqlDataCommand)],
+	["sql print", () => import("./sql-BCQt5TDs.js").then((m) => m.sqlPrintCommand)],
+	["codemod 0.4", () => import("./codemod-CrI33UR2.js").then((m) => m.codemodCommand("0.4"))],
+	["codemod 0.5", () => import("./codemod-CrI33UR2.js").then((m) => m.codemodCommand("0.5"))],
+	["codemod 0.6", () => import("./codemod-CrI33UR2.js").then((m) => m.codemodCommand("0.6"))],
+	["codemod 0.9", () => import("./codemod-CrI33UR2.js").then((m) => m.codemodCommand("0.9"))]
 ];
 /** The built-in commands, for `createCli`. */
 function builtinCommands() {
@@ -447,7 +448,7 @@ function cliFromTree(init, extra = {}) {
 		};
 		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(() => "");
+			const lines = await import("./completion-Vry-Wjw8.js").then(async ({ complete, completionLines }) => completionLines(await complete(tree, words))).catch(() => "");
 			if (lines !== "") out(lines);
 			return {
 				code: 0,
@@ -576,8 +577,8 @@ function cliFromTree(init, extra = {}) {
 		try {
 			const [loaded, { defaultConfig, discoverConfig, loadConfig }, { configEnvironment, isCi, parseEnv }] = await Promise.all([
 				node.load(),
-				import("./config-C1d-mbUA.js"),
-				import("./env-DJ4ZaJpe.js")
+				import("./config-DsqQr5z3.js"),
+				import("./env-Ch99nTQw.js")
 			]);
 			command = loaded;
 			rawArgs = joinRepeated(rest, listArgs(command));
@@ -681,4 +682,4 @@ 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 };
+export { envelope as a, run as i, createCli as n, help as r, commandNames as t };