better-supabase 0.7.1 → 0.9.0

package/dist/cli/add-B0zoJUYX.js

@@ -0,0 +1,651 @@
+import { a as list, p as commandMeta, r as defineCliCommand } from "./command-CK9Cn8HV.js";
+import { t as VERSION } from "./version-DNRW4DAP.js";
+import { a as parseNames, n as CliError } from "./errors-Caiz_0so.js";
+import { r as readIfExists, t as display } from "./io-BiPX-_J1.js";
+import { n as INTEGRATIONS } from "./names-D6LrQnOv.js";
+import { n as applyPlan, r as changeLines, s as planResult, t as PLAN_ARGS } from "./files-DDvAwTko.js";
+import { n as installCommand, t as detectProject } from "./detect-DYDUBLU4.js";
+import { r as addBlocksToWiring } from "./config-edit-Ct1lXe8a.js";
+import { t as addModules } from "./add-Bd5M6uEZ.js";
+import { t as blockNames } from "./blocks-Dq25D80b.js";
+import { existsSync } from "node:fs";
+import { dirname, join, posix, resolve } from "node:path";
+import { DEFAULT_CONVENTIONS, PRESET_CATALOG, PRESET_FRAMEWORKS, PROVIDER_COMMENT, glueCommand, resolvePreset } from "better-supabase/preset";
+import { INTEGRATION_INFO } from "better-supabase/config";
+//#region src/cli/templates.ts
+const join$1 = (...parts) => posix.normalize(posix.join(...parts));
+const libDir = (context) => join$1(context.srcDir, "lib");
+/** `lib/supabase/`: the shared definition, `server.ts` and `client.ts`. */
+const supabaseDir = (context) => join$1(libDir(context), "supabase");
+/** `lib/supabase/index.ts`, imported as `lib/supabase` on both sides. */
+const libEntry = (context) => join$1(supabaseDir(context), "index.ts");
+/** Import path of `lib/supabase/index.ts`: the folder, unless the project keeps `.ts` extensions. */
+function importLib(context, from) {
+	const path = importFrom(context, from, libEntry(context));
+	return context.tsExtensions ? path : path.replace(/^(\.\.?\/.+)\/index$/, "$1");
+}
+/** Relative import from one project file to another, following the project's extension style. */
+function importFrom(context, from, to, keepTs = context.tsExtensions) {
+	let path = posix.relative(posix.dirname(from), to);
+	if (!path.startsWith(".")) path = `./${path}`;
+	return keepTs ? path : path.replace(/\.tsx?$/, "");
+}
+function publicEnv(context) {
+	const read = (prefix, access) => access === "vite" ? {
+		url: `import.meta.env.${prefix}SUPABASE_URL`,
+		key: `import.meta.env.${prefix}SUPABASE_PUBLISHABLE_KEY`
+	} : {
+		url: `process.env.${prefix}SUPABASE_URL!`,
+		key: `process.env.${prefix}SUPABASE_PUBLISHABLE_KEY!`
+	};
+	if (context.frameworks.includes("next")) return read("NEXT_PUBLIC_", "process");
+	if (context.frameworks.includes("expo")) return read("EXPO_PUBLIC_", "process");
+	if (context.frameworks.includes("vite")) return read("VITE_", "vite");
+	return read("", "process");
+}
+const denoJson = (context) => `${JSON.stringify({ imports: {
+	"better-supabase": `npm:better-supabase@^${context.version}`,
+	"better-supabase/": `npm:/better-supabase@^${context.version}/`,
+	"@supabase/supabase-js": "npm:@supabase/supabase-js@^2",
+	zod: "npm:zod@^4"
+} }, null, 2)}\n`;
+const SHARED = "supabase/functions/_shared/supabase.ts";
+function shared(context) {
+	return {
+		path: SHARED,
+		contents: `import { defineSupabase } from 'better-supabase';
+
+import { schema } from '${importFrom(context, SHARED, context.generated, true)}';
+
+export const betterSupabase = defineSupabase(schema);
+`
+	};
+}
+/** `supabase/functions/<name>/server.ts`: the function's `bs`. */
+function functionServer(name, contents) {
+	return {
+		path: `supabase/functions/${name}/server.ts`,
+		contents: contents("../_shared/supabase.ts")
+	};
+}
+/** Edge Functions import `_shared/supabase.ts`, so they don't need the app definition. */
+const needsLib = (names) => names.length === 0 || names.some((name) => name !== "edge" && name !== "mcp");
+const quote = (text) => `'${text.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+/** A JSON value as a one-line TypeScript literal with single quotes. */
+function literal(value) {
+	if (Array.isArray(value)) return `[${value.map(literal).join(", ")}]`;
+	if (typeof value === "object" && value !== null) {
+		const entries = Object.entries(value).map(([name, each]) => `${/^[a-z_$][a-z0-9_$]*$/i.test(name) ? name : quote(name)}: ${literal(each)}`);
+		return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`;
+	}
+	return typeof value === "string" ? quote(value) : JSON.stringify(value);
+}
+/** The files `init` writes: the config and, unless `lib` is false, the isomorphic definition. */
+function baseFiles(context, casing, lib = true, integrations = [], workflow = "pg-delta", preset, keys = {}) {
+	const sql = {
+		...workflow === "pg-delta" ? {} : { workflow },
+		...keys.sql
+	};
+	const config = {
+		path: "better-supabase.config.ts",
+		contents: `import { defineConfig } from 'better-supabase/config';
+
+export default defineConfig({${preset === void 0 ? "" : `\n  // Expands into blocks and conventions; \`better-supabase preset info\` shows what it holds.\n  preset: '${preset}',`}
+  casing: '${casing}',
+  output: '${context.generated}',${integrations.length > 0 ? `\n  integrations: [${integrations.map((name) => `'${name}'`).join(", ")}],` : ""}${Object.keys(sql).length === 0 ? "" : `\n  sql: ${literal(sql)},`}${keys.provider === true ? `\n${PROVIDER_COMMENT.join("\n")}` : ""}${keys.blocks === void 0 ? "" : `\n  blocks: ${literal(keys.blocks)},`}
+  // \`better-supabase gen\` runs every task this file sets up: types, then
+  // sql, spec, seed and scaffold when they are configured. Pin the list with:
+  // gen: { tasks: ['types', 'sql', 'spec'] },
+  // env: { output: '.env.local' },
+  // doctor: { format: 'sarif', output: 'doctor.sarif' },
+});
+`
+	};
+	if (!lib) return [config];
+	const path = libEntry(context);
+	const generated = importFrom(context, path, context.generated);
+	const expo = context.frameworks.includes("expo");
+	return [config, {
+		path,
+		contents: `import { defineSupabase } from 'better-supabase';
+${expo ? "import { Temporal } from 'temporal-polyfill';\n" : ""}
+import { schema } from '${generated}';
+
+export type { Functions, Models } from '${generated}';
+
+export const betterSupabase = defineSupabase(schema${expo ? ", { temporal: Temporal }" : ""});
+`
+	}];
+}
+const TEMPLATES = {
+	client: {
+		packages: ["@supabase/ssr"],
+		files: (context) => {
+			const path = join$1(supabaseDir(context), "client.ts");
+			const env = publicEnv(context);
+			return [{
+				path,
+				contents: `import { createClient } from 'better-supabase/client';
+
+import { betterSupabase } from '${importLib(context, path)}';
+
+export const bs = createClient(betterSupabase, {
+  env: {
+    url: ${env.url},
+    publishableKey: ${env.key},
+  },
+});
+`
+			}];
+		}
+	},
+	next: {
+		packages: [
+			"@supabase/ssr",
+			"@supabase/server",
+			"server-only"
+		],
+		files: (context) => {
+			const server = join$1(supabaseDir(context), "server.ts");
+			const proxy = join$1(context.srcDir, "proxy.ts");
+			return [{
+				path: server,
+				contents: `import 'server-only';
+
+import { createNext } from 'better-supabase/next';
+
+import { betterSupabase } from '${importLib(context, server)}';
+
+export const bs = createNext(betterSupabase);
+`
+			}, {
+				path: proxy,
+				contents: `import type { NextRequest } from 'next/server';
+
+import { bs } from '${importFrom(context, proxy, server)}';
+
+export const proxy = (request: NextRequest) => bs.proxy(request);
+
+export const config = {
+  matcher: ['/((?!_next/static|_next/image|favicon.ico|.*\\\\.(?:svg|png|jpg|webp)$).*)'],
+};
+`
+			}];
+		},
+		next: ["Read the session in Server Components with `const { db } = await bs.context()`."]
+	},
+	react: {
+		packages: ["@tanstack/react-query"],
+		files: (context) => {
+			const client = join$1(supabaseDir(context), "client.ts");
+			const providers = context.frameworks.includes("next") ? join$1(context.srcDir, "app", "providers.tsx") : join$1(context.srcDir, "providers.tsx");
+			const hooks = join$1(libDir(context), "hooks.ts");
+			return [{
+				path: providers,
+				contents: `${context.frameworks.includes("next") ? "'use client';\n\n" : ""}import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { BetterSupabaseProvider } from 'better-supabase/react';
+import { type ReactNode, useState } from 'react';
+
+import { bs } from '${importFrom(context, providers, client)}';
+
+export function Providers({ children }: { children: ReactNode }) {
+  const [queryClient] = useState(() => new QueryClient());
+  return (
+    <QueryClientProvider client={queryClient}>
+      <BetterSupabaseProvider client={bs} queryClient={queryClient}>
+        {children}
+      </BetterSupabaseProvider>
+    </QueryClientProvider>
+  );
+}
+`
+			}, {
+				path: hooks,
+				contents: `import { createHooks } from 'better-supabase/react';
+
+import type { bs } from '${importFrom(context, hooks, client)}';
+
+export const { useDb, useQueries, useAuth, useSupabase } = createHooks<typeof bs>();
+`
+			}];
+		},
+		next: ["Wrap your app in <Providers>."]
+	},
+	hono: {
+		packages: ["hono", "@supabase/server"],
+		files: (context) => {
+			const path = join$1(context.srcDir, "server.ts");
+			return [{
+				path,
+				contents: `import { Hono } from 'hono';
+import { type HonoEnv, createHono } from 'better-supabase/hono';
+
+import { betterSupabase, type Functions, type Models } from '${importLib(context, path)}';
+
+export const bs = createHono(betterSupabase);
+
+const app = new Hono<HonoEnv<Models, Functions, unknown>>()
+  .onError(bs.onError)
+  .use('/api/*', bs.middleware())
+  .get('/api/me', (c) => c.json({ kind: c.var.auth.kind }));
+
+export default app;
+`
+			}];
+		}
+	},
+	orpc: {
+		packages: ["@orpc/server", "@supabase/server"],
+		files: (context) => {
+			const path = join$1(context.srcDir, "router.ts");
+			return [{
+				path,
+				contents: `import { os } from '@orpc/server';
+import { createOrpc, type OrpcRequestContext } from 'better-supabase/orpc';
+
+import { betterSupabase } from '${importLib(context, path)}';
+
+export const bs = createOrpc(betterSupabase);
+
+const base = os.$context<OrpcRequestContext>();
+const authed = base.use(bs.middleware());
+
+export const router = {
+  me: authed.handler(({ context }) => ({ kind: context.auth.kind })),
+};
+`
+			}];
+		}
+	},
+	edge: {
+		packages: [],
+		files: (context) => [
+			shared(context),
+			functionServer("api", (shared) => `import { createEdge } from 'better-supabase/edge';
+
+import { betterSupabase } from '${shared}';
+
+export const bs = createEdge(betterSupabase, { cors: true });
+`),
+			{
+				path: "supabase/functions/api/index.ts",
+				contents: `import { bs } from './server.ts';
+
+Deno.serve(bs.handler((_request, { auth }) => ({ kind: auth.kind })));
+`
+			},
+			{
+				path: "supabase/functions/api/deno.json",
+				contents: denoJson(context)
+			}
+		],
+		next: ["Serve it locally with `supabase functions serve api`."]
+	},
+	expo: {
+		packages: [
+			"expo-server",
+			"expo-secure-store",
+			"@supabase/supabase-js",
+			"temporal-polyfill"
+		],
+		files: (context) => {
+			const server = join$1(supabaseDir(context), "expo.ts");
+			const native = join$1(supabaseDir(context), "client.native.ts");
+			const middleware = join$1(context.srcDir, "app", "+middleware.ts");
+			const env = publicEnv(context);
+			return [
+				{
+					path: server,
+					contents: `import { createExpo } from 'better-supabase/expo';
+
+import { betterSupabase } from '${importLib(context, server)}';
+
+export const bs = createExpo(betterSupabase);
+`
+				},
+				{
+					path: native,
+					contents: `import { createClient as createSupabaseClient } from '@supabase/supabase-js';
+import { autoRefreshOnForeground, createNativeClient, secureStorage } from 'better-supabase/client/native';
+import * as SecureStore from 'expo-secure-store';
+import { AppState } from 'react-native';
+
+import { betterSupabase } from '${importLib(context, native)}';
+
+const supabase = createSupabaseClient(${env.url}, ${env.key}, {
+  auth: {
+    storage: secureStorage(SecureStore),
+    autoRefreshToken: true,
+    persistSession: true,
+    detectSessionInUrl: false,
+  },
+});
+
+autoRefreshOnForeground(supabase, AppState);
+
+export const bs = createNativeClient(betterSupabase, supabase);
+`
+				},
+				{
+					path: middleware,
+					contents: `import { bs } from '${importFrom(context, middleware, server)}';
+
+export default bs.middleware();
+`
+				}
+			];
+		},
+		next: ["Load data as the caller with `export const loader = bs.loader((ctx) => ctx.db.customers.findMany())`.", "Metro picks `client.native.ts` on iOS and Android and `client.ts` (cookie sessions) on the web."]
+	},
+	mcp: {
+		packages: [],
+		files: (context) => [
+			shared(context),
+			functionServer("mcp", (shared) => `import { createMcp } from 'better-supabase/mcp';
+
+import { betterSupabase } from '${shared}';
+
+export const bs = createMcp(betterSupabase, {
+  name: 'app',
+  version: '0.1.0',
+  resources: {},
+});
+`),
+			{
+				path: "supabase/functions/mcp/index.ts",
+				contents: `import { bs } from './server.ts';
+
+Deno.serve(bs.fetch);
+`
+			},
+			{
+				path: "supabase/functions/mcp/deno.json",
+				contents: denoJson(context)
+			}
+		],
+		next: ["List tables under `resources` to expose them as tools, e.g. `customers: true`.", "Add `[functions.mcp] verify_jwt = false` and `[auth.oauth_server] enabled = true` to `supabase/config.toml`, so MCP clients get the sign-in challenge."]
+	}
+};
+/** The integration and what it requires, dependencies first, without duplicates. */
+function resolveIntegrations(names) {
+	const ordered = [];
+	const visit = (name) => {
+		if (ordered.includes(name)) return;
+		for (const dependency of INTEGRATION_INFO[name].requires) visit(dependency);
+		ordered.push(name);
+	};
+	for (const name of names) visit(name);
+	return ordered;
+}
+function isIntegration(name) {
+	return INTEGRATIONS.includes(name);
+}
+/** Integrations `init` adds for the frameworks it finds. */
+function suggestedIntegrations(frameworks) {
+	const names = [];
+	for (const framework of frameworks) switch (framework) {
+		case "next":
+			names.push("next");
+			break;
+		case "hono":
+			names.push("hono");
+			break;
+		case "orpc":
+			names.push("orpc");
+			break;
+		case "vite":
+			names.push("client");
+			break;
+		case "expo":
+			names.push("expo");
+			break;
+		case "tanstack-query":
+			names.push("react");
+			break;
+		default: throw new TypeError(`Unknown framework ${String(framework)}`);
+	}
+	return resolveIntegrations(names);
+}
+//#endregion
+//#region src/cli/glue.ts
+const CANCELLED = {
+	code: 1,
+	error: "Cancelled."
+};
+/** `--force`, or the person's answer when files exist; `undefined` when they cancel. */
+async function overwrite(root, files, args, prompts, base = root) {
+	if (args.force === true) return true;
+	const existing = [...new Set(files.map((file) => file.path).filter((path) => existsSync(resolve(root, path))))];
+	if (!prompts || existing.length === 0) return false;
+	return prompts.confirm(`${existing.map((path) => display(base, resolve(root, path))).join(", ")} ${existing.length === 1 ? "exists" : "exist"}. Overwrite?`);
+}
+/** Template files as a plan: each is written once, and an existing file is the app's. */
+function templatePlan(root, files, regenerate, base = root) {
+	return {
+		root,
+		base,
+		regenerate,
+		files: files.map((file) => ({
+			path: file.path,
+			contents: file.contents,
+			policy: "create"
+		}))
+	};
+}
+function templateContextFor(project, generated) {
+	return {
+		srcDir: project.srcDir,
+		generated,
+		tsExtensions: project.tsExtensions,
+		frameworks: project.frameworks,
+		version: VERSION
+	};
+}
+function integrationFiles(names, templateContext) {
+	return names.flatMap((name) => TEMPLATES[name].files(templateContext));
+}
+function packagesFor(project, names) {
+	const wanted = [
+		"better-supabase",
+		"@supabase/supabase-js",
+		...names.flatMap((name) => TEMPLATES[name].packages)
+	];
+	return [...new Set(wanted)].filter((name) => !(name in project.dependencies));
+}
+function chooseIntegrations(prompts, initial) {
+	return prompts.multiselect("Integrations", INTEGRATIONS.map((name) => ({
+		value: name,
+		label: INTEGRATION_INFO[name].title,
+		hint: INTEGRATION_INFO[name].description
+	})), initial);
+}
+function parseIntegrations(values) {
+	return parseNames(values, isIntegration, "integration", INTEGRATIONS);
+}
+//#endregion
+//#region src/cli/commands/add.ts
+const ADD_ARGS = {
+	block: {
+		type: "positional",
+		required: false,
+		variadic: true,
+		description: "Blocks to install with what they require (`better-supabase blocks list`). Without blocks or --integration, sets up the integrations in the config that have no files yet"
+	},
+	integration: {
+		type: "string",
+		description: "Adds glue for integrations instead: next, hono, orpc, edge, expo, mcp, client or react",
+		valueHint: "integration,..."
+	},
+	force: {
+		type: "boolean",
+		description: "Overwrite files that exist"
+	},
+	"allow-hook-overlap": {
+		type: "boolean",
+		description: "With blocks: write modules whose claim the authorization provider's hook already writes"
+	},
+	"tests-dir": {
+		type: "string",
+		description: "With blocks: where the pgtap module goes. Defaults to sql.testsDir",
+		valueHint: "dir"
+	}
+};
+/**
+* Adds blocks: lists them in `blocks`, writes their modules and what they
+* require (`sql add`), wires the ones with a client into `lib/blocks.ts`,
+* and names the registry glue for the project's frameworks.
+*/
+async function addBlocks(config, args, names, deps) {
+	const added = await addModules(config, {
+		...args,
+		_: ["add", ...names]
+	}, names, deps);
+	if (added.code !== 0) return added;
+	const lines = [added.output ?? ""];
+	const project = await detectProject(config.root);
+	const context = templateContextFor(project, config.output);
+	const resolved = resolvePreset({
+		...DEFAULT_CONVENTIONS,
+		blocks: [...config.blockNames, ...names]
+	});
+	const wanted = new Set(resolvePreset({
+		...DEFAULT_CONVENTIONS,
+		blocks: names
+	}).manifests.map((manifest) => manifest.name));
+	const clients = resolved.manifests.flatMap((manifest) => manifest.client === null || !wanted.has(manifest.name) ? [] : [{
+		key: manifest.name.replaceAll(/-([a-z0-9])/g, (_, letter) => letter.toUpperCase()),
+		export: manifest.client.export,
+		subpath: manifest.client.subpath
+	}]);
+	if (clients.length > 0) {
+		const wiring = blocksWiringPath(context);
+		const path = resolve(config.root, wiring);
+		const current = await readIfExists(path);
+		const edit = current === void 0 ? void 0 : addBlocksToWiring(current, clients);
+		if (edit?.ok === true && edit.text !== current) {
+			await applyPlan({
+				root: config.root,
+				regenerate: "better-supabase add",
+				files: [{
+					path,
+					contents: edit.text,
+					policy: "edit"
+				}]
+			}, { "dry-run": args["dry-run"] });
+			lines.push("", `${args["dry-run"] === true ? "Would wire" : "Wired"} ${clients.map((client) => client.key).join(", ")} in ${wiring}.`);
+		} else if (edit?.ok !== true) lines.push("", `Wire the clients in ${wiring}${edit === void 0 ? " (it doesn't exist yet)" : ` (${edit.reason})`}:`, ...clients.map((client) => `  import { ${client.export} } from "${client.subpath}";  // ${client.key}: ${client.export}`));
+	}
+	const frameworks = PRESET_FRAMEWORKS.filter((framework) => config.integrations.some((name) => name === framework) || project.frameworks.some((name) => name === framework));
+	const installed = new Set(resolved.blocks.map((block) => block.name));
+	const glue = PRESET_CATALOG.glue.filter((item) => item.preset === void 0 && item.blocks.some((block) => names.includes(block)) && item.blocks.every((block) => installed.has(block)) && item.frameworks.some((framework) => frameworks.some((each) => each === framework)));
+	const glueLine = glue.length > 0 ? glueCommand(glue) : void 0;
+	if (glueLine !== void 0) lines.push("", `Glue for ${frameworks.join(", ")}: ${glueLine}`);
+	return {
+		code: 0,
+		output: lines.join("\n"),
+		data: {
+			blocks: names,
+			modules: added.data,
+			clients: clients.map((client) => client.key),
+			...glueLine === void 0 ? {} : { glue: glueLine }
+		}
+	};
+}
+/** `lib/blocks.ts` next to `lib/supabase/`. */
+function blocksWiringPath(context) {
+	return join(dirname(dirname(libEntry(context))), "blocks.ts");
+}
+/** How `lib/blocks.ts` imports the `blocks.generated.ts` that `gen` writes next to `generated.ts`. */
+function blockConfigImport(context) {
+	return importFrom(context, blocksWiringPath(context), join(dirname(context.generated), "blocks.generated.ts"));
+}
+const SYSTEM_DEPS = { now: () => /* @__PURE__ */ new Date() };
+async function runAdd(config, args, prompts, deps = SYSTEM_DEPS) {
+	if (args._.length > 0 && args.integration === void 0) return addBlocks(config, args, args._, deps);
+	if (args.integration !== void 0) return addIntegrations(config, {
+		...args,
+		_: list(args.integration)
+	}, prompts);
+	return addIntegrations(config, args, prompts);
+}
+async function addIntegrations(config, args, prompts) {
+	const project = await detectProject(config.root);
+	const templateContext = templateContextFor(project, config.output);
+	const fromConfig = args._.length === 0 && config.integrations.length > 0;
+	const missing = config.integrations.filter((name) => integrationFiles([name], templateContext).some((file) => !existsSync(resolve(config.root, file.path))));
+	if (fromConfig && missing.length === 0) return {
+		code: 0,
+		output: `Every integration in the config is set up: ${config.integrations.join(", ")}.`,
+		data: {
+			integrations: [],
+			files: [],
+			packages: [],
+			unlisted: []
+		}
+	};
+	const named = fromConfig ? missing : args._.length === 0 && prompts ? await chooseIntegrations(prompts, []) : args._;
+	if (named === void 0) return CANCELLED;
+	if (named.length === 0) throw new CliError("usage", `Name at least one integration (${INTEGRATIONS.join(", ")}), or list them in integrations in the config.`);
+	const requested = parseIntegrations(named);
+	if (typeof requested === "string") throw new CliError("usage", requested);
+	const integrations = resolveIntegrations(requested);
+	const files = integrationFiles(integrations, templateContext);
+	const force = await overwrite(config.root, files, args, prompts);
+	if (force === void 0) return CANCELLED;
+	const plan = templatePlan(config.root, files, "better-supabase add");
+	const applied = await applyPlan(plan, {
+		...args,
+		force
+	});
+	if (applied.mode === "check" && applied.drift) return planResult(plan, applied);
+	const lines = changeLines(applied);
+	const lib = libEntry(templateContext);
+	const libMissing = !existsSync(resolve(config.root, lib)) && integrations.some((name) => needsLib([name]));
+	const next = [];
+	if (libMissing) {
+		next.push({
+			command: "better-supabase init",
+			when: `${lib} is missing`
+		});
+		lines.push("", `Warning: ${lib} is missing. Run \`better-supabase init\` first.`);
+	}
+	const packages = packagesFor(project, integrations).filter((name) => name !== "better-supabase" && name !== "@supabase/supabase-js");
+	const install = packages.length > 0 ? installCommand(project.packageManager, packages) : void 0;
+	if (install !== void 0) {
+		lines.push("", `Install: ${install}`);
+		next.push({
+			command: install,
+			when: "to install the packages they need"
+		});
+	}
+	for (const name of integrations) for (const hint of TEMPLATES[name].next ?? []) lines.push(`- ${hint}`);
+	const unlisted = integrations.filter((name) => !config.integrations.includes(name));
+	if (unlisted.length > 0) lines.push("", "Add them to your config so `better-supabase add` sets them up in a fresh checkout:", `  integrations: [${[...config.integrations, ...unlisted].map((name) => `'${name}'`).join(", ")}]`);
+	return {
+		code: 0,
+		output: lines.join("\n"),
+		data: {
+			integrations,
+			files: applied.changes,
+			packages,
+			unlisted
+		},
+		next
+	};
+}
+const addCommand = defineCliCommand({
+	meta: commandMeta("add"),
+	args: {
+		...ADD_ARGS,
+		"dry-run": PLAN_ARGS["dry-run"],
+		check: PLAN_ARGS.check
+	},
+	lists: ["integration"],
+	completions: { block: blockNames },
+	run: (args, { config, configFile, io }) => runAdd(config, args, io.prompts, {
+		...SYSTEM_DEPS,
+		...configFile === void 0 ? {} : { configFile }
+	})
+});
+//#endregion
+export { suggestedIntegrations as _, CANCELLED as a, overwrite as c, templateContextFor as d, templatePlan as f, resolveIntegrations as g, needsLib as h, runAdd as i, packagesFor as l, baseFiles as m, blockConfigImport as n, chooseIntegrations as o, TEMPLATES as p, blocksWiringPath as r, integrationFiles as s, addCommand as t, parseIntegrations as u };