create-better-t-stack 3.19.3 → 3.19.5-pr874.92079f0

package/dist/{src-7x63_Zwm.mjs → src-C4Fa8qXv.mjs}

@@ -1,25 +1,25 @@
 #!/usr/bin/env node
-import { t as __reExport } from "./chunk-DPg_XC7m.mjs";
-import { autocompleteMultiselect, cancel, confirm, group, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
+import { t as __reExport } from "./chunk-CHc3S52W.mjs";
 import { createRouterClient, os } from "@orpc/server";
 import { Result, Result as Result$1, TaggedError } from "better-result";
-import pc from "picocolors";
 import { createCli } from "trpc-cli";
 import z from "zod";
-import { EMBEDDED_TEMPLATES, EMBEDDED_TEMPLATES as EMBEDDED_TEMPLATES$1, GeneratorError, GeneratorError as GeneratorError$1, TEMPLATE_COUNT, VirtualFileSystem, VirtualFileSystem as VirtualFileSystem$1, dependencyVersionMap, generate, generate as generate$1, generateReproducibleCommand, processAddonTemplates, processAddonsDeps } from "@better-t-stack/template-generator";
-import { writeTree } from "@better-t-stack/template-generator/fs-writer";
+import { autocompleteMultiselect, cancel, confirm, group, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
+import pc from "picocolors";
+import envPaths from "env-paths";
 import fs from "fs-extra";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { EMBEDDED_TEMPLATES, EMBEDDED_TEMPLATES as EMBEDDED_TEMPLATES$1, GeneratorError, GeneratorError as GeneratorError$1, TEMPLATE_COUNT, VirtualFileSystem, VirtualFileSystem as VirtualFileSystem$1, dependencyVersionMap, generate, generate as generate$1, generateReproducibleCommand, processAddonTemplates, processAddonsDeps } from "@better-t-stack/template-generator";
 import consola, { consola as consola$1 } from "consola";
+import gradient from "gradient-string";
+import { $, execa } from "execa";
+import { writeTree } from "@better-t-stack/template-generator/fs-writer";
 import { ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, SelectPrompt, isCancel as isCancel$1 } from "@clack/core";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { applyEdits, modify, parse } from "jsonc-parser";
-import gradient from "gradient-string";
-import { $, execa } from "execa";
-import envPaths from "env-paths";
-import { format } from "oxfmt";
 import os$1 from "node:os";
+import { format } from "oxfmt";
 
 //#region src/utils/get-package-manager.ts
 const getUserPkgManager = () => {
@@ -86,6 +86,7 @@ const ADDON_COMPATIBILITY = {
 	starlight: [],
 	ultracite: [],
 	ruler: [],
+	mcp: [],
 	oxlint: [],
 	fumadocs: [],
 	opentui: [],
@@ -94,25 +95,6 @@ const ADDON_COMPATIBILITY = {
 	none: []
 };
 
-//#endregion
-//#region src/types.ts
-var types_exports = {};
-import * as import__better_t_stack_types from "@better-t-stack/types";
-__reExport(types_exports, import__better_t_stack_types);
-
-//#endregion
-//#region src/utils/compatibility.ts
-const WEB_FRAMEWORKS = [
-	"tanstack-router",
-	"react-router",
-	"tanstack-start",
-	"next",
-	"nuxt",
-	"svelte",
-	"solid",
-	"astro"
-];
-
 //#endregion
 //#region src/utils/errors.ts
 /**
@@ -202,6 +184,344 @@ function displayError(error) {
 	else consola.error(pc.red(error.message));
 }
 
+//#endregion
+//#region src/utils/get-latest-cli-version.ts
+function getLatestCLIVersionResult() {
+	const packageJsonPath = path.join(PKG_ROOT, "package.json");
+	return Result.try({
+		try: () => {
+			return fs.readJSONSync(packageJsonPath).version;
+		},
+		catch: (e) => new CLIError({
+			message: `Failed to read CLI version from package.json: ${e instanceof Error ? e.message : String(e)}`,
+			cause: e
+		})
+	});
+}
+function getLatestCLIVersion() {
+	return getLatestCLIVersionResult().unwrapOr("1.0.0");
+}
+
+//#endregion
+//#region src/utils/project-history.ts
+const paths = envPaths("better-t-stack", { suffix: "" });
+const HISTORY_FILE = "history.json";
+var HistoryError = class extends TaggedError("HistoryError")() {};
+function getHistoryDir() {
+	return paths.data;
+}
+function getHistoryPath() {
+	return path.join(paths.data, HISTORY_FILE);
+}
+function generateId() {
+	return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+function emptyHistory() {
+	return {
+		version: 1,
+		entries: []
+	};
+}
+async function ensureHistoryDir() {
+	return Result.tryPromise({
+		try: async () => {
+			await fs.ensureDir(getHistoryDir());
+		},
+		catch: (e) => new HistoryError({
+			message: `Failed to create history directory: ${e instanceof Error ? e.message : String(e)}`,
+			cause: e
+		})
+	});
+}
+async function readHistory() {
+	const historyPath = getHistoryPath();
+	const existsResult = await Result.tryPromise({
+		try: async () => await fs.pathExists(historyPath),
+		catch: (e) => new HistoryError({
+			message: `Failed to check history file: ${e instanceof Error ? e.message : String(e)}`,
+			cause: e
+		})
+	});
+	if (existsResult.isErr()) return existsResult;
+	if (!existsResult.value) return Result.ok(emptyHistory());
+	const readResult = await Result.tryPromise({
+		try: async () => await fs.readJson(historyPath),
+		catch: (e) => new HistoryError({
+			message: `Failed to read history file: ${e instanceof Error ? e.message : String(e)}`,
+			cause: e
+		})
+	});
+	if (readResult.isErr()) return Result.ok(emptyHistory());
+	return Result.ok(readResult.value);
+}
+async function writeHistory(history) {
+	const ensureDirResult = await ensureHistoryDir();
+	if (ensureDirResult.isErr()) return ensureDirResult;
+	return Result.tryPromise({
+		try: async () => {
+			await fs.writeJson(getHistoryPath(), history, { spaces: 2 });
+		},
+		catch: (e) => new HistoryError({
+			message: `Failed to write history file: ${e instanceof Error ? e.message : String(e)}`,
+			cause: e
+		})
+	});
+}
+async function addToHistory(config, reproducibleCommand) {
+	const historyResult = await readHistory();
+	if (historyResult.isErr()) return historyResult;
+	const history = historyResult.value;
+	const entry = {
+		id: generateId(),
+		projectName: config.projectName,
+		projectDir: config.projectDir,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		stack: {
+			frontend: config.frontend,
+			backend: config.backend,
+			database: config.database,
+			orm: config.orm,
+			runtime: config.runtime,
+			auth: config.auth,
+			payments: config.payments,
+			api: config.api,
+			addons: config.addons,
+			examples: config.examples,
+			dbSetup: config.dbSetup,
+			packageManager: config.packageManager
+		},
+		cliVersion: getLatestCLIVersion(),
+		reproducibleCommand
+	};
+	history.entries.unshift(entry);
+	if (history.entries.length > 100) history.entries = history.entries.slice(0, 100);
+	return await writeHistory(history);
+}
+async function getHistory(limit = 10) {
+	const historyResult = await readHistory();
+	if (historyResult.isErr()) return historyResult;
+	return Result.ok(historyResult.value.entries.slice(0, limit));
+}
+async function clearHistory() {
+	const historyPath = getHistoryPath();
+	return Result.tryPromise({
+		try: async () => {
+			if (await fs.pathExists(historyPath)) await fs.remove(historyPath);
+		},
+		catch: (e) => new HistoryError({
+			message: `Failed to clear history: ${e instanceof Error ? e.message : String(e)}`,
+			cause: e
+		})
+	});
+}
+
+//#endregion
+//#region src/utils/render-title.ts
+const TITLE_TEXT = `
+ ██████╗ ███████╗████████╗████████╗███████╗██████╗
+ ██╔══██╗██╔════╝╚══██╔══╝╚══██╔══╝██╔════╝██╔══██╗
+ ██████╔╝█████╗     ██║      ██║   █████╗  ██████╔╝
+ ██╔══██╗██╔══╝     ██║      ██║   ██╔══╝  ██╔══██╗
+ ██████╔╝███████╗   ██║      ██║   ███████╗██║  ██║
+ ╚═════╝ ╚══════╝   ╚═╝      ╚═╝   ╚══════╝╚═╝  ╚═╝
+
+ ████████╗    ███████╗████████╗ █████╗  ██████╗██╗  ██╗
+ ╚══██╔══╝    ██╔════╝╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝
+    ██║       ███████╗   ██║   ███████║██║     █████╔╝
+    ██║       ╚════██║   ██║   ██╔══██║██║     ██╔═██╗
+    ██║       ███████║   ██║   ██║  ██║╚██████╗██║  ██╗
+    ╚═╝       ╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝
+ `;
+const catppuccinTheme = {
+	pink: "#F5C2E7",
+	mauve: "#CBA6F7",
+	red: "#F38BA8",
+	maroon: "#E78284",
+	peach: "#FAB387",
+	yellow: "#F9E2AF",
+	green: "#A6E3A1",
+	teal: "#94E2D5",
+	sky: "#89DCEB",
+	sapphire: "#74C7EC",
+	lavender: "#B4BEFE"
+};
+const renderTitle = () => {
+	const terminalWidth = process.stdout.columns || 80;
+	const titleLines = TITLE_TEXT.split("\n");
+	if (terminalWidth < Math.max(...titleLines.map((line) => line.length))) console.log(gradient(Object.values(catppuccinTheme)).multiline(`Better T Stack`));
+	else console.log(gradient(Object.values(catppuccinTheme)).multiline(TITLE_TEXT));
+};
+
+//#endregion
+//#region src/commands/history.ts
+function formatStackSummary(entry) {
+	const parts = [];
+	if (entry.stack.frontend.length > 0 && !entry.stack.frontend.includes("none")) parts.push(entry.stack.frontend.join(", "));
+	if (entry.stack.backend && entry.stack.backend !== "none") parts.push(entry.stack.backend);
+	if (entry.stack.database && entry.stack.database !== "none") parts.push(entry.stack.database);
+	if (entry.stack.orm && entry.stack.orm !== "none") parts.push(entry.stack.orm);
+	return parts.length > 0 ? parts.join(" + ") : "minimal";
+}
+function formatDate(isoString) {
+	return new Date(isoString).toLocaleDateString("en-US", {
+		year: "numeric",
+		month: "short",
+		day: "numeric",
+		hour: "2-digit",
+		minute: "2-digit"
+	});
+}
+async function historyHandler(input) {
+	if (input.clear) {
+		const clearResult = await clearHistory();
+		if (clearResult.isErr()) {
+			log.warn(pc.yellow(clearResult.error.message));
+			return;
+		}
+		log.success(pc.green("Project history cleared."));
+		return;
+	}
+	const historyResult = await getHistory(input.limit);
+	if (historyResult.isErr()) {
+		log.warn(pc.yellow(historyResult.error.message));
+		return;
+	}
+	const entries = historyResult.value;
+	if (entries.length === 0) {
+		log.info(pc.dim("No projects in history yet."));
+		log.info(pc.dim("Create a project with: create-better-t-stack my-app"));
+		return;
+	}
+	if (input.json) {
+		console.log(JSON.stringify(entries, null, 2));
+		return;
+	}
+	renderTitle();
+	intro(pc.magenta(`Project History (${entries.length} entries)`));
+	for (const [index, entry] of entries.entries()) {
+		const num = pc.dim(`${index + 1}.`);
+		const name = pc.cyan(pc.bold(entry.projectName));
+		const stack = pc.dim(formatStackSummary(entry));
+		log.message(`${num} ${name}`);
+		log.message(`   ${pc.dim("Created:")} ${formatDate(entry.createdAt)}`);
+		log.message(`   ${pc.dim("Path:")} ${entry.projectDir}`);
+		log.message(`   ${pc.dim("Stack:")} ${stack}`);
+		log.message(`   ${pc.dim("Command:")} ${pc.dim(entry.reproducibleCommand)}`);
+		log.message("");
+	}
+}
+
+//#endregion
+//#region src/utils/open-url.ts
+async function openUrl(url) {
+	const platform = process.platform;
+	if (platform === "darwin") {
+		await $({ stdio: "ignore" })`open ${url}`;
+		return;
+	}
+	if (platform === "win32") {
+		const escapedUrl = url.replace(/&/g, "^&");
+		await $({ stdio: "ignore" })`cmd /c start "" ${escapedUrl}`;
+		return;
+	}
+	await $({ stdio: "ignore" })`xdg-open ${url}`;
+}
+
+//#endregion
+//#region src/utils/sponsors.ts
+const SPONSORS_JSON_URL = "https://sponsors.better-t-stack.dev/sponsors.json";
+async function fetchSponsors(url = SPONSORS_JSON_URL) {
+	const s = spinner();
+	s.start("Fetching sponsors…");
+	const response = await fetch(url);
+	if (!response.ok) {
+		s.stop(pc.red(`Failed to fetch sponsors: ${response.statusText}`));
+		throw new Error(`Failed to fetch sponsors: ${response.statusText}`);
+	}
+	const sponsors = await response.json();
+	s.stop("Sponsors fetched successfully!");
+	return sponsors;
+}
+function displaySponsors(sponsors) {
+	const { total_sponsors } = sponsors.summary;
+	if (total_sponsors === 0) {
+		log.info("No sponsors found. You can be the first one! ✨");
+		outro(pc.cyan("Visit https://github.com/sponsors/AmanVarshney01 to become a sponsor."));
+		return;
+	}
+	displaySponsorsBox(sponsors);
+	if (total_sponsors - sponsors.specialSponsors.length > 0) log.message(pc.blue(`+${total_sponsors - sponsors.specialSponsors.length} more amazing sponsors.\n`));
+	outro(pc.magenta("Visit https://github.com/sponsors/AmanVarshney01 to become a sponsor."));
+}
+function displaySponsorsBox(sponsors) {
+	if (sponsors.specialSponsors.length === 0) return;
+	let output = `${pc.bold(pc.cyan("-> Special Sponsors"))}\n\n`;
+	sponsors.specialSponsors.forEach((sponsor, idx) => {
+		const displayName = sponsor.name ?? sponsor.githubId;
+		const tier = sponsor.tierName ? ` ${pc.yellow(`(${sponsor.tierName})`)}` : "";
+		output += `${pc.green(`• ${displayName}`)}${tier}\n`;
+		output += `  ${pc.dim("GitHub:")} https://github.com/${sponsor.githubId}\n`;
+		const website = sponsor.websiteUrl ?? sponsor.githubUrl;
+		if (website) output += `  ${pc.dim("Website:")} ${website}\n`;
+		if (idx < sponsors.specialSponsors.length - 1) output += "\n";
+	});
+	consola$1.box(output);
+}
+
+//#endregion
+//#region src/commands/meta.ts
+const DOCS_URL = "https://better-t-stack.dev/docs";
+const BUILDER_URL = "https://better-t-stack.dev/new";
+async function openExternalUrl(url, successMessage) {
+	if ((await Result.tryPromise({
+		try: () => openUrl(url),
+		catch: () => null
+	})).isOk()) log.success(pc.blue(successMessage));
+	else log.message(`Please visit ${url}`);
+}
+async function showSponsorsCommand() {
+	const result = await Result.tryPromise({
+		try: async () => {
+			renderTitle();
+			intro(pc.magenta("Better-T-Stack Sponsors"));
+			displaySponsors(await fetchSponsors());
+		},
+		catch: (error) => new CLIError({
+			message: error instanceof Error ? error.message : "Failed to display sponsors",
+			cause: error
+		})
+	});
+	if (result.isErr()) {
+		displayError(result.error);
+		process.exit(1);
+	}
+}
+async function openDocsCommand() {
+	await openExternalUrl(DOCS_URL, "Opened docs in your default browser.");
+}
+async function openBuilderCommand() {
+	await openExternalUrl(BUILDER_URL, "Opened builder in your default browser.");
+}
+
+//#endregion
+//#region src/types.ts
+var types_exports = {};
+import * as import__better_t_stack_types from "@better-t-stack/types";
+__reExport(types_exports, import__better_t_stack_types);
+
+//#endregion
+//#region src/utils/compatibility.ts
+const WEB_FRAMEWORKS = [
+	"tanstack-router",
+	"react-router",
+	"tanstack-start",
+	"next",
+	"nuxt",
+	"svelte",
+	"solid",
+	"astro"
+];
+
 //#endregion
 //#region src/utils/compatibility-rules.ts
 function validationErr$1(message) {
@@ -705,6 +1025,10 @@ function getAddonDisplay(addon) {
 			label = "Skills";
 			hint = "AI coding agent skills for your stack";
 			break;
+		case "mcp":
+			label = "MCP";
+			hint = "Install MCP servers (docs, databases, SaaS) via add-mcp";
+			break;
 		default:
 			label = addon;
 			hint = `Add ${addon}`;
@@ -730,7 +1054,11 @@ const ADDON_GROUPS = {
 		"opentui",
 		"wxt"
 	],
-	AI: ["ruler", "skills"]
+	AI: [
+		"ruler",
+		"skills",
+		"mcp"
+	]
 };
 async function getAddonsChoice(addons, frontends, auth) {
 	if (addons !== void 0) return addons;
@@ -756,11 +1084,11 @@ async function getAddonsChoice(addons, frontends, auth) {
 		else if (ADDON_GROUPS.Extensions.includes(addon)) groupedOptions.Extensions.push(option);
 		else if (ADDON_GROUPS.AI.includes(addon)) groupedOptions.AI.push(option);
 	}
-	Object.keys(groupedOptions).forEach((group$1) => {
-		if (groupedOptions[group$1].length === 0) delete groupedOptions[group$1];
+	Object.keys(groupedOptions).forEach((group) => {
+		if (groupedOptions[group].length === 0) delete groupedOptions[group];
 		else {
-			const groupOrder = ADDON_GROUPS[group$1] || [];
-			groupedOptions[group$1].sort((a, b) => {
+			const groupOrder = ADDON_GROUPS[group] || [];
+			groupedOptions[group].sort((a, b) => {
 				return groupOrder.indexOf(a.value) - groupOrder.indexOf(b.value);
 			});
 		}
@@ -795,11 +1123,11 @@ async function getAddonsToAdd(frontend, existingAddons = [], auth) {
 		else if (ADDON_GROUPS.Extensions.includes(addon)) groupedOptions.Extensions.push(option);
 		else if (ADDON_GROUPS.AI.includes(addon)) groupedOptions.AI.push(option);
 	}
-	Object.keys(groupedOptions).forEach((group$1) => {
-		if (groupedOptions[group$1].length === 0) delete groupedOptions[group$1];
+	Object.keys(groupedOptions).forEach((group) => {
+		if (groupedOptions[group].length === 0) delete groupedOptions[group];
 		else {
-			const groupOrder = ADDON_GROUPS[group$1] || [];
-			groupedOptions[group$1].sort((a, b) => {
+			const groupOrder = ADDON_GROUPS[group] || [];
+			groupedOptions[group].sort((a, b) => {
 				return groupOrder.indexOf(a.value) - groupOrder.indexOf(b.value);
 			});
 		}
@@ -845,43 +1173,6 @@ async function updateBtsConfig(projectDir, updates) {
 	} catch {}
 }
 
-//#endregion
-//#region src/utils/render-title.ts
-const TITLE_TEXT = `
- ██████╗ ███████╗████████╗████████╗███████╗██████╗
- ██╔══██╗██╔════╝╚══██╔══╝╚══██╔══╝██╔════╝██╔══██╗
- ██████╔╝█████╗     ██║      ██║   █████╗  ██████╔╝
- ██╔══██╗██╔══╝     ██║      ██║   ██╔══╝  ██╔══██╗
- ██████╔╝███████╗   ██║      ██║   ███████╗██║  ██║
- ╚═════╝ ╚══════╝   ╚═╝      ╚═╝   ╚══════╝╚═╝  ╚═╝
-
- ████████╗    ███████╗████████╗ █████╗  ██████╗██╗  ██╗
- ╚══██╔══╝    ██╔════╝╚══██╔══╝██╔══██╗██╔════╝██║ ██╔╝
-    ██║       ███████╗   ██║   ███████║██║     █████╔╝
-    ██║       ╚════██║   ██║   ██╔══██║██║     ██╔═██╗
-    ██║       ███████║   ██║   ██║  ██║╚██████╗██║  ██╗
-    ╚═╝       ╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝
- `;
-const catppuccinTheme = {
-	pink: "#F5C2E7",
-	mauve: "#CBA6F7",
-	red: "#F38BA8",
-	maroon: "#E78284",
-	peach: "#FAB387",
-	yellow: "#F9E2AF",
-	green: "#A6E3A1",
-	teal: "#94E2D5",
-	sky: "#89DCEB",
-	sapphire: "#74C7EC",
-	lavender: "#B4BEFE"
-};
-const renderTitle = () => {
-	const terminalWidth = process.stdout.columns || 80;
-	const titleLines = TITLE_TEXT.split("\n");
-	if (terminalWidth < Math.max(...titleLines.map((line) => line.length))) console.log(gradient(Object.values(catppuccinTheme)).multiline(`Better T Stack`));
-	else console.log(gradient(Object.values(catppuccinTheme)).multiline(TITLE_TEXT));
-};
-
 //#endregion
 //#region src/utils/add-package-deps.ts
 const addPackageDependency = async (opts) => {
@@ -905,8 +1196,52 @@ const addPackageDependency = async (opts) => {
 	await fs.writeJson(pkgJsonPath, pkgJson, { spaces: 2 });
 };
 
+//#endregion
+//#region src/utils/external-commands.ts
+function shouldSkipExternalCommands() {
+	return process.env.BTS_SKIP_EXTERNAL_COMMANDS === "1" || process.env.BTS_TEST_MODE === "1";
+}
+
 //#endregion
 //#region src/utils/package-runner.ts
+function splitCommandArgs(commandWithArgs) {
+	const args = [];
+	let current = "";
+	let quote = null;
+	for (let i = 0; i < commandWithArgs.length; i += 1) {
+		const char = commandWithArgs[i];
+		if (quote) {
+			if (char === quote) {
+				quote = null;
+				continue;
+			}
+			if (char === "\\" && i + 1 < commandWithArgs.length) {
+				const nextChar = commandWithArgs[i + 1];
+				if (nextChar === quote || nextChar === "\\") {
+					current += nextChar;
+					i += 1;
+					continue;
+				}
+			}
+			current += char;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (/\s/.test(char)) {
+			if (current.length > 0) {
+				args.push(current);
+				current = "";
+			}
+			continue;
+		}
+		current += char;
+	}
+	if (current.length > 0) args.push(current);
+	return args;
+}
 /**
 * Returns the appropriate command for running a package without installing it globally,
 * based on the selected package manager.
@@ -931,7 +1266,7 @@ function getPackageExecutionCommand(packageManager, commandWithArgs) {
 * @returns An array of [command, ...args] (e.g., ["npx", "prisma", "generate"]).
 */
 function getPackageExecutionArgs(packageManager, commandWithArgs) {
-	const args = commandWithArgs.split(" ");
+	const args = splitCommandArgs(commandWithArgs);
 	switch (packageManager) {
 		case "pnpm": return [
 			"pnpm",
@@ -1002,95 +1337,352 @@ const TEMPLATES$2 = {
 	}
 };
 async function setupFumadocs(config) {
+	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const { packageManager, projectDir } = config;
 	log.info("Setting up Fumadocs...");
 	const template = await select({
 		message: "Choose a template",
-		options: Object.entries(TEMPLATES$2).map(([key, template$1]) => ({
+		options: Object.entries(TEMPLATES$2).map(([key, template]) => ({
 			value: key,
-			label: template$1.label,
-			hint: template$1.hint
+			label: template.label,
+			hint: template.hint
 		})),
 		initialValue: "next-mdx"
 	});
-	if (isCancel(template)) return userCancelled("Operation cancelled");
-	const templateArg = TEMPLATES$2[template].value;
-	const isNextTemplate = template.startsWith("next-");
-	const options = [
-		`--template ${templateArg}`,
-		`--pm ${packageManager}`,
-		"--no-git"
-	];
-	if (isNextTemplate) options.push("--src");
-	if (config.addons.includes("biome")) options.push("--linter biome");
-	const args = getPackageExecutionArgs(packageManager, `create-fumadocs-app@latest fumadocs ${options.join(" ")}`);
-	const appsDir = path.join(projectDir, "apps");
-	await fs.ensureDir(appsDir);
-	const s = spinner();
-	s.start("Running Fumadocs create command...");
-	const result = await Result.tryPromise({
-		try: async () => {
-			await $({
-				cwd: appsDir,
-				env: { CI: "true" }
-			})`${args}`;
-			const fumadocsDir = path.join(projectDir, "apps", "fumadocs");
-			const packageJsonPath = path.join(fumadocsDir, "package.json");
-			if (await fs.pathExists(packageJsonPath)) {
-				const packageJson = await fs.readJson(packageJsonPath);
-				packageJson.name = "fumadocs";
-				if (packageJson.scripts?.dev) packageJson.scripts.dev = `${packageJson.scripts.dev} --port=4000`;
-				await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-			}
-		},
-		catch: (e) => new AddonSetupError({
-			addon: "fumadocs",
-			message: `Failed to set up Fumadocs: ${e instanceof Error ? e.message : String(e)}`,
-			cause: e
-		})
+	if (isCancel(template)) return userCancelled("Operation cancelled");
+	const templateArg = TEMPLATES$2[template].value;
+	const isNextTemplate = template.startsWith("next-");
+	const options = [
+		`--template ${templateArg}`,
+		`--pm ${packageManager}`,
+		"--no-git"
+	];
+	if (isNextTemplate) options.push("--src");
+	if (config.addons.includes("biome")) options.push("--linter biome");
+	const args = getPackageExecutionArgs(packageManager, `create-fumadocs-app@latest fumadocs ${options.join(" ")}`);
+	const appsDir = path.join(projectDir, "apps");
+	await fs.ensureDir(appsDir);
+	const s = spinner();
+	s.start("Running Fumadocs create command...");
+	const result = await Result.tryPromise({
+		try: async () => {
+			await $({
+				cwd: appsDir,
+				env: { CI: "true" }
+			})`${args}`;
+			const fumadocsDir = path.join(projectDir, "apps", "fumadocs");
+			const packageJsonPath = path.join(fumadocsDir, "package.json");
+			if (await fs.pathExists(packageJsonPath)) {
+				const packageJson = await fs.readJson(packageJsonPath);
+				packageJson.name = "fumadocs";
+				if (packageJson.scripts?.dev) packageJson.scripts.dev = `${packageJson.scripts.dev} --port=4000`;
+				await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+			}
+		},
+		catch: (e) => new AddonSetupError({
+			addon: "fumadocs",
+			message: `Failed to set up Fumadocs: ${e instanceof Error ? e.message : String(e)}`,
+			cause: e
+		})
+	});
+	if (result.isErr()) {
+		s.stop("Failed to set up Fumadocs");
+		return result;
+	}
+	s.stop("Fumadocs setup complete!");
+	return Result.ok(void 0);
+}
+
+//#endregion
+//#region src/helpers/addons/mcp-setup.ts
+const MCP_AGENTS = [
+	{
+		value: "cursor",
+		label: "Cursor",
+		scope: "both"
+	},
+	{
+		value: "claude-code",
+		label: "Claude Code",
+		scope: "both"
+	},
+	{
+		value: "codex",
+		label: "Codex",
+		scope: "both"
+	},
+	{
+		value: "opencode",
+		label: "OpenCode",
+		scope: "both"
+	},
+	{
+		value: "gemini-cli",
+		label: "Gemini CLI",
+		scope: "both"
+	},
+	{
+		value: "vscode",
+		label: "VS Code (GitHub Copilot)",
+		scope: "both"
+	},
+	{
+		value: "zed",
+		label: "Zed",
+		scope: "both"
+	},
+	{
+		value: "claude-desktop",
+		label: "Claude Desktop",
+		scope: "global"
+	},
+	{
+		value: "goose",
+		label: "Goose",
+		scope: "global"
+	}
+];
+function uniqueValues$1(values) {
+	return Array.from(new Set(values));
+}
+function hasReactBasedFrontend$1(frontend) {
+	return frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("tanstack-start") || frontend.includes("next");
+}
+function getRecommendedMcpServers(config) {
+	const servers = [];
+	servers.push({
+		key: "context7",
+		label: "Context7",
+		name: "context7",
+		target: "@upstash/context7-mcp"
+	});
+	if (config.runtime === "workers" || config.webDeploy === "cloudflare" || config.serverDeploy === "cloudflare") servers.push({
+		key: "cloudflare-docs",
+		label: "Cloudflare Docs",
+		name: "cloudflare-docs",
+		target: "https://docs.mcp.cloudflare.com/sse",
+		transport: "sse"
+	});
+	if (config.backend === "convex") servers.push({
+		key: "convex",
+		label: "Convex",
+		name: "convex",
+		target: "npx -y convex@latest mcp start"
+	});
+	if (hasReactBasedFrontend$1(config.frontend)) servers.push({
+		key: "shadcn",
+		label: "shadcn/ui",
+		name: "shadcn",
+		target: "npx -y shadcn@latest mcp"
+	});
+	if (config.frontend.includes("next")) servers.push({
+		key: "next-devtools",
+		label: "Next Devtools",
+		name: "next-devtools",
+		target: "npx -y next-devtools-mcp@latest"
+	});
+	if (config.frontend.includes("nuxt")) servers.push({
+		key: "nuxt-docs",
+		label: "Nuxt Docs",
+		name: "nuxt",
+		target: "https://nuxt.com/mcp"
+	}, {
+		key: "nuxt-ui-docs",
+		label: "Nuxt UI Docs",
+		name: "nuxt-ui",
+		target: "https://ui.nuxt.com/mcp"
+	});
+	if (config.frontend.includes("svelte")) servers.push({
+		key: "svelte-docs",
+		label: "Svelte Docs",
+		name: "svelte",
+		target: "https://mcp.svelte.dev/mcp"
+	});
+	if (config.frontend.includes("astro")) servers.push({
+		key: "astro-docs",
+		label: "Astro Docs",
+		name: "astro-docs",
+		target: "https://mcp.docs.astro.build/mcp"
+	});
+	if (config.dbSetup === "planetscale") servers.push({
+		key: "planetscale",
+		label: "PlanetScale",
+		name: "planetscale",
+		target: "https://mcp.pscale.dev/mcp/planetscale"
+	});
+	if (config.dbSetup === "neon") servers.push({
+		key: "neon",
+		label: "Neon",
+		name: "neon",
+		target: "https://mcp.neon.tech/mcp"
+	});
+	if (config.dbSetup === "supabase") servers.push({
+		key: "supabase",
+		label: "Supabase",
+		name: "supabase",
+		target: "https://mcp.supabase.com/mcp"
+	});
+	if (config.auth === "better-auth") servers.push({
+		key: "better-auth",
+		label: "Better Auth",
+		name: "better-auth",
+		target: "https://mcp.inkeep.com/better-auth/mcp"
+	});
+	if (config.payments === "polar") servers.push({
+		key: "polar",
+		label: "Polar",
+		name: "polar",
+		target: "https://mcp.polar.sh/mcp/polar-mcp"
+	});
+	return servers;
+}
+function filterAgentsForScope(scope) {
+	return MCP_AGENTS.filter((a) => a.scope === "both" || a.scope === scope);
+}
+async function setupMcp(config) {
+	if (shouldSkipExternalCommands()) return Result.ok(void 0);
+	const { packageManager, projectDir } = config;
+	log.info("Setting up MCP servers...");
+	const scope = await select({
+		message: "Where should MCP servers be installed?",
+		options: [{
+			value: "project",
+			label: "Project",
+			hint: "Writes to project config files (recommended for teams)"
+		}, {
+			value: "global",
+			label: "Global",
+			hint: "Writes to user-level config files (personal machine)"
+		}],
+		initialValue: "project"
+	});
+	if (isCancel(scope)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+	const recommendedServers = getRecommendedMcpServers(config);
+	if (recommendedServers.length === 0) return Result.ok(void 0);
+	const serverOptions = recommendedServers.map((s) => ({
+		value: s.key,
+		label: s.label,
+		hint: s.target
+	}));
+	const selectedServerKeys = await multiselect({
+		message: "Select MCP servers to install",
+		options: serverOptions,
+		required: false,
+		initialValues: serverOptions.map((o) => o.value)
+	});
+	if (isCancel(selectedServerKeys)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+	if (selectedServerKeys.length === 0) return Result.ok(void 0);
+	const agentOptions = filterAgentsForScope(scope).map((a) => ({
+		value: a.value,
+		label: a.label
+	}));
+	const selectedAgents = await multiselect({
+		message: "Select agents to install MCP servers to",
+		options: agentOptions,
+		required: false,
+		initialValues: uniqueValues$1([
+			"cursor",
+			"claude-code",
+			"vscode"
+		].filter((a) => agentOptions.some((o) => o.value === a)))
 	});
-	if (result.isErr()) {
-		s.stop("Failed to set up Fumadocs");
-		return result;
+	if (isCancel(selectedAgents)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
+	if (selectedAgents.length === 0) return Result.ok(void 0);
+	const serversByKey = new Map(recommendedServers.map((s) => [s.key, s]));
+	const selectedServers = [];
+	for (const key of selectedServerKeys) {
+		const server = serversByKey.get(key);
+		if (server) selectedServers.push(server);
 	}
-	s.stop("Fumadocs setup complete!");
+	if (selectedServers.length === 0) return Result.ok(void 0);
+	const installSpinner = spinner();
+	installSpinner.start("Installing MCP servers...");
+	const runner = getPackageRunnerPrefix(packageManager);
+	const globalFlags = scope === "global" ? ["-g"] : [];
+	for (const server of selectedServers) {
+		const transportFlags = server.transport ? ["-t", server.transport] : [];
+		const headerFlags = (server.headers ?? []).flatMap((h) => ["--header", h]);
+		const agentFlags = selectedAgents.flatMap((a) => ["-a", a]);
+		const args = [
+			...runner,
+			"add-mcp@latest",
+			server.target,
+			"--name",
+			server.name,
+			...transportFlags,
+			...headerFlags,
+			...agentFlags,
+			...globalFlags,
+			"-y"
+		];
+		if ((await Result.tryPromise({
+			try: async () => {
+				await $({
+					cwd: projectDir,
+					env: { CI: "true" }
+				})`${args}`;
+			},
+			catch: (e) => new AddonSetupError({
+				addon: "mcp",
+				message: `Failed to install MCP server '${server.name}': ${e instanceof Error ? e.message : String(e)}`,
+				cause: e
+			})
+		})).isErr()) log.warn(pc.yellow(`Warning: Could not install MCP server '${server.name}'`));
+	}
+	installSpinner.stop("MCP servers installed");
 	return Result.ok(void 0);
 }
 
 //#endregion
 //#region src/helpers/addons/oxlint-setup.ts
 async function setupOxlint(projectDir, packageManager) {
-	await addPackageDependency({
-		devDependencies: ["oxlint", "oxfmt"],
-		projectDir
+	return Result.tryPromise({
+		try: async () => {
+			await addPackageDependency({
+				devDependencies: ["oxlint", "oxfmt"],
+				projectDir
+			});
+			const packageJsonPath = path.join(projectDir, "package.json");
+			if (await fs.pathExists(packageJsonPath)) {
+				const packageJson = await fs.readJson(packageJsonPath);
+				packageJson.scripts = {
+					...packageJson.scripts,
+					check: "oxlint && oxfmt --write"
+				};
+				await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+			}
+			if (shouldSkipExternalCommands()) return;
+			const s = spinner();
+			s.start("Initializing oxlint and oxfmt...");
+			try {
+				const oxlintArgs = getPackageExecutionArgs(packageManager, "oxlint@latest --init");
+				await $({
+					cwd: projectDir,
+					env: { CI: "true" }
+				})`${oxlintArgs}`;
+				const oxfmtArgs = getPackageExecutionArgs(packageManager, "oxfmt@latest --init");
+				await $({
+					cwd: projectDir,
+					env: { CI: "true" }
+				})`${oxfmtArgs}`;
+				s.stop("oxlint and oxfmt initialized successfully!");
+			} catch (error) {
+				s.stop("Failed to initialize oxlint and oxfmt");
+				throw error;
+			}
+		},
+		catch: (error) => new AddonSetupError({
+			addon: "oxlint",
+			message: `Failed to set up oxlint: ${error instanceof Error ? error.message : String(error)}`,
+			cause: error
+		})
 	});
-	const packageJsonPath = path.join(projectDir, "package.json");
-	if (await fs.pathExists(packageJsonPath)) {
-		const packageJson = await fs.readJson(packageJsonPath);
-		packageJson.scripts = {
-			...packageJson.scripts,
-			check: "oxlint && oxfmt --write"
-		};
-		await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
-	}
-	const s = spinner();
-	const oxlintArgs = getPackageExecutionArgs(packageManager, "oxlint@latest --init");
-	s.start("Initializing oxlint and oxfmt...");
-	await $({
-		cwd: projectDir,
-		env: { CI: "true" }
-	})`${oxlintArgs}`;
-	const oxfmtArgs = getPackageExecutionArgs(packageManager, "oxfmt@latest --init");
-	await $({
-		cwd: projectDir,
-		env: { CI: "true" }
-	})`${oxfmtArgs}`;
-	s.stop("oxlint and oxfmt initialized successfully!");
 }
 
 //#endregion
 //#region src/helpers/addons/ruler-setup.ts
 async function setupRuler(config) {
+	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const { packageManager, projectDir } = config;
 	log.info("Setting up Ruler...");
 	const rulerDir = path.join(projectDir, ".ruler");
@@ -1189,54 +1781,20 @@ async function addRulerScriptToPackageJson(projectDir, packageManager) {
 //#endregion
 //#region src/helpers/addons/skills-setup.ts
 const SKILL_SOURCES = {
-	"vercel-labs/agent-skills": {
-		source: "vercel-labs/agent-skills",
-		label: "Vercel Agent Skills"
-	},
-	"anthropics/skills": {
-		source: "https://github.com/anthropics/skills",
-		label: "Anthropic Skills"
-	},
-	"vercel/ai": {
-		source: "vercel/ai",
-		label: "Vercel AI SDK"
-	},
-	"vercel/turborepo": {
-		source: "vercel/turborepo",
-		label: "Turborepo"
-	},
-	"yusukebe/hono-skill": {
-		source: "yusukebe/hono-skill",
-		label: "Hono Backend"
-	},
-	"vercel-labs/next-skills": {
-		source: "vercel-labs/next-skills",
-		label: "Next.js Best Practices"
-	},
-	"heroui-inc/heroui": {
-		source: "heroui-inc/heroui",
-		label: "HeroUI Native"
-	},
-	"better-auth/skills": {
-		source: "better-auth/skills",
-		label: "Better Auth"
-	},
-	"neondatabase/agent-skills": {
-		source: "neondatabase/agent-skills",
-		label: "Neon Database"
-	},
-	"supabase/agent-skills": {
-		source: "supabase/agent-skills",
-		label: "Supabase"
-	},
-	"elysiajs/skills": {
-		source: "elysiajs/skills",
-		label: "ElysiaJS"
-	},
-	"waynesutton/convexskills": {
-		source: "waynesutton/convexskills",
-		label: "Convex"
-	}
+	"vercel-labs/agent-skills": { label: "Vercel Agent Skills" },
+	"vercel/ai": { label: "Vercel AI SDK" },
+	"vercel/turborepo": { label: "Turborepo" },
+	"yusukebe/hono-skill": { label: "Hono Backend" },
+	"vercel-labs/next-skills": { label: "Next.js Best Practices" },
+	"nuxt/ui": { label: "Nuxt UI" },
+	"heroui-inc/heroui": { label: "HeroUI Native" },
+	"better-auth/skills": { label: "Better Auth" },
+	"neondatabase/agent-skills": { label: "Neon Database" },
+	"supabase/agent-skills": { label: "Supabase" },
+	"expo/skills": { label: "Expo" },
+	"prisma/skills": { label: "Prisma" },
+	"elysiajs/skills": { label: "ElysiaJS" },
+	"waynesutton/convexskills": { label: "Convex" }
 };
 const AVAILABLE_AGENTS = [
 	{
@@ -1340,15 +1898,24 @@ const AVAILABLE_AGENTS = [
 		label: "MCPJam"
 	}
 ];
+function hasReactBasedFrontend(frontend) {
+	return frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("tanstack-start") || frontend.includes("next");
+}
+function hasNativeFrontend(frontend) {
+	return frontend.includes("native-bare") || frontend.includes("native-uniwind") || frontend.includes("native-unistyles");
+}
 function getRecommendedSourceKeys(config) {
 	const sources = [];
-	const { frontend, backend, dbSetup, auth, examples, addons } = config;
-	if (frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("tanstack-start") || frontend.includes("next")) sources.push("vercel-labs/agent-skills");
+	const { frontend, backend, dbSetup, auth, examples, addons, orm } = config;
+	if (hasReactBasedFrontend(frontend)) sources.push("vercel-labs/agent-skills");
 	if (frontend.includes("next")) sources.push("vercel-labs/next-skills");
+	if (frontend.includes("nuxt")) sources.push("nuxt/ui");
 	if (frontend.includes("native-uniwind")) sources.push("heroui-inc/heroui");
+	if (hasNativeFrontend(frontend)) sources.push("expo/skills");
 	if (auth === "better-auth") sources.push("better-auth/skills");
 	if (dbSetup === "neon") sources.push("neondatabase/agent-skills");
 	if (dbSetup === "supabase") sources.push("supabase/agent-skills");
+	if (orm === "prisma" || dbSetup === "prisma-postgres") sources.push("prisma/skills");
 	if (examples.includes("ai")) sources.push("vercel/ai");
 	if (addons.includes("turborepo")) sources.push("vercel/turborepo");
 	if (backend === "hono") sources.push("yusukebe/hono-skill");
@@ -1356,54 +1923,95 @@ function getRecommendedSourceKeys(config) {
 	if (backend === "convex") sources.push("waynesutton/convexskills");
 	return sources;
 }
-function parseSkillsFromOutput(output) {
-	const skills = [];
-	const lines = output.split("\n");
-	for (const line of lines) {
-		const match = line.replace(/\x1b\[[0-9;]*m/g, "").match(/^│\s{4}([a-z][a-z0-9-]*)$/);
-		if (match) skills.push(match[1]);
-	}
-	return skills;
+const CURATED_SKILLS_BY_SOURCE = {
+	"vercel-labs/agent-skills": (config) => {
+		const skills = [
+			"web-design-guidelines",
+			"vercel-composition-patterns",
+			"vercel-react-best-practices"
+		];
+		if (hasNativeFrontend(config.frontend)) skills.push("vercel-react-native-skills");
+		return skills;
+	},
+	"vercel/ai": () => ["ai-sdk"],
+	"vercel/turborepo": () => ["turborepo"],
+	"yusukebe/hono-skill": () => ["hono"],
+	"vercel-labs/next-skills": () => ["next-best-practices", "next-cache-components"],
+	"nuxt/ui": () => ["nuxt-ui"],
+	"heroui-inc/heroui": () => ["heroui-native"],
+	"better-auth/skills": () => ["better-auth-best-practices"],
+	"neondatabase/agent-skills": () => ["neon-postgres"],
+	"supabase/agent-skills": () => ["supabase-postgres-best-practices"],
+	"expo/skills": (config) => {
+		const skills = [
+			"expo-dev-client",
+			"building-native-ui",
+			"native-data-fetching",
+			"expo-deployment",
+			"upgrading-expo",
+			"expo-cicd-workflows"
+		];
+		if (config.frontend.includes("native-uniwind")) skills.push("expo-tailwind-setup");
+		return skills;
+	},
+	"prisma/skills": (config) => {
+		const skills = [];
+		if (config.orm === "prisma") skills.push("prisma-cli", "prisma-client-api", "prisma-database-setup");
+		if (config.dbSetup === "prisma-postgres") skills.push("prisma-postgres");
+		return skills;
+	},
+	"elysiajs/skills": () => ["elysiajs"],
+	"waynesutton/convexskills": () => [
+		"convex-best-practices",
+		"convex-functions",
+		"convex-schema-validator",
+		"convex-realtime",
+		"convex-http-actions",
+		"convex-cron-jobs",
+		"convex-file-storage",
+		"convex-migrations",
+		"convex-security-check"
+	]
+};
+function getCuratedSkillNamesForSourceKey(sourceKey, config) {
+	return CURATED_SKILLS_BY_SOURCE[sourceKey](config);
 }
-async function fetchSkillsFromSource(source, packageManager, projectDir) {
-	try {
-		const args = getPackageExecutionArgs(packageManager, `skills@latest add ${source.source} --list`);
-		return parseSkillsFromOutput((await $({
-			cwd: projectDir,
-			env: { CI: "true" }
-		})`${args}`).stdout);
-	} catch {
-		return [];
-	}
+function uniqueValues(values) {
+	return Array.from(new Set(values));
 }
 async function setupSkills(config) {
+	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const { packageManager, projectDir } = config;
 	const btsConfig = await readBtsConfig(projectDir);
-	const recommendedSourceKeys = getRecommendedSourceKeys(btsConfig ? {
+	const fullConfig = btsConfig ? {
 		...config,
 		addons: btsConfig.addons ?? config.addons
-	} : config);
+	} : config;
+	const recommendedSourceKeys = getRecommendedSourceKeys(fullConfig);
 	if (recommendedSourceKeys.length === 0) return Result.ok(void 0);
-	const s = spinner();
-	s.start("Fetching available skills...");
-	const allSkills = [];
-	for (const sourceKey of recommendedSourceKeys) {
+	const skillOptions = uniqueValues(recommendedSourceKeys).flatMap((sourceKey) => {
 		const source = SKILL_SOURCES[sourceKey];
-		if (!source) continue;
-		const skills = await fetchSkillsFromSource(source, packageManager, projectDir);
-		for (const skillName of skills) allSkills.push({
-			name: skillName,
-			source: source.source,
-			sourceLabel: source.label
-		});
-	}
-	s.stop("Fetched available skills");
-	if (allSkills.length === 0) return Result.ok(void 0);
-	const skillOptions = allSkills.map((skill) => ({
-		value: `${skill.source}::${skill.name}`,
-		label: skill.name,
-		hint: skill.sourceLabel
-	}));
+		return getCuratedSkillNamesForSourceKey(sourceKey, fullConfig).map((skillName) => ({
+			value: `${sourceKey}::${skillName}`,
+			label: skillName,
+			hint: source.label
+		}));
+	});
+	if (skillOptions.length === 0) return Result.ok(void 0);
+	const scope = await select({
+		message: "Where should skills be installed?",
+		options: [{
+			value: "project",
+			label: "Project",
+			hint: "Writes to project config files (recommended for teams)"
+		}, {
+			value: "global",
+			label: "Global",
+			hint: "Writes to user-level config files (personal machine)"
+		}],
+		initialValue: "project"
+	});
+	if (isCancel(scope)) return Result.err(new UserCancelledError({ message: "Operation cancelled" }));
 	const selectedSkills = await multiselect({
 		message: "Select skills to install",
 		options: skillOptions,
@@ -1433,11 +2041,12 @@ async function setupSkills(config) {
 	const installSpinner = spinner();
 	installSpinner.start("Installing skills...");
 	const agentFlags = selectedAgents.map((a) => `-a ${a}`).join(" ");
+	const globalFlag = scope === "global" ? "-g" : "";
 	for (const [source, skills] of Object.entries(skillsBySource)) {
-		const skillFlags = skills.map((s$1) => `-s ${s$1}`).join(" ");
+		const skillFlags = skills.map((s) => `-s ${s}`).join(" ");
 		if ((await Result.tryPromise({
 			try: async () => {
-				const args = getPackageExecutionArgs(packageManager, `skills@latest add ${source} ${skillFlags} ${agentFlags} -y`);
+				const args = getPackageExecutionArgs(packageManager, `skills@latest add ${source} ${globalFlag} ${skillFlags} ${agentFlags} -y`);
 				await $({
 					cwd: projectDir,
 					env: { CI: "true" }
@@ -1457,6 +2066,7 @@ async function setupSkills(config) {
 //#endregion
 //#region src/helpers/addons/starlight-setup.ts
 async function setupStarlight(config) {
+	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const { packageManager, projectDir } = config;
 	const s = spinner();
 	s.start("Setting up Starlight docs...");
@@ -1496,6 +2106,7 @@ async function setupStarlight(config) {
 //#endregion
 //#region src/helpers/addons/tauri-setup.ts
 async function setupTauri(config) {
+	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const { packageManager, frontend, projectDir } = config;
 	const s = spinner();
 	const clientPackageDir = path.join(projectDir, "apps/web");
@@ -1556,14 +2167,15 @@ const TEMPLATES$1 = {
 	}
 };
 async function setupTui(config) {
+	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const { packageManager, projectDir } = config;
 	log.info("Setting up OpenTUI...");
 	const template = await select({
 		message: "Choose a template",
-		options: Object.entries(TEMPLATES$1).map(([key, template$1]) => ({
+		options: Object.entries(TEMPLATES$1).map(([key, template]) => ({
 			value: key,
-			label: template$1.label,
-			hint: template$1.hint
+			label: template.label,
+			hint: template.hint
 		})),
 		initialValue: "core"
 	});
@@ -1681,6 +2293,7 @@ function getFrameworksFromFrontend(frontend) {
 	return Array.from(frameworks);
 }
 async function setupUltracite(config, gitHooks) {
+	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const { packageManager, projectDir, frontend } = config;
 	log.info("Setting up Ultracite...");
 	let result;
@@ -1689,10 +2302,10 @@ async function setupUltracite(config, gitHooks) {
 			return await group({
 				linter: () => select({
 					message: "Choose linter/formatter",
-					options: Object.entries(LINTERS).map(([key, linter$1]) => ({
+					options: Object.entries(LINTERS).map(([key, linter]) => ({
 						value: key,
-						label: linter$1.label,
-						hint: linter$1.hint
+						label: linter.label,
+						hint: linter.hint
 					})),
 					initialValue: "biome"
 				}),
@@ -1811,14 +2424,15 @@ const TEMPLATES = {
 	}
 };
 async function setupWxt(config) {
+	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const { packageManager, projectDir } = config;
 	log.info("Setting up WXT...");
 	const template = await select({
 		message: "Choose a template",
-		options: Object.entries(TEMPLATES).map(([key, template$1]) => ({
+		options: Object.entries(TEMPLATES).map(([key, template]) => ({
 			value: key,
-			label: template$1.label,
-			hint: template$1.hint
+			label: template.label,
+			hint: template.hint
 		})),
 		initialValue: "react"
 	});
@@ -1886,6 +2500,17 @@ async function runSetup(setupFn) {
 		consola.error(pc.red(result.error.message));
 	}
 }
+async function runAddonStep(addon, step) {
+	const result = await Result.tryPromise({
+		try: async () => step(),
+		catch: (e) => new AddonSetupError({
+			addon,
+			message: `Failed to set up ${addon}: ${e instanceof Error ? e.message : String(e)}`,
+			cause: e
+		})
+	});
+	if (result.isErr()) consola.error(pc.red(result.error.message));
+}
 async function setupAddons(config) {
 	const { addons, frontend, projectDir } = config;
 	const hasReactWebFrontend = frontend.includes("react-router") || frontend.includes("tanstack-router") || frontend.includes("next");
@@ -1905,14 +2530,14 @@ async function setupAddons(config) {
 		if (hasLefthook) gitHooks.push("lefthook");
 		await runSetup(() => setupUltracite(config, gitHooks));
 	} else {
-		if (hasBiome) await setupBiome(projectDir);
-		if (hasOxlint) await setupOxlint(projectDir, config.packageManager);
+		if (hasBiome) await runAddonStep("biome", () => setupBiome(projectDir));
+		if (hasOxlint) await runSetup(() => setupOxlint(projectDir, config.packageManager));
 		if (hasHusky || hasLefthook) {
 			let linter;
 			if (hasOxlint) linter = "oxlint";
 			else if (hasBiome) linter = "biome";
-			if (hasHusky) await setupHusky(projectDir, linter);
-			if (hasLefthook) await setupLefthook(projectDir);
+			if (hasHusky) await runAddonStep("husky", () => setupHusky(projectDir, linter));
+			if (hasLefthook) await runAddonStep("lefthook", () => setupLefthook(projectDir));
 		}
 	}
 	if (addons.includes("starlight")) await runSetup(() => setupStarlight(config));
@@ -1921,6 +2546,7 @@ async function setupAddons(config) {
 	if (addons.includes("wxt")) await runSetup(() => setupWxt(config));
 	if (addons.includes("ruler")) await runSetup(() => setupRuler(config));
 	if (addons.includes("skills")) await runSetup(() => setupSkills(config));
+	if (addons.includes("mcp")) await runSetup(() => setupMcp(config));
 }
 async function setupBiome(projectDir) {
 	await addPackageDependency({
@@ -1996,6 +2622,7 @@ async function detectProjectConfig(projectDir) {
 //#endregion
 //#region src/helpers/core/install-dependencies.ts
 async function installDependencies({ projectDir, packageManager }) {
+	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const s = spinner();
 	s.start(`Running ${packageManager} install...`);
 	const result = await Result.tryPromise({
@@ -2230,13 +2857,13 @@ async function getAuthChoice(auth, backend, frontend) {
 			label: "None",
 			hint: "No auth"
 		});
-		const response$1 = await navigableSelect({
+		const response = await navigableSelect({
 			message: "Select authentication provider",
 			options,
 			initialValue: "none"
 		});
-		if (isCancel$1(response$1)) throw new UserCancelledError({ message: "Operation cancelled" });
-		return response$1;
+		if (isCancel$1(response)) throw new UserCancelledError({ message: "Operation cancelled" });
+		return response;
 	}
 	const response = await navigableSelect({
 		message: "Select authentication provider",
@@ -2835,6 +3462,27 @@ async function getDeploymentChoice(deployment, _runtime, _backend, frontend = []
 //#endregion
 //#region src/prompts/config-prompts.ts
 async function gatherConfig(flags, projectName, projectDir, relativePath) {
+	if (isSilent()) return {
+		projectName,
+		projectDir,
+		relativePath,
+		frontend: flags.frontend ?? [...DEFAULT_CONFIG.frontend],
+		backend: flags.backend ?? DEFAULT_CONFIG.backend,
+		runtime: flags.runtime ?? DEFAULT_CONFIG.runtime,
+		database: flags.database ?? DEFAULT_CONFIG.database,
+		orm: flags.orm ?? DEFAULT_CONFIG.orm,
+		auth: flags.auth ?? DEFAULT_CONFIG.auth,
+		payments: flags.payments ?? DEFAULT_CONFIG.payments,
+		addons: flags.addons ?? [...DEFAULT_CONFIG.addons],
+		examples: flags.examples ?? [...DEFAULT_CONFIG.examples],
+		git: flags.git ?? DEFAULT_CONFIG.git,
+		packageManager: flags.packageManager ?? DEFAULT_CONFIG.packageManager,
+		install: flags.install ?? DEFAULT_CONFIG.install,
+		dbSetup: flags.dbSetup ?? DEFAULT_CONFIG.dbSetup,
+		api: flags.api ?? DEFAULT_CONFIG.api,
+		webDeploy: flags.webDeploy ?? DEFAULT_CONFIG.webDeploy,
+		serverDeploy: flags.serverDeploy ?? DEFAULT_CONFIG.serverDeploy
+	};
 	const result = await navigableGroup({
 		frontend: () => getFrontendChoice(flags.frontend, flags.backend, flags.auth),
 		backend: ({ results }) => getBackendFrameworkChoice(flags.backend, results.frontend),
@@ -2880,7 +3528,7 @@ async function gatherConfig(flags, projectName, projectDir, relativePath) {
 
 //#endregion
 //#region src/prompts/project-name.ts
-function isPathWithinCwd(targetPath) {
+function isPathWithinCwd$1(targetPath) {
 	const resolved = path.resolve(targetPath);
 	const rel = path.relative(process.cwd(), resolved);
 	return !rel.startsWith("..") && !path.isAbsolute(rel);
@@ -2894,7 +3542,7 @@ async function getProjectName(initialName) {
 	if (initialName) {
 		if (initialName === ".") return initialName;
 		if (!validateDirectoryName(path.basename(initialName))) {
-			if (isPathWithinCwd(path.resolve(process.cwd(), initialName))) return initialName;
+			if (isPathWithinCwd$1(path.resolve(process.cwd(), initialName))) return initialName;
 			consola.error(pc.red("Project path must be within current directory"));
 		}
 	}
@@ -2917,7 +3565,7 @@ async function getProjectName(initialName) {
 				const validationError = validateDirectoryName(path.basename(nameToUse));
 				if (validationError) return validationError;
 				if (nameToUse !== ".") {
-					if (!isPathWithinCwd(path.resolve(process.cwd(), nameToUse))) return "Project path must be within current directory";
+					if (!isPathWithinCwd$1(path.resolve(process.cwd(), nameToUse))) return "Project path must be within current directory";
 				}
 			}
 		});
@@ -2928,13 +3576,6 @@ async function getProjectName(initialName) {
 	return projectPath;
 }
 
-//#endregion
-//#region src/utils/get-latest-cli-version.ts
-const getLatestCLIVersion = () => {
-	const packageJsonPath = path.join(PKG_ROOT, "package.json");
-	return fs.readJSONSync(packageJsonPath).version ?? "1.0.0";
-};
-
 //#endregion
 //#region src/utils/telemetry.ts
 /**
@@ -2945,7 +3586,7 @@ const getLatestCLIVersion = () => {
 */
 function isTelemetryEnabled() {
 	const BTS_TELEMETRY_DISABLED = process.env.BTS_TELEMETRY_DISABLED;
-	const BTS_TELEMETRY = "1";
+	const BTS_TELEMETRY = "0";
 	if (BTS_TELEMETRY_DISABLED !== void 0) return BTS_TELEMETRY_DISABLED !== "1";
 	if (BTS_TELEMETRY !== void 0) return BTS_TELEMETRY === "1";
 	return true;
@@ -2953,17 +3594,7 @@ function isTelemetryEnabled() {
 
 //#endregion
 //#region src/utils/analytics.ts
-const CONVEX_INGEST_URL = "https://striped-seahorse-863.convex.site/api/analytics/ingest";
-async function sendConvexEvent(payload) {
-	await Result.tryPromise({
-		try: () => fetch(CONVEX_INGEST_URL, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify(payload)
-		}),
-		catch: () => void 0
-	});
-}
+async function sendConvexEvent(payload) {}
 async function trackProjectCreation(config, disableAnalytics = false) {
 	if (!isTelemetryEnabled() || disableAnalytics) return;
 	const { projectName: _projectName, projectDir: _projectDir, relativePath: _relativePath, ...safeConfig } = config;
@@ -3088,138 +3719,44 @@ async function setupProjectDirectory(finalPathInput, shouldClearDirectory) {
 		finalBaseName = path.basename(finalResolvedPath);
 	}
 	if (shouldClearDirectory) {
-		const s = spinner();
-		s.start(`Clearing directory "${finalResolvedPath}"...`);
-		const clearResult = await Result.tryPromise({
-			try: () => fs.emptyDir(finalResolvedPath),
-			catch: (error) => new CLIError({
-				message: `Failed to clear directory "${finalResolvedPath}".`,
-				cause: error
-			})
-		});
-		if (clearResult.isErr()) {
-			s.stop(pc.red(`Failed to clear directory "${finalResolvedPath}".`));
-			throw clearResult.error;
-		}
-		s.stop(`Directory "${finalResolvedPath}" cleared.`);
-	} else await fs.ensureDir(finalResolvedPath);
-	return {
-		finalResolvedPath,
-		finalBaseName
-	};
-}
-
-//#endregion
-//#region src/utils/project-history.ts
-const paths = envPaths("better-t-stack", { suffix: "" });
-const HISTORY_FILE = "history.json";
-var HistoryError = class extends TaggedError("HistoryError")() {};
-function getHistoryDir() {
-	return paths.data;
-}
-function getHistoryPath() {
-	return path.join(paths.data, HISTORY_FILE);
-}
-function generateId() {
-	return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
-function emptyHistory() {
-	return {
-		version: 1,
-		entries: []
-	};
-}
-async function ensureHistoryDir() {
-	return Result.tryPromise({
-		try: async () => {
-			await fs.ensureDir(getHistoryDir());
-		},
-		catch: (e) => new HistoryError({
-			message: `Failed to create history directory: ${e instanceof Error ? e.message : String(e)}`,
-			cause: e
-		})
-	});
-}
-async function readHistory() {
-	const historyPath = getHistoryPath();
-	const existsResult = await Result.tryPromise({
-		try: async () => await fs.pathExists(historyPath),
-		catch: (e) => new HistoryError({
-			message: `Failed to check history file: ${e instanceof Error ? e.message : String(e)}`,
-			cause: e
-		})
-	});
-	if (existsResult.isErr()) return existsResult;
-	if (!existsResult.value) return Result.ok(emptyHistory());
-	const readResult = await Result.tryPromise({
-		try: async () => await fs.readJson(historyPath),
-		catch: (e) => new HistoryError({
-			message: `Failed to read history file: ${e instanceof Error ? e.message : String(e)}`,
-			cause: e
-		})
-	});
-	if (readResult.isErr()) return Result.ok(emptyHistory());
-	return Result.ok(readResult.value);
-}
-async function writeHistory(history) {
-	const ensureDirResult = await ensureHistoryDir();
-	if (ensureDirResult.isErr()) return ensureDirResult;
-	return Result.tryPromise({
-		try: async () => {
-			await fs.writeJson(getHistoryPath(), history, { spaces: 2 });
-		},
-		catch: (e) => new HistoryError({
-			message: `Failed to write history file: ${e instanceof Error ? e.message : String(e)}`,
-			cause: e
-		})
-	});
-}
-async function addToHistory(config, reproducibleCommand) {
-	const historyResult = await readHistory();
-	if (historyResult.isErr()) return historyResult;
-	const history = historyResult.value;
-	const entry = {
-		id: generateId(),
-		projectName: config.projectName,
-		projectDir: config.projectDir,
-		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-		stack: {
-			frontend: config.frontend,
-			backend: config.backend,
-			database: config.database,
-			orm: config.orm,
-			runtime: config.runtime,
-			auth: config.auth,
-			payments: config.payments,
-			api: config.api,
-			addons: config.addons,
-			examples: config.examples,
-			dbSetup: config.dbSetup,
-			packageManager: config.packageManager
-		},
-		cliVersion: getLatestCLIVersion(),
-		reproducibleCommand
+		const s = spinner();
+		s.start(`Clearing directory "${finalResolvedPath}"...`);
+		const clearResult = await Result.tryPromise({
+			try: () => fs.emptyDir(finalResolvedPath),
+			catch: (error) => new CLIError({
+				message: `Failed to clear directory "${finalResolvedPath}".`,
+				cause: error
+			})
+		});
+		if (clearResult.isErr()) {
+			s.stop(pc.red(`Failed to clear directory "${finalResolvedPath}".`));
+			throw clearResult.error;
+		}
+		s.stop(`Directory "${finalResolvedPath}" cleared.`);
+	} else await fs.ensureDir(finalResolvedPath);
+	return {
+		finalResolvedPath,
+		finalBaseName
 	};
-	history.entries.unshift(entry);
-	if (history.entries.length > 100) history.entries = history.entries.slice(0, 100);
-	return await writeHistory(history);
 }
-async function getHistory(limit = 10) {
-	const historyResult = await readHistory();
-	if (historyResult.isErr()) return historyResult;
-	return Result.ok(historyResult.value.entries.slice(0, limit));
+
+//#endregion
+//#region src/utils/project-name-validation.ts
+function validateProjectName(name) {
+	const result = types_exports.ProjectNameSchema.safeParse(name);
+	if (!result.success) return Result.err(new ValidationError({
+		field: "projectName",
+		value: name,
+		message: `Invalid project name: ${result.error.issues[0]?.message || "Invalid project name"}`
+	}));
+	return Result.ok(void 0);
 }
-async function clearHistory() {
-	const historyPath = getHistoryPath();
-	return Result.tryPromise({
-		try: async () => {
-			if (await fs.pathExists(historyPath)) await fs.remove(historyPath);
-		},
-		catch: (e) => new HistoryError({
-			message: `Failed to clear history: ${e instanceof Error ? e.message : String(e)}`,
-			cause: e
-		})
-	});
+function extractAndValidateProjectName(projectName, projectDirectory) {
+	const derivedName = projectName || (projectDirectory ? path.basename(path.resolve(process.cwd(), projectDirectory)) : "");
+	if (!derivedName) return Result.ok("");
+	const validationResult = validateProjectName(projectName ? path.basename(projectName) : derivedName);
+	if (validationResult.isErr()) return Result.err(validationResult.error);
+	return Result.ok(projectName || derivedName);
 }
 
 //#endregion
@@ -3515,7 +4052,7 @@ function validateFullConfig(config, providedFlags, options) {
 		yield* validateServerDeployRequiresBackend(config.serverDeploy, config.backend);
 		yield* validateSelfBackendCompatibility(providedFlags, options, config);
 		yield* validateWorkersCompatibility(providedFlags, options, config);
-		if (config.runtime === "workers" && config.serverDeploy === "none") yield* validationErr("Cloudflare Workers runtime requires a server deployment. Please choose 'alchemy' for --server-deploy.");
+		if (config.runtime === "workers" && config.serverDeploy === "none") yield* validationErr("Cloudflare Workers runtime requires a server deployment. Please choose 'cloudflare' for --server-deploy.");
 		if (providedFlags.has("serverDeploy") && config.serverDeploy === "cloudflare" && config.runtime !== "workers") yield* validationErr(`Server deployment '${config.serverDeploy}' requires '--runtime workers'. Please use '--runtime workers' or choose a different server deployment.`);
 		if (config.addons && config.addons.length > 0) {
 			yield* validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth);
@@ -3538,25 +4075,6 @@ function validateConfigForProgrammaticUse(config) {
 	});
 }
 
-//#endregion
-//#region src/utils/project-name-validation.ts
-function validateProjectName(name) {
-	const result = types_exports.ProjectNameSchema.safeParse(name);
-	if (!result.success) return Result.err(new ValidationError({
-		field: "projectName",
-		value: name,
-		message: `Invalid project name: ${result.error.issues[0]?.message || "Invalid project name"}`
-	}));
-	return Result.ok(void 0);
-}
-function extractAndValidateProjectName(projectName, projectDirectory) {
-	const derivedName = projectName || (projectDirectory ? path.basename(path.resolve(process.cwd(), projectDirectory)) : "");
-	if (!derivedName) return Result.ok("");
-	const validationResult = validateProjectName(projectName ? path.basename(projectName) : derivedName);
-	if (validationResult.isErr()) return Result.err(validationResult.error);
-	return Result.ok(projectName || derivedName);
-}
-
 //#endregion
 //#region src/validation.ts
 const CORE_STACK_FLAGS = new Set([
@@ -3584,8 +4102,8 @@ function validateYesFlagCombination(options, providedFlags) {
 function processAndValidateFlags(options, providedFlags, projectName) {
 	if (options.yolo) {
 		const cfg = processFlags(options, projectName);
-		const validatedProjectNameResult$1 = extractAndValidateProjectName(projectName, options.projectDirectory);
-		if (validatedProjectNameResult$1.isOk() && validatedProjectNameResult$1.value) cfg.projectName = validatedProjectNameResult$1.value;
+		const validatedProjectNameResult = extractAndValidateProjectName(projectName, options.projectDirectory);
+		if (validatedProjectNameResult.isOk() && validatedProjectNameResult.value) cfg.projectName = validatedProjectNameResult.value;
 		return Result.ok(cfg);
 	}
 	const yesFlagResult = validateYesFlagCombination(options, providedFlags);
@@ -3696,18 +4214,26 @@ async function addEnvVariablesToFile(envPath, variables) {
 //#region src/helpers/database-providers/d1-setup.ts
 async function setupCloudflareD1(config) {
 	const { projectDir, serverDeploy, orm, backend } = config;
-	if (serverDeploy === "cloudflare" && orm === "prisma") {
-		const targetApp2 = backend === "self" ? "apps/web" : "apps/server";
-		await addEnvVariablesToFile(path.join(projectDir, targetApp2, ".env"), [{
-			key: "DATABASE_URL",
-			value: `file:${path.join(projectDir, "apps/server", "local.db")}`,
-			condition: true
-		}]);
-		await addPackageDependency({
-			dependencies: ["@prisma/adapter-d1"],
-			projectDir: path.join(projectDir, backend === "self" ? "apps/web" : "apps/server")
-		});
-	}
+	if (!(serverDeploy === "cloudflare" && orm === "prisma")) return Result.ok(void 0);
+	return Result.tryPromise({
+		try: async () => {
+			const targetApp = backend === "self" ? "apps/web" : "apps/server";
+			await addEnvVariablesToFile(path.join(projectDir, targetApp, ".env"), [{
+				key: "DATABASE_URL",
+				value: `file:${path.join(projectDir, targetApp, "local.db")}`,
+				condition: true
+			}]);
+			await addPackageDependency({
+				dependencies: ["@prisma/adapter-d1"],
+				projectDir: path.join(projectDir, backend === "self" ? "apps/web" : "apps/server")
+			});
+		},
+		catch: (e) => new DatabaseSetupError({
+			provider: "d1",
+			message: `Failed to set up Cloudflare D1: ${e instanceof Error ? e.message : String(e)}`,
+			cause: e
+		})
+	});
 }
 
 //#endregion
@@ -3849,8 +4375,8 @@ async function setupMongoDBAtlas(config, cliInput) {
 	if (ensureDirResult.isErr()) return ensureDirResult;
 	if (manualDb) {
 		log.info("MongoDB Atlas manual setup selected");
-		const envResult$1 = await writeEnvFile$3(projectDir, backend);
-		if (envResult$1.isErr()) return envResult$1;
+		const envResult = await writeEnvFile$3(projectDir, backend);
+		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$3();
 		return Result.ok(void 0);
 	}
@@ -3870,15 +4396,15 @@ async function setupMongoDBAtlas(config, cliInput) {
 	if (isCancel(mode)) return userCancelled("Operation cancelled");
 	if (mode === "manual") {
 		log.info("MongoDB Atlas manual setup selected");
-		const envResult$1 = await writeEnvFile$3(projectDir, backend);
-		if (envResult$1.isErr()) return envResult$1;
+		const envResult = await writeEnvFile$3(projectDir, backend);
+		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$3();
 		return Result.ok(void 0);
 	}
 	const mongoConfigResult = await initMongoDBAtlas(serverDir);
 	if (mongoConfigResult.isOk()) {
-		const envResult$1 = await writeEnvFile$3(projectDir, backend, mongoConfigResult.value);
-		if (envResult$1.isErr()) return envResult$1;
+		const envResult = await writeEnvFile$3(projectDir, backend, mongoConfigResult.value);
+		if (envResult.isErr()) return envResult;
 		log.success(pc.green("MongoDB Atlas setup complete! Connection saved to .env file."));
 		return Result.ok(void 0);
 	}
@@ -4037,8 +4563,8 @@ async function setupNeonPostgres(config, cliInput) {
 	const manualDb = cliInput?.manualDb ?? false;
 	const target = backend === "self" ? "apps/web" : "apps/server";
 	if (manualDb) {
-		const envResult$1 = await writeEnvFile$2(projectDir, backend);
-		if (envResult$1.isErr()) return envResult$1;
+		const envResult = await writeEnvFile$2(projectDir, backend);
+		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$2(target);
 		return Result.ok(void 0);
 	}
@@ -4057,8 +4583,8 @@ async function setupNeonPostgres(config, cliInput) {
 	});
 	if (isCancel(mode)) return userCancelled("Operation cancelled");
 	if (mode === "manual") {
-		const envResult$1 = await writeEnvFile$2(projectDir, backend);
-		if (envResult$1.isErr()) return envResult$1;
+		const envResult = await writeEnvFile$2(projectDir, backend);
+		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$2(target);
 		return Result.ok(void 0);
 	}
@@ -4080,8 +4606,8 @@ async function setupNeonPostgres(config, cliInput) {
 		const neonDbResult = await setupWithNeonDb(projectDir, packageManager, backend);
 		if (neonDbResult.isErr()) {
 			log.error(pc.red(neonDbResult.error.message));
-			const envResult$1 = await writeEnvFile$2(projectDir, backend);
-			if (envResult$1.isErr()) return envResult$1;
+			const envResult = await writeEnvFile$2(projectDir, backend);
+			if (envResult.isErr()) return envResult;
 			displayManualSetupInstructions$2(target);
 		} else log.info(`Get Neon with Better T Stack referral: ${pc.cyan("https://get.neon.com/sbA3tIe")}`);
 		return neonDbResult;
@@ -4102,8 +4628,8 @@ async function setupNeonPostgres(config, cliInput) {
 	const neonConfigResult = await createNeonProject(projectName, regionId, packageManager);
 	if (neonConfigResult.isErr()) {
 		log.error(pc.red(neonConfigResult.error.message));
-		const envResult$1 = await writeEnvFile$2(projectDir, backend);
-		if (envResult$1.isErr()) return envResult$1;
+		const envResult = await writeEnvFile$2(projectDir, backend);
+		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$2(target);
 		return Result.ok(void 0);
 	}
@@ -4123,61 +4649,71 @@ async function setupNeonPostgres(config, cliInput) {
 //#region src/helpers/database-providers/planetscale-setup.ts
 async function setupPlanetScale(config) {
 	const { projectDir, database, orm, backend } = config;
-	const targetApp = backend === "self" ? "apps/web" : "apps/server";
-	const envPath = path.join(projectDir, targetApp, ".env");
-	if (database === "mysql" && orm === "drizzle") {
-		const variables = [
-			{
-				key: "DATABASE_URL",
-				value: "mysql://username:password@host/database?ssl={\"rejectUnauthorized\":true}",
-				condition: true
-			},
-			{
-				key: "DATABASE_HOST",
-				value: "",
-				condition: true
-			},
-			{
-				key: "DATABASE_USERNAME",
-				value: "",
-				condition: true
-			},
-			{
-				key: "DATABASE_PASSWORD",
-				value: "",
-				condition: true
+	if (!["mysql", "postgres"].includes(database)) return Result.ok(void 0);
+	return Result.tryPromise({
+		try: async () => {
+			const targetApp = backend === "self" ? "apps/web" : "apps/server";
+			const envPath = path.join(projectDir, targetApp, ".env");
+			if (database === "mysql" && orm === "drizzle") {
+				const variables = [
+					{
+						key: "DATABASE_URL",
+						value: "mysql://username:password@host/database?ssl={\"rejectUnauthorized\":true}",
+						condition: true
+					},
+					{
+						key: "DATABASE_HOST",
+						value: "",
+						condition: true
+					},
+					{
+						key: "DATABASE_USERNAME",
+						value: "",
+						condition: true
+					},
+					{
+						key: "DATABASE_PASSWORD",
+						value: "",
+						condition: true
+					}
+				];
+				await fs.ensureDir(path.join(projectDir, targetApp));
+				await addEnvVariablesToFile(envPath, variables);
 			}
-		];
-		await fs.ensureDir(path.join(projectDir, targetApp));
-		await addEnvVariablesToFile(envPath, variables);
-	}
-	if (database === "postgres" && orm === "prisma") {
-		const variables = [{
-			key: "DATABASE_URL",
-			value: "postgresql://username:password@host/database?sslaccept=strict",
-			condition: true
-		}];
-		await fs.ensureDir(path.join(projectDir, targetApp));
-		await addEnvVariablesToFile(envPath, variables);
-	}
-	if (database === "postgres" && orm === "drizzle") {
-		const variables = [{
-			key: "DATABASE_URL",
-			value: "postgresql://username:password@host/database?sslmode=verify-full",
-			condition: true
-		}];
-		await fs.ensureDir(path.join(projectDir, targetApp));
-		await addEnvVariablesToFile(envPath, variables);
-	}
-	if (database === "mysql" && orm === "prisma") {
-		const variables = [{
-			key: "DATABASE_URL",
-			value: "mysql://username:password@host/database?sslaccept=strict",
-			condition: true
-		}];
-		await fs.ensureDir(path.join(projectDir, targetApp));
-		await addEnvVariablesToFile(envPath, variables);
-	}
+			if (database === "postgres" && orm === "prisma") {
+				const variables = [{
+					key: "DATABASE_URL",
+					value: "postgresql://username:password@host/database?sslaccept=strict",
+					condition: true
+				}];
+				await fs.ensureDir(path.join(projectDir, targetApp));
+				await addEnvVariablesToFile(envPath, variables);
+			}
+			if (database === "postgres" && orm === "drizzle") {
+				const variables = [{
+					key: "DATABASE_URL",
+					value: "postgresql://username:password@host/database?sslmode=verify-full",
+					condition: true
+				}];
+				await fs.ensureDir(path.join(projectDir, targetApp));
+				await addEnvVariablesToFile(envPath, variables);
+			}
+			if (database === "mysql" && orm === "prisma") {
+				const variables = [{
+					key: "DATABASE_URL",
+					value: "mysql://username:password@host/database?sslaccept=strict",
+					condition: true
+				}];
+				await fs.ensureDir(path.join(projectDir, targetApp));
+				await addEnvVariablesToFile(envPath, variables);
+			}
+		},
+		catch: (e) => new DatabaseSetupError({
+			provider: "planetscale",
+			message: `Failed to set up PlanetScale env: ${e instanceof Error ? e.message : String(e)}`,
+			cause: e
+		})
+	});
 }
 
 //#endregion
@@ -4299,8 +4835,8 @@ async function setupPrismaPostgres(config, cliInput) {
 	});
 	if (ensureDirResult.isErr()) return ensureDirResult;
 	if (manualDb) {
-		const envResult$1 = await writeEnvFile$1(projectDir, backend);
-		if (envResult$1.isErr()) return envResult$1;
+		const envResult = await writeEnvFile$1(projectDir, backend);
+		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$1(target);
 		return Result.ok(void 0);
 	}
@@ -4319,8 +4855,8 @@ async function setupPrismaPostgres(config, cliInput) {
 	});
 	if (isCancel(setupMode)) return userCancelled("Operation cancelled");
 	if (setupMode === "manual") {
-		const envResult$1 = await writeEnvFile$1(projectDir, backend);
-		if (envResult$1.isErr()) return envResult$1;
+		const envResult = await writeEnvFile$1(projectDir, backend);
+		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$1(target);
 		return Result.ok(void 0);
 	}
@@ -4328,8 +4864,8 @@ async function setupPrismaPostgres(config, cliInput) {
 	if (prismaConfigResult.isErr()) {
 		if (UserCancelledError.is(prismaConfigResult.error)) return prismaConfigResult;
 		log.error(pc.red(prismaConfigResult.error.message));
-		const envResult$1 = await writeEnvFile$1(projectDir, backend);
-		if (envResult$1.isErr()) return envResult$1;
+		const envResult = await writeEnvFile$1(projectDir, backend);
+		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$1(target);
 		log.info("Setup completed with manual configuration required.");
 		return Result.ok(void 0);
@@ -4398,9 +4934,9 @@ async function startSupabase(serverDir, packageManager) {
 			const subprocess = execa(supabaseStartArgs[0], supabaseStartArgs.slice(1), { cwd: serverDir });
 			let stdoutData = "";
 			if (subprocess.stdout) subprocess.stdout.on("data", (data) => {
-				const text$1 = data.toString();
-				process.stdout.write(text$1);
-				stdoutData += text$1;
+				const text = data.toString();
+				process.stdout.write(text);
+				stdoutData += text;
 			});
 			if (subprocess.stderr) subprocess.stderr.pipe(process.stderr);
 			await subprocess;
@@ -4587,9 +5123,9 @@ async function selectTursoGroup() {
 	}
 	const selectedGroup = await select({
 		message: "Select a Turso database group:",
-		options: groups.map((group$1) => ({
-			value: group$1.name,
-			label: `${group$1.name} (${group$1.locations})`
+		options: groups.map((group) => ({
+			value: group.name,
+			label: `${group.name} (${group.locations})`
 		}))
 	});
 	if (isCancel(selectedGroup)) return userCancelled("Operation cancelled");
@@ -4767,8 +5303,8 @@ async function setupTurso(config, cliInput) {
 				continue;
 			}
 			log.error(pc.red(createResult.error.message));
-			const envResult$1 = await writeEnvFile(projectDir, backend);
-			if (envResult$1.isErr()) return envResult$1;
+			const envResult = await writeEnvFile(projectDir, backend);
+			if (envResult.isErr()) return envResult;
 			displayManualSetupInstructions();
 			log.success("Setup completed with manual configuration required.");
 			return Result.ok(void 0);
@@ -4793,23 +5329,23 @@ async function setupDatabase(config, cliInput) {
 	}
 	const dbPackageDir = path.join(projectDir, "packages/db");
 	if (!await fs.pathExists(dbPackageDir)) return;
-	async function runSetup$1(setupFn) {
+	async function runSetup(setupFn) {
 		const result = await setupFn();
 		if (result.isErr()) {
 			if (UserCancelledError.is(result.error)) throw result.error;
 			consola.error(pc.red(result.error.message));
 		}
 	}
-	if (dbSetup === "docker") await runSetup$1(() => setupDockerCompose(config));
-	else if (database === "sqlite" && dbSetup === "turso") await runSetup$1(() => setupTurso(config, cliInput));
-	else if (database === "sqlite" && dbSetup === "d1") await setupCloudflareD1(config);
+	if (dbSetup === "docker") await runSetup(() => setupDockerCompose(config));
+	else if (database === "sqlite" && dbSetup === "turso") await runSetup(() => setupTurso(config, cliInput));
+	else if (database === "sqlite" && dbSetup === "d1") await runSetup(() => setupCloudflareD1(config));
 	else if (database === "postgres") {
-		if (dbSetup === "prisma-postgres") await runSetup$1(() => setupPrismaPostgres(config, cliInput));
-		else if (dbSetup === "neon") await runSetup$1(() => setupNeonPostgres(config, cliInput));
-		else if (dbSetup === "planetscale") await setupPlanetScale(config);
-		else if (dbSetup === "supabase") await runSetup$1(() => setupSupabase(config, cliInput));
-	} else if (database === "mysql" && dbSetup === "planetscale") await setupPlanetScale(config);
-	else if (database === "mongodb" && dbSetup === "mongodb-atlas") await runSetup$1(() => setupMongoDBAtlas(config, cliInput));
+		if (dbSetup === "prisma-postgres") await runSetup(() => setupPrismaPostgres(config, cliInput));
+		else if (dbSetup === "neon") await runSetup(() => setupNeonPostgres(config, cliInput));
+		else if (dbSetup === "planetscale") await runSetup(() => setupPlanetScale(config));
+		else if (dbSetup === "supabase") await runSetup(() => setupSupabase(config, cliInput));
+	} else if (database === "mysql" && dbSetup === "planetscale") await runSetup(() => setupPlanetScale(config));
+	else if (database === "mongodb" && dbSetup === "mongodb-atlas") await runSetup(() => setupMongoDBAtlas(config, cliInput));
 }
 
 //#endregion
@@ -4930,11 +5466,12 @@ async function displayPostInstallInstructions(config) {
 		"solid"
 	].includes(f));
 	const hasNative = frontend?.includes("native-bare") || frontend?.includes("native-uniwind") || frontend?.includes("native-unistyles");
-	const bunWebNativeWarning = packageManager === "bun" && hasNative && hasWeb ? getBunWebNativeWarning() : "";
-	const noOrmWarning = !isConvex && database !== "none" && orm === "none" ? getNoOrmWarning() : "";
 	const hasReactRouter = frontend?.includes("react-router");
 	const hasSvelte = frontend?.includes("svelte");
 	const webPort = hasReactRouter || hasSvelte ? "5173" : "3001";
+	const betterAuthConvexInstructions = isConvex && config.auth === "better-auth" ? getBetterAuthConvexInstructions(hasWeb ?? false, webPort, packageManager) : "";
+	const bunWebNativeWarning = packageManager === "bun" && hasNative && hasWeb ? getBunWebNativeWarning() : "";
+	const noOrmWarning = !isConvex && database !== "none" && orm === "none" ? getNoOrmWarning() : "";
 	let output = `${pc.bold("Next steps")}\n${pc.cyan("1.")} ${cdCmd}\n`;
 	let stepCounter = 2;
 	if (!depsInstalled) output += `${pc.cyan(`${stepCounter++}.`)} ${packageManager} install\n`;
@@ -4974,6 +5511,7 @@ async function displayPostInstallInstructions(config) {
 	if (alchemyDeployInstructions) output += `\n${alchemyDeployInstructions.trim()}\n`;
 	if (starlightInstructions) output += `\n${starlightInstructions.trim()}\n`;
 	if (clerkInstructions) output += `\n${clerkInstructions.trim()}\n`;
+	if (betterAuthConvexInstructions) output += `\n${betterAuthConvexInstructions.trim()}\n`;
 	if (polarInstructions) output += `\n${polarInstructions.trim()}\n`;
 	if (noOrmWarning) output += `\n${noOrmWarning.trim()}\n`;
 	if (bunWebNativeWarning) output += `\n${bunWebNativeWarning.trim()}\n`;
@@ -5057,6 +5595,10 @@ function getBunWebNativeWarning() {
 function getClerkInstructions() {
 	return `${pc.bold("Clerk Authentication Setup:")}\n${pc.cyan("•")} Follow the guide: ${pc.underline("https://docs.convex.dev/auth/clerk")}\n${pc.cyan("•")} Set CLERK_JWT_ISSUER_DOMAIN in Convex Dashboard\n${pc.cyan("•")} Set CLERK_PUBLISHABLE_KEY in apps/*/.env`;
 }
+function getBetterAuthConvexInstructions(hasWeb, webPort, packageManager) {
+	const cmd = packageManager === "npm" ? "npx" : packageManager;
+	return `${pc.bold("Better Auth + Convex Setup:")}\n${pc.cyan("•")} Set environment variables from ${pc.white("packages/backend")}:\n${pc.white("   cd packages/backend")}\n${pc.white(`   ${cmd} convex env set BETTER_AUTH_SECRET=$(openssl rand -base64 32)`)}\n` + (hasWeb ? `${pc.white(`   ${cmd} convex env set SITE_URL http://localhost:${webPort}`)}\n` : "");
+}
 function getPolarInstructions(backend) {
 	const envPath = backend === "self" ? "apps/web/.env" : "apps/server/.env";
 	return `${pc.bold("Polar Payments Setup:")}\n${pc.cyan("•")} Get access token & product ID from ${pc.underline("https://sandbox.polar.sh/")}\n${pc.cyan("•")} Set POLAR_ACCESS_TOKEN in ${envPath}`;
@@ -5064,9 +5606,9 @@ function getPolarInstructions(backend) {
 function getAlchemyDeployInstructions(runCmd, webDeploy, serverDeploy, backend) {
 	const instructions = [];
 	const isBackendSelf = backend === "self";
-	if (webDeploy === "cloudflare" && serverDeploy !== "cloudflare") instructions.push(`${pc.bold("Deploy web with Alchemy:")}\n${pc.cyan("•")} Dev: ${`cd apps/web && ${runCmd} alchemy dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/web && ${runCmd} destroy`}`);
-	else if (serverDeploy === "cloudflare" && webDeploy !== "cloudflare" && !isBackendSelf) instructions.push(`${pc.bold("Deploy server with Alchemy:")}\n${pc.cyan("•")} Dev: ${`cd apps/server && ${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/server && ${runCmd} destroy`}`);
-	else if (webDeploy === "cloudflare" && (serverDeploy === "cloudflare" || isBackendSelf)) instructions.push(`${pc.bold("Deploy with Alchemy:")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
+	if (webDeploy === "cloudflare" && serverDeploy !== "cloudflare") instructions.push(`${pc.bold("Deploy web with Cloudflare (Alchemy):")}\n${pc.cyan("•")} Dev: ${`cd apps/web && ${runCmd} alchemy dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/web && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/web && ${runCmd} destroy`}`);
+	else if (serverDeploy === "cloudflare" && webDeploy !== "cloudflare" && !isBackendSelf) instructions.push(`${pc.bold("Deploy server with Cloudflare (Alchemy):")}\n${pc.cyan("•")} Dev: ${`cd apps/server && ${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`cd apps/server && ${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`cd apps/server && ${runCmd} destroy`}`);
+	else if (webDeploy === "cloudflare" && (serverDeploy === "cloudflare" || isBackendSelf)) instructions.push(`${pc.bold("Deploy with Cloudflare (Alchemy):")}\n${pc.cyan("•")} Dev: ${`${runCmd} dev`}\n${pc.cyan("•")} Deploy: ${`${runCmd} deploy`}\n${pc.cyan("•")} Destroy: ${`${runCmd} destroy`}`);
 	return instructions.length ? `\n${instructions.join("\n")}` : "";
 }
 
@@ -5138,7 +5680,7 @@ async function setPackageManagerVersion(projectDir, packageManager) {
 	if (!await fs.pathExists(pkgJsonPath)) return Result.ok(void 0);
 	const versionResult = await Result.tryPromise({
 		try: async () => {
-			const { stdout } = await $`${packageManager} -v`;
+			const { stdout } = await $({ cwd: os$1.tmpdir() })`${packageManager} -v`;
 			return stdout.trim();
 		},
 		catch: () => null
@@ -5219,7 +5761,8 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 		if (!isSilent()) intro(pc.magenta("Creating a new Better-T-Stack project"));
 		if (!isSilent() && input.yolo) consola.fatal("YOLO mode enabled - skipping checks. Things may break!");
 		let currentPathInput;
-		if (input.yes && input.projectName) currentPathInput = input.projectName;
+		if (isSilent()) currentPathInput = yield* Result.await(resolveProjectNameForSilent(input));
+		else if (input.yes && input.projectName) currentPathInput = input.projectName;
 		else if (input.yes) {
 			const defaultConfig = getDefaultConfig();
 			let defaultName = defaultConfig.relativePath;
@@ -5349,6 +5892,23 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 		});
 	});
 }
+function isPathWithinCwd(targetPath) {
+	const resolved = path.resolve(targetPath);
+	const rel = path.relative(process.cwd(), resolved);
+	return !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+async function resolveProjectNameForSilent(input) {
+	const defaultConfig = getDefaultConfig();
+	const candidate = (input.projectName?.trim() || void 0) ?? defaultConfig.relativePath;
+	if (candidate === ".") return Result.ok(candidate);
+	const validationResult = validateProjectName(path.basename(candidate));
+	if (validationResult.isErr()) return Result.err(new CLIError({
+		message: validationResult.error.message,
+		cause: validationResult.error
+	}));
+	if (!isPathWithinCwd(candidate)) return Result.err(new CLIError({ message: "Project path must be within current directory" }));
+	return Result.ok(candidate);
+}
 async function handleDirectoryConflictResult(currentPathInput, strategy) {
 	if (strategy) return handleDirectoryConflictProgrammatically(currentPathInput, strategy);
 	return Result.tryPromise({
@@ -5400,121 +5960,8 @@ async function handleDirectoryConflictProgrammatically(currentPathInput, strateg
 	}
 }
 
-//#endregion
-//#region src/utils/open-url.ts
-async function openUrl(url) {
-	const platform = process.platform;
-	if ((await Result.tryPromise({
-		try: async () => {
-			if (platform === "darwin") await $({ stdio: "ignore" })`open ${url}`;
-			else if (platform === "win32") {
-				const escapedUrl = url.replace(/&/g, "^&");
-				await $({ stdio: "ignore" })`cmd /c start "" ${escapedUrl}`;
-			} else await $({ stdio: "ignore" })`xdg-open ${url}`;
-		},
-		catch: () => void 0
-	})).isErr()) log.message(`Please open ${url} in your browser.`);
-}
-
-//#endregion
-//#region src/utils/sponsors.ts
-const SPONSORS_JSON_URL = "https://sponsors.better-t-stack.dev/sponsors.json";
-async function fetchSponsors(url = SPONSORS_JSON_URL) {
-	const s = spinner();
-	s.start("Fetching sponsors…");
-	const response = await fetch(url);
-	if (!response.ok) {
-		s.stop(pc.red(`Failed to fetch sponsors: ${response.statusText}`));
-		throw new Error(`Failed to fetch sponsors: ${response.statusText}`);
-	}
-	const sponsors$1 = await response.json();
-	s.stop("Sponsors fetched successfully!");
-	return sponsors$1;
-}
-function displaySponsors(sponsors$1) {
-	const { total_sponsors } = sponsors$1.summary;
-	if (total_sponsors === 0) {
-		log.info("No sponsors found. You can be the first one! ✨");
-		outro(pc.cyan("Visit https://github.com/sponsors/AmanVarshney01 to become a sponsor."));
-		return;
-	}
-	displaySponsorsBox(sponsors$1);
-	if (total_sponsors - sponsors$1.specialSponsors.length > 0) log.message(pc.blue(`+${total_sponsors - sponsors$1.specialSponsors.length} more amazing sponsors.\n`));
-	outro(pc.magenta("Visit https://github.com/sponsors/AmanVarshney01 to become a sponsor."));
-}
-function displaySponsorsBox(sponsors$1) {
-	if (sponsors$1.specialSponsors.length === 0) return;
-	let output = `${pc.bold(pc.cyan("-> Special Sponsors"))}\n\n`;
-	sponsors$1.specialSponsors.forEach((sponsor, idx) => {
-		const displayName = sponsor.name ?? sponsor.githubId;
-		const tier = sponsor.tierName ? ` ${pc.yellow(`(${sponsor.tierName})`)}` : "";
-		output += `${pc.green(`• ${displayName}`)}${tier}\n`;
-		output += `  ${pc.dim("GitHub:")} https://github.com/${sponsor.githubId}\n`;
-		const website = sponsor.websiteUrl ?? sponsor.githubUrl;
-		if (website) output += `  ${pc.dim("Website:")} ${website}\n`;
-		if (idx < sponsors$1.specialSponsors.length - 1) output += "\n";
-	});
-	consola$1.box(output);
-}
-
 //#endregion
 //#region src/index.ts
-function formatStackSummary(entry) {
-	const parts = [];
-	if (entry.stack.frontend.length > 0 && !entry.stack.frontend.includes("none")) parts.push(entry.stack.frontend.join(", "));
-	if (entry.stack.backend && entry.stack.backend !== "none") parts.push(entry.stack.backend);
-	if (entry.stack.database && entry.stack.database !== "none") parts.push(entry.stack.database);
-	if (entry.stack.orm && entry.stack.orm !== "none") parts.push(entry.stack.orm);
-	return parts.length > 0 ? parts.join(" + ") : "minimal";
-}
-function formatDate(isoString) {
-	return new Date(isoString).toLocaleDateString("en-US", {
-		year: "numeric",
-		month: "short",
-		day: "numeric",
-		hour: "2-digit",
-		minute: "2-digit"
-	});
-}
-async function historyHandler(input) {
-	if (input.clear) {
-		const clearResult = await clearHistory();
-		if (clearResult.isErr()) {
-			log.warn(pc.yellow(clearResult.error.message));
-			return;
-		}
-		log.success(pc.green("Project history cleared."));
-		return;
-	}
-	const historyResult = await getHistory(input.limit);
-	if (historyResult.isErr()) {
-		log.warn(pc.yellow(historyResult.error.message));
-		return;
-	}
-	const entries = historyResult.value;
-	if (entries.length === 0) {
-		log.info(pc.dim("No projects in history yet."));
-		log.info(pc.dim("Create a project with: create-better-t-stack my-app"));
-		return;
-	}
-	if (input.json) {
-		console.log(JSON.stringify(entries, null, 2));
-		return;
-	}
-	renderTitle();
-	intro(pc.magenta(`Project History (${entries.length} entries)`));
-	for (const [index, entry] of entries.entries()) {
-		const num = pc.dim(`${index + 1}.`);
-		const name = pc.cyan(pc.bold(entry.projectName));
-		const stack = pc.dim(formatStackSummary(entry));
-		log.message(`${num} ${name}`);
-		log.message(`   ${pc.dim("Created:")} ${formatDate(entry.createdAt)}`);
-		log.message(`   ${pc.dim("Path:")} ${entry.projectDir}`);
-		log.message(`   ${pc.dim("Stack:")} ${stack}`);
-		log.message(`   ${pc.dim("Command:")} ${pc.dim(entry.reproducibleCommand)}`);
-		log.message("");
-	}
-}
 const router = os.router({
 	create: os.meta({
 		description: "Create a new Better-T-Stack project",
@@ -5553,39 +6000,9 @@ const router = os.router({
 		});
 		if (options.verbose) return result;
 	}),
-	sponsors: os.meta({ description: "Show Better-T-Stack sponsors" }).handler(async () => {
-		const result = await Result.tryPromise({
-			try: async () => {
-				renderTitle();
-				intro(pc.magenta("Better-T-Stack Sponsors"));
-				displaySponsors(await fetchSponsors());
-			},
-			catch: (e) => new CLIError({
-				message: e instanceof Error ? e.message : "Failed to display sponsors",
-				cause: e
-			})
-		});
-		if (result.isErr()) {
-			displayError(result.error);
-			process.exit(1);
-		}
-	}),
-	docs: os.meta({ description: "Open Better-T-Stack documentation" }).handler(async () => {
-		const DOCS_URL = "https://better-t-stack.dev/docs";
-		if ((await Result.tryPromise({
-			try: () => openUrl(DOCS_URL),
-			catch: () => null
-		})).isOk()) log.success(pc.blue("Opened docs in your default browser."));
-		else log.message(`Please visit ${DOCS_URL}`);
-	}),
-	builder: os.meta({ description: "Open the web-based stack builder" }).handler(async () => {
-		const BUILDER_URL = "https://better-t-stack.dev/new";
-		if ((await Result.tryPromise({
-			try: () => openUrl(BUILDER_URL),
-			catch: () => null
-		})).isOk()) log.success(pc.blue("Opened builder in your default browser."));
-		else log.message(`Please visit ${BUILDER_URL}`);
-	}),
+	sponsors: os.meta({ description: "Show Better-T-Stack sponsors" }).handler(showSponsorsCommand),
+	docs: os.meta({ description: "Open Better-T-Stack documentation" }).handler(openDocsCommand),
+	builder: os.meta({ description: "Open the web-based stack builder" }).handler(openBuilderCommand),
 	add: os.meta({ description: "Add addons to an existing Better-T-Stack project" }).input(z.object({
 		addons: z.array(types_exports.AddonsSchema).optional().describe("Addons to add"),
 		install: z.boolean().optional().default(false).describe("Install dependencies after adding"),