@makerkit/cli 2.0.2 → 2.0.4

package/dist/index.mjs

@@ -0,0 +1,1333 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+import prompts from "prompts";
+import { dirname, join } from "path";
+import { execa, execaCommand } from "execa";
+import fs from "fs-extra";
+import invariant from "tiny-invariant";
+import { homedir, tmpdir } from "os";
+import { config } from "dotenv";
+//#region src/version.ts
+const CLI_VERSION = "2.0.3";
+//#endregion
+//#region src/utils/marker-file.ts
+async function writeMarkerFile(projectPath, variant, kitRepo) {
+	const dir = join(projectPath, ".makerkit");
+	await fs.ensureDir(dir);
+	const config = {
+		version: 1,
+		variant,
+		kit_repo: kitRepo,
+		created_at: (/* @__PURE__ */ new Date()).toISOString(),
+		cli_version: CLI_VERSION
+	};
+	await fs.writeJson(join(dir, "config.json"), config, { spaces: 2 });
+}
+//#endregion
+//#region src/utils/upstream.ts
+const VARIANT_REPO_MAP = {
+	"next-supabase": "makerkit/next-supabase-saas-kit-turbo",
+	"next-drizzle": "makerkit/next-drizzle-saas-kit-turbo",
+	"next-prisma": "makerkit/next-prisma-saas-kit-turbo",
+	"react-router-supabase": "makerkit/react-router-supabase-saas-kit-turbo"
+};
+function sshUrl(repo) {
+	return `git@github.com:${repo}`;
+}
+function httpsUrl(repo) {
+	return `https://github.com/${repo}`;
+}
+async function hasSshAccess() {
+	try {
+		await execaCommand("ssh -T git@github.com -o StrictHostKeyChecking=no", { timeout: 1e4 });
+		return true;
+	} catch (error) {
+		return (error instanceof Error && "stderr" in error ? String(error.stderr) : "").includes("successfully authenticated");
+	}
+}
+function getUpstreamUrl(variant, useSsh) {
+	const repo = VARIANT_REPO_MAP[variant];
+	return useSsh ? sshUrl(repo) : httpsUrl(repo);
+}
+/**
+* Check if a remote URL points to the correct repo for the given variant,
+* regardless of whether it uses SSH or HTTPS.
+* Handles trailing `.git` and `/` in URLs.
+*/
+function isUpstreamUrlValid(url, variant) {
+	const normalized = url.replace(/\/+$/, "").replace(/\.git$/, "");
+	const repo = VARIANT_REPO_MAP[variant];
+	return normalized === sshUrl(repo) || normalized === httpsUrl(repo);
+}
+async function getUpstreamRemoteUrl() {
+	try {
+		const { stdout } = await execaCommand("git remote get-url upstream");
+		return stdout.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+async function setUpstreamRemote(url) {
+	if (await getUpstreamRemoteUrl()) await execaCommand(`git remote set-url upstream ${url}`);
+	else await execaCommand(`git remote add upstream ${url}`);
+}
+//#endregion
+//#region src/utils/create-project.ts
+async function createProject(options) {
+	const { variant, name, directory, githubToken } = options;
+	const projectPath = join(directory, name);
+	const repo = VARIANT_REPO_MAP[variant];
+	if (await fs.pathExists(projectPath)) throw new Error(`Target directory "${projectPath}" already exists. Choose a different name or remove it first.`);
+	if (!await fs.pathExists(directory)) throw new Error(`Parent directory "${directory}" does not exist.`);
+	let cloneUrl;
+	if (githubToken) cloneUrl = `https://${githubToken}@github.com/${repo}`;
+	else cloneUrl = await hasSshAccess() ? `git@github.com:${repo}` : `https://github.com/${repo}`;
+	await execa("git", [
+		"clone",
+		cloneUrl,
+		name
+	], { cwd: directory });
+	if (githubToken) await execa("git", [
+		"remote",
+		"set-url",
+		"origin",
+		`https://github.com/${repo}`
+	], { cwd: projectPath });
+	await execa("pnpm", ["install"], { cwd: projectPath });
+	await writeMarkerFile(projectPath, variant, repo);
+	return {
+		success: true,
+		projectPath,
+		variant,
+		kitRepo: repo,
+		message: `Project "${name}" created successfully with variant "${variant}".`
+	};
+}
+//#endregion
+//#region src/utils/list-variants.ts
+const VARIANT_CATALOG = [
+	{
+		id: "next-supabase",
+		name: "Next.js + Supabase",
+		description: "Full-stack SaaS kit with Next.js App Router and Supabase",
+		repo: VARIANT_REPO_MAP["next-supabase"],
+		tech: [
+			"Next.js",
+			"Supabase",
+			"Tailwind CSS",
+			"shadcn/ui"
+		],
+		database: "PostgreSQL (Supabase)",
+		auth: "Supabase Auth",
+		status: "stable"
+	},
+	{
+		id: "next-drizzle",
+		name: "Next.js + Drizzle",
+		description: "Full-stack SaaS kit with Next.js and Drizzle ORM",
+		repo: VARIANT_REPO_MAP["next-drizzle"],
+		tech: [
+			"Next.js",
+			"Drizzle",
+			"Tailwind CSS",
+			"shadcn/ui"
+		],
+		database: "PostgreSQL",
+		auth: "Better Auth",
+		status: "stable"
+	},
+	{
+		id: "next-prisma",
+		name: "Next.js + Prisma",
+		description: "Full-stack SaaS kit with Next.js and Prisma ORM",
+		repo: VARIANT_REPO_MAP["next-prisma"],
+		tech: [
+			"Next.js",
+			"Prisma",
+			"Tailwind CSS",
+			"shadcn/ui"
+		],
+		database: "PostgreSQL",
+		auth: "Better Auth",
+		status: "stable"
+	},
+	{
+		id: "react-router-supabase",
+		name: "React Router + Supabase",
+		description: "Full-stack SaaS kit with React Router and Supabase",
+		repo: VARIANT_REPO_MAP["react-router-supabase"],
+		tech: [
+			"React Router",
+			"Supabase",
+			"Tailwind CSS",
+			"shadcn/ui"
+		],
+		database: "PostgreSQL (Supabase)",
+		auth: "Supabase Auth",
+		status: "stable"
+	}
+];
+//#endregion
+//#region src/commands/new/new.command.ts
+const newCommand = new Command().name("new").description("Initialize a new Makerkit project").action(async () => {
+	const choices = VARIANT_CATALOG.map((v) => ({
+		title: v.name,
+		value: v.id
+	}));
+	const { kit, name: projectName } = await prompts([{
+		type: "select",
+		name: "kit",
+		message: `Select the ${chalk.cyan(`SaaS Kit`)} you want to clone`,
+		choices
+	}, {
+		type: "text",
+		name: "name",
+		message: `Enter your ${chalk.cyan("Project Name")}.`
+	}]);
+	const selected = VARIANT_CATALOG.find((v) => v.id === kit);
+	if (!selected) {
+		console.log("Invalid kit selection. Aborting...");
+		process.exit(1);
+	}
+	const { confirm } = await prompts([{
+		type: "confirm",
+		name: "confirm",
+		message: `Are you sure you want to clone ${chalk.cyan(selected.name)} to ${chalk.cyan(projectName)}?`
+	}]);
+	if (!confirm) {
+		console.log("Aborting...");
+		process.exit(0);
+	}
+	const spinner = ora(`Cloning ${selected.name}...`).start();
+	try {
+		const result = await createProject({
+			variant: selected.id,
+			name: projectName,
+			directory: process.cwd()
+		});
+		spinner.succeed(`${result.message}`);
+		console.log(`You can now get started. Open the project in your IDE and read the README.md file for more information.`);
+	} catch (e) {
+		console.error(e);
+		spinner.fail(`Failed to create project`);
+		process.exit(1);
+	}
+});
+//#endregion
+//#region src/utils/plugins-cache.ts
+const CACHE_DIR = join(homedir(), ".makerkit");
+const CACHE_FILE = join(CACHE_DIR, "plugins.json");
+const CACHE_TTL_MS = 3600 * 1e3;
+async function readCache() {
+	try {
+		if (!await fs.pathExists(CACHE_FILE)) return null;
+		return await fs.readJson(CACHE_FILE);
+	} catch {
+		return null;
+	}
+}
+async function writeCache(plugins) {
+	try {
+		await fs.ensureDir(CACHE_DIR);
+		await fs.writeJson(CACHE_FILE, {
+			fetchedAt: Date.now(),
+			plugins
+		}, { spaces: 2 });
+	} catch {}
+}
+async function fetchPluginRegistry(registryUrl, fallback) {
+	if (!registryUrl) return fallback;
+	const cached = await readCache();
+	if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) return cached.plugins;
+	try {
+		const response = await fetch(registryUrl);
+		if (response.ok) {
+			const plugins = (await response.json()).plugins;
+			await writeCache(plugins);
+			return plugins;
+		}
+	} catch {}
+	return cached?.plugins ?? fallback;
+}
+//#endregion
+//#region src/plugins-model.ts
+const DEFAULT_PLUGINS = {
+	feedback: {
+		name: "Feedback",
+		id: "feedback",
+		description: "Add a feedback popup to your site.",
+		postInstallMessage: "Run database migrations: pnpm db:migrate",
+		variants: { "next-supabase": {
+			envVars: [],
+			path: "packages/plugins/feedback"
+		} }
+	},
+	waitlist: {
+		name: "Waitlist",
+		id: "waitlist",
+		description: "Add a waitlist to your site.",
+		postInstallMessage: "Run database migrations: pnpm db:migrate",
+		variants: { "next-supabase": {
+			envVars: [],
+			path: "packages/plugins/waitlist"
+		} }
+	},
+	testimonial: {
+		name: "Testimonial",
+		id: "testimonial",
+		description: "Add a testimonial widget to your site.",
+		postInstallMessage: "Run database migrations: pnpm db:migrate",
+		variants: { "next-supabase": {
+			envVars: [],
+			path: "packages/plugins/testimonial"
+		} }
+	},
+	roadmap: {
+		name: "Roadmap",
+		id: "roadmap",
+		description: "Add a roadmap to your site.",
+		postInstallMessage: "Run database migrations: pnpm db:migrate",
+		variants: { "next-supabase": {
+			envVars: [],
+			path: "packages/plugins/roadmap"
+		} }
+	},
+	"google-analytics": {
+		name: "Google Analytics",
+		id: "google-analytics",
+		description: "Add Google Analytics to your site.",
+		variants: {
+			"next-supabase": {
+				envVars: [{
+					key: "NEXT_PUBLIC_GOOGLE_ANALYTICS_ID",
+					description: "Google Analytics Measurement ID"
+				}],
+				path: "packages/plugins/analytics/google-analytics"
+			},
+			"next-drizzle": {
+				envVars: [{
+					key: "NEXT_PUBLIC_GOOGLE_ANALYTICS_ID",
+					description: "Google Analytics Measurement ID"
+				}],
+				path: "packages/plugins/analytics/google-analytics"
+			},
+			"next-prisma": {
+				envVars: [{
+					key: "NEXT_PUBLIC_GOOGLE_ANALYTICS_ID",
+					description: "Google Analytics Measurement ID"
+				}],
+				path: "packages/plugins/analytics/google-analytics"
+			}
+		}
+	},
+	honeybadger: {
+		name: "Honeybadger",
+		id: "honeybadger",
+		description: "Add Honeybadger Error Tracking to your site.",
+		variants: {
+			"next-supabase": {
+				envVars: [
+					{
+						key: "HONEYBADGER_API_KEY",
+						description: "Honeybadger private API key"
+					},
+					{
+						key: "NEXT_PUBLIC_HONEYBADGER_ENVIRONMENT",
+						description: "Honeybadger environment"
+					},
+					{
+						key: "NEXT_PUBLIC_HONEYBADGER_REVISION",
+						description: "Honeybadger log revision"
+					}
+				],
+				path: "packages/plugins/honeybadger"
+			},
+			"next-drizzle": {
+				envVars: [
+					{
+						key: "HONEYBADGER_API_KEY",
+						description: "Honeybadger private API key"
+					},
+					{
+						key: "NEXT_PUBLIC_HONEYBADGER_ENVIRONMENT",
+						description: "Honeybadger environment"
+					},
+					{
+						key: "NEXT_PUBLIC_HONEYBADGER_REVISION",
+						description: "Honeybadger log revision"
+					}
+				],
+				path: "packages/plugins/honeybadger"
+			},
+			"next-prisma": { envVars: [
+				{
+					key: "HONEYBADGER_API_KEY",
+					description: "Honeybadger private API key"
+				},
+				{
+					key: "NEXT_PUBLIC_HONEYBADGER_ENVIRONMENT",
+					description: "Honeybadger environment"
+				},
+				{
+					key: "NEXT_PUBLIC_HONEYBADGER_REVISION",
+					description: "Honeybadger log revision"
+				}
+			] }
+		}
+	},
+	posthog: {
+		name: "PostHog",
+		id: "posthog",
+		description: "Add PostHog Analytics to your site.",
+		variants: {
+			"next-supabase": {
+				envVars: [{
+					key: "NEXT_PUBLIC_POSTHOG_KEY",
+					description: "PostHog project API key"
+				}, {
+					key: "NEXT_PUBLIC_POSTHOG_HOST",
+					description: "PostHog host URL",
+					defaultValue: "https://app.posthog.com"
+				}],
+				path: "packages/plugins/analytics/posthog"
+			},
+			"next-drizzle": {
+				envVars: [{
+					key: "NEXT_PUBLIC_POSTHOG_KEY",
+					description: "PostHog project API key"
+				}, {
+					key: "NEXT_PUBLIC_POSTHOG_HOST",
+					description: "PostHog host URL",
+					defaultValue: "https://app.posthog.com"
+				}],
+				path: "packages/plugins/analytics/posthog"
+			},
+			"next-prisma": {
+				envVars: [{
+					key: "NEXT_PUBLIC_POSTHOG_KEY",
+					description: "PostHog project API key"
+				}, {
+					key: "NEXT_PUBLIC_POSTHOG_HOST",
+					description: "PostHog host URL",
+					defaultValue: "https://app.posthog.com"
+				}],
+				path: "packages/plugins/analytics/posthog"
+			}
+		}
+	},
+	umami: {
+		name: "Umami",
+		id: "umami",
+		description: "Add Umami Analytics to your site.",
+		variants: {
+			"next-supabase": {
+				envVars: [{
+					key: "NEXT_PUBLIC_UMAMI_WEBSITE_ID",
+					description: "Umami website ID"
+				}, {
+					key: "NEXT_PUBLIC_UMAMI_HOST",
+					description: "Umami host URL"
+				}],
+				path: "packages/plugins/analytics/umami"
+			},
+			"next-drizzle": {
+				envVars: [{
+					key: "NEXT_PUBLIC_UMAMI_WEBSITE_ID",
+					description: "Umami website ID"
+				}, {
+					key: "NEXT_PUBLIC_UMAMI_HOST",
+					description: "Umami host URL"
+				}],
+				path: "packages/plugins/analytics/umami"
+			},
+			"next-prisma": {
+				envVars: [{
+					key: "NEXT_PUBLIC_UMAMI_WEBSITE_ID",
+					description: "Umami website ID"
+				}, {
+					key: "NEXT_PUBLIC_UMAMI_HOST",
+					description: "Umami host URL"
+				}],
+				path: "packages/plugins/analytics/umami"
+			}
+		}
+	},
+	signoz: {
+		name: "SigNoz",
+		id: "signoz",
+		description: "Add SigNoz Monitoring to your app.",
+		variants: {
+			"next-supabase": {
+				envVars: [{
+					key: "OTEL_EXPORTER_OTLP_ENDPOINT",
+					description: "SigNoz OTLP endpoint URL"
+				}],
+				path: "packages/plugins/signoz"
+			},
+			"next-drizzle": {
+				envVars: [{
+					key: "OTEL_EXPORTER_OTLP_ENDPOINT",
+					description: "SigNoz OTLP endpoint URL"
+				}],
+				path: "packages/plugins/signoz"
+			},
+			"next-prisma": {
+				envVars: [{
+					key: "OTEL_EXPORTER_OTLP_ENDPOINT",
+					description: "SigNoz OTLP endpoint URL"
+				}],
+				path: "packages/plugins/signoz"
+			}
+		}
+	},
+	paddle: {
+		name: "Paddle",
+		id: "paddle",
+		description: "Add Paddle Billing to your app.",
+		variants: { "next-supabase": {
+			envVars: [
+				{
+					key: "NEXT_PUBLIC_PADDLE_CLIENT_TOKEN",
+					description: "Paddle client-side token"
+				},
+				{
+					key: "PADDLE_API_KEY",
+					description: "Paddle API key"
+				},
+				{
+					key: "PADDLE_WEBHOOK_SECRET",
+					description: "Paddle webhook secret"
+				}
+			],
+			path: "packages/plugins/paddle"
+		} }
+	},
+	"supabase-cms": {
+		name: "Supabase CMS",
+		id: "supabase-cms",
+		description: "Add Supabase CMS provider to your app.",
+		postInstallMessage: "Run database migrations: pnpm db:migrate",
+		variants: { "next-supabase": {
+			envVars: [],
+			path: "packages/plugins/supabase-cms"
+		} }
+	},
+	"meshes-analytics": {
+		name: "Meshes Analytics",
+		id: "meshes-analytics",
+		description: "Add Meshes Analytics to your app.",
+		variants: { "next-supabase": {
+			envVars: [{
+				key: "NEXT_PUBLIC_MESHES_PUBLISHABLE_KEY",
+				description: "The Meshes publishable key"
+			}],
+			path: "packages/plugins/meshes-analytics"
+		} }
+	},
+	directus: {
+		name: "Directus CMS",
+		id: "directus",
+		description: "Add Directus as your CMS.",
+		variants: {
+			"next-supabase": {
+				envVars: [{
+					key: "NEXT_PUBLIC_DIRECTUS_URL",
+					description: "The Directus URL"
+				}, {
+					key: "DIRECTUS_ACCESS_TOKEN",
+					description: "The Directus access token"
+				}],
+				path: "packages/plugins/directus"
+			},
+			"next-drizzle": {
+				envVars: [{
+					key: "NEXT_PUBLIC_DIRECTUS_URL",
+					description: "The Directus URL"
+				}, {
+					key: "DIRECTUS_ACCESS_TOKEN",
+					description: "The Directus access token"
+				}],
+				path: "packages/plugins/directus"
+			},
+			"next-prisma": {
+				envVars: [{
+					key: "NEXT_PUBLIC_DIRECTUS_URL",
+					description: "The Directus URL"
+				}, {
+					key: "DIRECTUS_ACCESS_TOKEN",
+					description: "The Directus access token"
+				}],
+				path: "packages/plugins/directus"
+			}
+		}
+	}
+};
+var PluginRegistry = class PluginRegistry {
+	constructor(plugins) {
+		this.plugins = plugins;
+	}
+	static async load() {
+		const registryUrl = process.env.MAKERKIT_PLUGINS_REGISTRY_URL;
+		return new PluginRegistry(await fetchPluginRegistry(registryUrl, DEFAULT_PLUGINS));
+	}
+	getPluginById(id) {
+		return this.plugins[id];
+	}
+	getPluginsForVariant(variant) {
+		return Object.values(this.plugins).filter((p) => variant in p.variants);
+	}
+	validatePlugin(pluginId, variant) {
+		const plugin = this.getPluginById(pluginId);
+		invariant(plugin, `Plugin "${pluginId}" not found`);
+		invariant(plugin.variants[variant], `Plugin "${pluginId}" is not available for the ${variant} variant`);
+		return plugin;
+	}
+};
+function getEnvVars(plugin, variant) {
+	return plugin.variants[variant]?.envVars ?? [];
+}
+function getPath(plugin, variant) {
+	return plugin.variants[variant]?.path;
+}
+async function isInstalled(plugin, variant) {
+	const pluginPath = getPath(plugin, variant);
+	if (!pluginPath) return false;
+	const pkgJsonPath = join(process.cwd(), pluginPath, "package.json");
+	if (!await fs.pathExists(pkgJsonPath)) return false;
+	try {
+		const pkg = await fs.readJson(pkgJsonPath);
+		return !!pkg.name && !!pkg.exports;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/utils/base-store.ts
+function basesDir(pluginId) {
+	return join(process.cwd(), "node_modules", ".cache", "makerkit", "bases", pluginId);
+}
+async function saveBaseVersions(pluginId, files) {
+	const dir = basesDir(pluginId);
+	for (const file of files) {
+		const targetPath = join(dir, file.target);
+		await fs.ensureDir(dirname(targetPath));
+		await fs.writeFile(targetPath, file.content);
+	}
+}
+//#endregion
+//#region src/utils/git.ts
+function getErrorOutput(error) {
+	if (error instanceof Error && "stderr" in error) {
+		const stderr = String(error.stderr);
+		if (stderr) return stderr;
+	}
+	if (error instanceof Error && "stdout" in error) {
+		const stdout = String(error.stdout);
+		if (stdout) return stdout;
+	}
+	return error instanceof Error ? error.message : String(error);
+}
+async function isGitClean() {
+	const { stdout } = await execaCommand("git status --porcelain");
+	return stdout.trim() === "";
+}
+async function getGitUsername() {
+	try {
+		const { stdout } = await execaCommand("git config --get user.username");
+		const username = stdout.trim();
+		return username.length > 0 ? username : void 0;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/utils/install-registry-files.ts
+async function fetchRegistryItem(variant, pluginId, username, majorVersion) {
+	const url = `https://makerkit.dev/r/${variant}${majorVersion != null ? `/v${majorVersion}` : ""}/${pluginId}.json?username=${username}`;
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to fetch plugin registry for "${pluginId}" (${response.status}): ${response.statusText}`);
+	const item = await response.json();
+	if (!item.files || item.files.length === 0) throw new Error(`Plugin "${pluginId}" has no files in the registry.`);
+	return item;
+}
+async function installRegistryFiles(variant, pluginId, username, majorVersion) {
+	const item = await fetchRegistryItem(variant, pluginId, username, majorVersion);
+	const cwd = process.cwd();
+	for (const file of item.files) {
+		const targetPath = join(cwd, file.target);
+		await fs.ensureDir(dirname(targetPath));
+		await fs.writeFile(targetPath, file.content);
+	}
+	return item;
+}
+//#endregion
+//#region src/utils/run-codemod.ts
+const CODEMOD_TIMEOUT_MS = 300 * 1e3;
+async function runCodemod(variant, pluginId, codemodVersion, options) {
+	try {
+		const localPath = process.env.MAKERKIT_CODEMODS_PATH;
+		const runner = process.env.MAKERKIT_PACKAGE_RUNNER ?? "npx --yes";
+		const versionTag = codemodVersion ? `@${codemodVersion}` : "";
+		const { stdout, stderr } = await execaCommand(localPath ? `${runner} codemod workflow run --allow-dirty -w ${localPath}/codemods/${variant}/${pluginId}` : `${runner} codemod --allow-dirty @makerkit/${variant}-${pluginId}${versionTag}`, {
+			stdio: options?.captureOutput ? "pipe" : "inherit",
+			timeout: CODEMOD_TIMEOUT_MS
+		});
+		return {
+			success: true,
+			output: stdout || stderr || ""
+		};
+	} catch (error) {
+		let message = "Unknown error during codemod";
+		if (error instanceof Error) {
+			message = error.message;
+			if ("stderr" in error && error.stderr) message += `\n${error.stderr}`;
+			if ("timedOut" in error && error.timedOut) message = `Codemod timed out after ${CODEMOD_TIMEOUT_MS / 1e3}s (the workflow engine may have stalled after an error)`;
+		}
+		return {
+			success: false,
+			output: message
+		};
+	}
+}
+//#endregion
+//#region src/utils/username-cache.ts
+const USERNAME_FILE = join(tmpdir(), "makerkit-username");
+function getCachedUsername() {
+	try {
+		const username = fs.readFileSync(USERNAME_FILE, "utf-8").trim();
+		return username.length > 0 ? username : void 0;
+	} catch {
+		return;
+	}
+}
+function cacheUsername(username) {
+	fs.writeFileSync(USERNAME_FILE, username, "utf-8");
+}
+function clearCachedUsername() {
+	try {
+		fs.removeSync(USERNAME_FILE);
+	} catch {}
+}
+async function promptForUsername() {
+	const username = (await prompts({
+		type: "text",
+		name: "githubUsername",
+		message: "Enter the GitHub username registered with your Makerkit account",
+		initial: await getGitUsername(),
+		validate: (value) => {
+			return value.trim().length > 0 ? true : "GitHub username is required";
+		}
+	})).githubUsername?.trim();
+	if (!username) throw new Error("Setup cancelled. GitHub username is required.");
+	cacheUsername(username);
+	return username;
+}
+async function getOrPromptUsername(providedUsername) {
+	if (providedUsername?.trim()) {
+		const username = providedUsername.trim();
+		cacheUsername(username);
+		return username;
+	}
+	const cached = getCachedUsername();
+	if (cached) return cached;
+	return promptForUsername();
+}
+//#endregion
+//#region src/utils/workspace.ts
+async function readDeps(pkgPath) {
+	if (!await fs.pathExists(pkgPath)) return {};
+	const pkg = await fs.readJson(pkgPath);
+	return {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+}
+async function detectVariant() {
+	const cwd = process.cwd();
+	const rootPkgPath = join(cwd, "package.json");
+	if (!await fs.pathExists(rootPkgPath)) throw new Error("No package.json found. Please run this command from a MakerKit project root.");
+	if (!(await readDeps(rootPkgPath))["turbo"]) throw new Error("This does not appear to be a MakerKit Turbo monorepo. The \"turbo\" dependency was not found in package.json.");
+	const webDeps = await readDeps(join(cwd, "apps", "web", "package.json"));
+	const dbDeps = await readDeps(join(cwd, "packages", "database", "package.json"));
+	const hasSupabase = !!webDeps["@supabase/supabase-js"];
+	const hasReactRouter = !!webDeps["@react-router/node"];
+	const hasDrizzle = !!webDeps["drizzle-orm"] || !!dbDeps["drizzle-orm"];
+	const hasPrisma = !!webDeps["@prisma/client"] || !!dbDeps["@prisma/client"];
+	if (hasReactRouter && hasSupabase) return "react-router-supabase";
+	if (hasSupabase) return "next-supabase";
+	if (hasDrizzle) return "next-drizzle";
+	if (hasPrisma) return "next-prisma";
+	throw new Error("Unrecognized MakerKit project. Could not detect variant from dependencies.");
+}
+async function validateProject() {
+	const variant = await detectVariant();
+	const version = (await fs.readJson(join(process.cwd(), "package.json"))).version ?? "unknown";
+	const major = parseInt(version.split(".")[0], 10);
+	return {
+		variant,
+		version,
+		majorVersion: isNaN(major) ? void 0 : major
+	};
+}
+//#endregion
+//#region src/utils/add-plugin.ts
+async function addPlugin(options) {
+	if (!options.skipGitCheck) {
+		if (!await isGitClean()) return {
+			success: false,
+			reason: "Git working directory has uncommitted changes. Please commit or stash them before adding a plugin."
+		};
+	}
+	const { variant, majorVersion } = await validateProject();
+	const username = options.githubUsername?.trim() || getCachedUsername();
+	if (!username) return {
+		success: false,
+		reason: "No GitHub username cached and none provided. Call makerkit_init_registry first or pass githubUsername."
+	};
+	cacheUsername(username);
+	const plugin = (await PluginRegistry.load()).validatePlugin(options.pluginId, variant);
+	if (await isInstalled(plugin, variant)) return {
+		success: false,
+		reason: `Plugin "${plugin.name}" is already installed.`
+	};
+	const item = await installRegistryFiles(variant, options.pluginId, username, majorVersion);
+	await saveBaseVersions(options.pluginId, item.files);
+	const codemodResult = await runCodemod(variant, options.pluginId, item.codemodVersion, { captureOutput: options.captureCodemodOutput ?? true });
+	const envVars = getEnvVars(plugin, variant);
+	return {
+		success: true,
+		pluginName: plugin.name,
+		pluginId: plugin.id,
+		variant,
+		envVars: envVars.map((e) => ({
+			key: e.key,
+			description: e.description
+		})),
+		postInstallMessage: plugin.postInstallMessage ?? null,
+		codemodOutput: codemodResult.output,
+		codemodWarning: codemodResult.success ? void 0 : `The automated codemod did not complete successfully. Plugin files were installed but some wiring steps may have failed.\n${codemodResult.output}`
+	};
+}
+//#endregion
+//#region src/utils/list-plugins.ts
+async function listPlugins(options) {
+	const variant = await detectVariant();
+	const plugins = (await PluginRegistry.load()).getPluginsForVariant(variant);
+	return {
+		variant,
+		plugins: await Promise.all(plugins.map(async (p) => ({
+			id: p.id,
+			name: p.name,
+			description: p.description,
+			installed: await isInstalled(p, variant),
+			envVars: getEnvVars(p, variant).map((e) => e.key),
+			postInstallMessage: p.postInstallMessage ?? null
+		})))
+	};
+}
+//#endregion
+//#region src/commands/plugins/add/add.command.ts
+function createAddCommand(parentCommand) {
+	return parentCommand.command("add").argument("[plugin-id...]", "Plugins to install (e.g. feedback waitlist)").description("Install one or more MakerKit plugins.").action(async (pluginIds) => {
+		try {
+			if (!await isGitClean()) {
+				console.error(chalk.red("Your git working directory has uncommitted changes. Please commit or stash them before adding a plugin."));
+				process.exit(1);
+			}
+			if (!pluginIds || pluginIds.length === 0) {
+				const available = (await listPlugins({ projectPath: process.cwd() })).plugins.filter((p) => !p.installed);
+				if (available.length === 0) {
+					console.log(chalk.green("All plugins are already installed."));
+					return;
+				}
+				pluginIds = (await prompts({
+					type: "multiselect",
+					name: "pluginIds",
+					message: "Select plugins to install",
+					choices: available.map((p) => ({
+						title: `${p.name} ${chalk.gray(`(${p.id})`)}`,
+						value: p.id
+					}))
+				})).pluginIds ?? [];
+				if (pluginIds.length === 0) return;
+			}
+			let username = await getOrPromptUsername();
+			for (const pluginId of pluginIds) {
+				console.log(`\nInstalling ${chalk.cyan(pluginId)}...\n`);
+				const filesSpinner = ora("Installing plugin...").start();
+				let result;
+				try {
+					result = await addPlugin({
+						projectPath: process.cwd(),
+						pluginId,
+						githubUsername: username,
+						skipGitCheck: true,
+						captureCodemodOutput: false
+					});
+				} catch (error) {
+					filesSpinner.fail("Failed to install plugin.");
+					clearCachedUsername();
+					console.log(chalk.yellow("\nRetrying with a different username...\n"));
+					username = await getOrPromptUsername();
+					const retrySpinner = ora("Installing plugin...").start();
+					try {
+						result = await addPlugin({
+							projectPath: process.cwd(),
+							pluginId,
+							githubUsername: username,
+							skipGitCheck: true,
+							captureCodemodOutput: false
+						});
+					} catch (retryError) {
+						retrySpinner.fail("Failed to install plugin.");
+						const message = retryError instanceof Error ? retryError.message : "Unknown error";
+						console.error(chalk.red(`\nError installing "${pluginId}": ${message}`));
+						console.log(chalk.yellow("\nTo revert changes, run: git checkout . && git clean -fd"));
+						process.exit(1);
+					}
+					if (result.success) retrySpinner.succeed("Plugin installed.");
+					else retrySpinner.stop();
+				}
+				if (!result.success) {
+					if (result.reason.includes("already installed")) {
+						filesSpinner.warn(result.reason + " Skipping.");
+						continue;
+					}
+					filesSpinner.fail("Failed to install plugin.");
+					console.error(chalk.red(`\n${result.reason}`));
+					console.log(chalk.yellow("\nTo revert changes, run: git checkout . && git clean -fd"));
+					process.exit(1);
+				}
+				if (result.codemodWarning) {
+					filesSpinner.warn(`${result.pluginName} installed with warnings — some automated steps may not have completed.`);
+					console.log(chalk.yellow(`\n${result.codemodWarning}`));
+					console.log(chalk.yellow("\nPlugin files were written successfully. Review the changes with `git diff` and complete any missing steps manually."));
+				} else if (filesSpinner.isSpinning) filesSpinner.succeed(`${result.pluginName} installed successfully!`);
+				if (result.envVars.length > 0) {
+					console.log(chalk.white("\nEnvironment variables to configure:"));
+					for (const envVar of result.envVars) console.log(`  ${chalk.cyan(envVar.key)} - ${envVar.description}`);
+				}
+				if (result.postInstallMessage) {
+					console.log(chalk.white("\nNext steps:"));
+					console.log(`  ${chalk.cyan(result.postInstallMessage)}`);
+				}
+			}
+			console.log("");
+			console.log(chalk.yellow("Important:"));
+			console.log(chalk.yellow("  This plugin was installed using an automated migration."));
+			console.log(chalk.yellow("  Please review the changes manually and test thoroughly before committing."));
+			console.log("");
+			console.log(chalk.white("Tips:"));
+			console.log(`  ${chalk.gray("-")} Run ${chalk.cyan("git diff")} to review all changes made by the migration.`);
+			console.log(`  ${chalk.gray("-")} Use an AI assistant (e.g. Claude) as a first pass to review the diff for issues.`);
+			console.log(`  ${chalk.gray("-")} Run your test suite and verify the app builds before committing.`);
+			console.log(`  ${chalk.gray("-")} To undo all changes: ${chalk.cyan("git checkout . && git clean -fd")}`);
+			console.log("");
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Error: ${message}`));
+			console.log(chalk.yellow("\nTo revert changes, run: git checkout . && git clean -fd"));
+			process.exit(1);
+		}
+	});
+}
+//#endregion
+//#region src/commands/plugins/diff/diff.command.ts
+function createDiffCommand(parentCommand) {
+	return parentCommand.command("diff").argument("[plugin-id]", "Plugin to diff (e.g. feedback, waitlist)").description("Show differences between installed plugin files and the latest registry version.").action(async (pluginId) => {
+		try {
+			const { variant, majorVersion } = await validateProject();
+			const registry = await PluginRegistry.load();
+			if (!pluginId) {
+				const plugins = registry.getPluginsForVariant(variant);
+				const installed = [];
+				for (const p of plugins) if (await isInstalled(p, variant)) installed.push(p);
+				if (installed.length === 0) {
+					console.log(chalk.yellow("No plugins installed."));
+					return;
+				}
+				pluginId = (await prompts({
+					type: "select",
+					name: "pluginId",
+					message: "Select a plugin to diff",
+					choices: installed.map((p) => ({
+						title: `${p.name} ${chalk.gray(`(${p.id})`)}`,
+						value: p.id
+					}))
+				})).pluginId;
+				if (!pluginId) return;
+			}
+			const plugin = registry.validatePlugin(pluginId, variant);
+			if (!await isInstalled(plugin, variant)) {
+				console.error(chalk.yellow(`Plugin "${plugin.name}" is not installed.`));
+				return;
+			}
+			const username = await getOrPromptUsername();
+			const spinner = ora("Fetching latest plugin files...").start();
+			const item = await fetchRegistryItem(variant, pluginId, username, majorVersion);
+			spinner.succeed("Fetched latest plugin files.");
+			const tempDir = join(tmpdir(), `makerkit-diff-${pluginId}`);
+			await fs.ensureDir(tempDir);
+			try {
+				const cwd = process.cwd();
+				let hasDiff = false;
+				for (const file of item.files) {
+					const localPath = join(cwd, file.target);
+					const remotePath = join(tempDir, file.target);
+					await fs.ensureDir(dirname(join(tempDir, file.target)));
+					await fs.writeFile(remotePath, file.content);
+					if (!await fs.pathExists(localPath)) {
+						console.log(chalk.green(`\nNew file: ${file.target}`));
+						hasDiff = true;
+						continue;
+					}
+					if (await fs.readFile(localPath, "utf-8") !== file.content) {
+						hasDiff = true;
+						console.log(chalk.white(`\n--- ${file.target}`));
+						await execa("git", [
+							"diff",
+							"--no-index",
+							"--color",
+							"--",
+							localPath,
+							remotePath
+						], {
+							stdio: "inherit",
+							reject: false
+						});
+					}
+				}
+				if (!hasDiff) console.log(chalk.green(`\n${plugin.name} is up to date.`));
+			} finally {
+				await fs.remove(tempDir);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Error: ${message}`));
+			process.exit(1);
+		}
+	});
+}
+//#endregion
+//#region src/utils/init-registry.ts
+async function initRegistry(options) {
+	const variant = await detectVariant();
+	cacheUsername(options.githubUsername);
+	return {
+		success: true,
+		variant,
+		username: options.githubUsername
+	};
+}
+//#endregion
+//#region src/commands/plugins/init/init.command.ts
+function createInitCommand(parentCommand) {
+	return parentCommand.command("init").description("Initialize MakerKit plugin registry in your project (one-time setup).").action(async () => {
+		try {
+			const username = await getOrPromptUsername();
+			const initResult = await initRegistry({
+				projectPath: process.cwd(),
+				githubUsername: username
+			});
+			console.log(`Detected project variant: ${chalk.cyan(initResult.variant)}\n`);
+			console.log(chalk.green("Registry configured.\n"));
+			const pluginsResult = await listPlugins({ projectPath: process.cwd() });
+			console.log(chalk.white("Available plugins:\n"));
+			for (const plugin of pluginsResult.plugins) console.log(`  ${chalk.green(plugin.name)} ${chalk.gray(`(${plugin.id})`)}`);
+			console.log(`\nRun ${chalk.cyan("makerkit plugins add <plugin-id>")} to install a plugin.`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Error: ${message}`));
+			process.exit(1);
+		}
+	});
+}
+//#endregion
+//#region src/commands/plugins/list/list-plugins.command.ts
+function createListPluginsCommand(parentCommand) {
+	return parentCommand.command("list").description("List available and installed plugins.").action(async () => {
+		const result = await listPlugins({ projectPath: process.cwd() });
+		console.log(chalk.white(`MakerKit Plugins ${chalk.gray(`(${result.variant})`)}\n`));
+		console.log(`  ${chalk.green("Plugin Name")} ${chalk.gray("(plugin-id)")} — Status\n`);
+		let installedCount = 0;
+		for (const plugin of result.plugins) {
+			if (plugin.installed) installedCount++;
+			const status = plugin.installed ? chalk.green("installed") : chalk.gray("available");
+			console.log(`  ${chalk.cyan(plugin.name)} ${chalk.gray(`(${plugin.id})`)} — ${status}`);
+		}
+		console.log(`\n  ${chalk.white(`${installedCount} installed`)} / ${chalk.gray(`${result.plugins.length} available`)}\n`);
+		if (installedCount === 0) console.log(`Run ${chalk.cyan("makerkit plugins init")} to set up the registry, then ${chalk.cyan("makerkit plugins add <plugin-id>")} to install.`);
+	});
+}
+//#endregion
+//#region src/commands/plugins/outdated/outdated.command.ts
+async function isOutdated(plugin, variant, username) {
+	const item = await fetchRegistryItem(variant, plugin.id, username);
+	const cwd = process.cwd();
+	for (const file of item.files) {
+		const localPath = join(cwd, file.target);
+		if (!await fs.pathExists(localPath)) return true;
+		if (await fs.readFile(localPath, "utf-8") !== file.content) return true;
+	}
+	return false;
+}
+function createOutdatedCommand(parentCommand) {
+	return parentCommand.command("outdated").description("Check installed plugins for updates.").action(async () => {
+		try {
+			const { variant } = await validateProject();
+			const plugins = (await PluginRegistry.load()).getPluginsForVariant(variant);
+			const installed = [];
+			for (const p of plugins) if (await isInstalled(p, variant)) installed.push(p);
+			if (installed.length === 0) {
+				console.log(chalk.yellow("No plugins installed."));
+				return;
+			}
+			const username = await getOrPromptUsername();
+			const spinner = ora(`Checking ${installed.length} plugin${installed.length > 1 ? "s" : ""} for updates...`).start();
+			const outdated = [];
+			for (const plugin of installed) try {
+				if (await isOutdated(plugin, variant, username)) outdated.push(plugin);
+			} catch {}
+			spinner.stop();
+			if (outdated.length === 0) {
+				console.log(chalk.green("All plugins are up to date."));
+				return;
+			}
+			console.log(chalk.yellow(`\n${outdated.length} plugin${outdated.length > 1 ? "s have" : " has"} updates available:\n`));
+			for (const plugin of outdated) {
+				const pluginPath = getPath(plugin, variant);
+				console.log(`  ${chalk.cyan(plugin.name)} ${chalk.gray(`(${plugin.id})`)}${pluginPath ? chalk.gray(` — ${pluginPath}`) : ""}`);
+			}
+			console.log(`\nRun ${chalk.cyan("makerkit plugins diff <plugin-id>")} to see what changed.`);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Error: ${message}`));
+			process.exit(1);
+		}
+	});
+}
+//#endregion
+//#region src/commands/plugins/update/update.command.ts
+function createUpdateCommand(parentCommand) {
+	return parentCommand.command("update").argument("[plugin-id...]", "Plugins to update (e.g. feedback waitlist)").description("Update installed plugins to the latest registry version.").action(async (pluginIds) => {
+		try {
+			const { variant, majorVersion } = await validateProject();
+			const registry = await PluginRegistry.load();
+			if (!pluginIds || pluginIds.length === 0) {
+				const plugins = registry.getPluginsForVariant(variant);
+				const installed = [];
+				for (const p of plugins) if (await isInstalled(p, variant)) installed.push(p);
+				if (installed.length === 0) {
+					console.log(chalk.yellow("No plugins installed."));
+					return;
+				}
+				pluginIds = (await prompts({
+					type: "multiselect",
+					name: "pluginIds",
+					message: "Select plugins to update",
+					choices: installed.map((p) => ({
+						title: `${p.name} ${chalk.gray(`(${p.id})`)}`,
+						value: p.id
+					}))
+				})).pluginIds ?? [];
+				if (pluginIds.length === 0) return;
+			}
+			const username = await getOrPromptUsername();
+			for (const pluginId of pluginIds) {
+				const plugin = registry.validatePlugin(pluginId, variant);
+				if (!await isInstalled(plugin, variant)) {
+					console.log(chalk.yellow(`Plugin "${plugin.name}" is not installed. Use "plugins add ${pluginId}" to install it.`));
+					continue;
+				}
+				const spinner = ora(`Fetching latest ${plugin.name} files...`).start();
+				const item = await fetchRegistryItem(variant, pluginId, username, majorVersion);
+				spinner.succeed(`Fetched latest ${plugin.name} files.`);
+				const cwd = process.cwd();
+				const modifiedFiles = [];
+				for (const file of item.files) {
+					const localPath = join(cwd, file.target);
+					if (await fs.pathExists(localPath)) {
+						if (await fs.readFile(localPath, "utf-8") !== file.content) modifiedFiles.push(file.target);
+					}
+				}
+				if (modifiedFiles.length === 0) {
+					console.log(chalk.green(`${plugin.name} is already up to date.`));
+					continue;
+				}
+				console.log(chalk.yellow(`\n${modifiedFiles.length} file${modifiedFiles.length > 1 ? "s" : ""} will be overwritten:`));
+				for (const file of modifiedFiles) console.log(`  ${chalk.gray(file)}`);
+				const { confirm } = await prompts({
+					type: "confirm",
+					name: "confirm",
+					message: `Update ${plugin.name}? Local changes will be lost.`,
+					initial: false
+				});
+				if (!confirm) {
+					console.log(chalk.gray(`Skipped ${plugin.name}.`));
+					continue;
+				}
+				const writeSpinner = ora(`Updating ${plugin.name}...`).start();
+				for (const file of item.files) {
+					const targetPath = join(cwd, file.target);
+					await fs.ensureDir(dirname(targetPath));
+					await fs.writeFile(targetPath, file.content);
+				}
+				await saveBaseVersions(pluginId, item.files);
+				writeSpinner.succeed(`${plugin.name} updated.`);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Error: ${message}`));
+			process.exit(1);
+		}
+	});
+}
+//#endregion
+//#region src/commands/plugins/plugins.command.ts
+const pluginsCommand = new Command().name("plugins").description("Manage MakerKit plugins.");
+createInitCommand(pluginsCommand);
+createAddCommand(pluginsCommand);
+createUpdateCommand(pluginsCommand);
+createDiffCommand(pluginsCommand);
+createOutdatedCommand(pluginsCommand);
+createListPluginsCommand(pluginsCommand);
+//#endregion
+//#region src/utils/project-pull.ts
+async function projectPull(options) {
+	const { variant } = await validateProject();
+	if (!await isGitClean()) return {
+		success: false,
+		reason: "Git working directory has uncommitted changes. Please commit or stash them before pulling upstream updates."
+	};
+	let currentUrl = await getUpstreamRemoteUrl();
+	if (!currentUrl) {
+		const url = getUpstreamUrl(variant, await hasSshAccess());
+		await setUpstreamRemote(url);
+		currentUrl = url;
+	} else if (!isUpstreamUrlValid(currentUrl, variant)) {
+		const expectedUrl = getUpstreamUrl(variant, currentUrl.startsWith("git@"));
+		return {
+			success: false,
+			reason: `Upstream remote points to "${currentUrl}" but expected "${expectedUrl}" for variant "${variant}". Please ask the user whether to update the upstream URL, then run: git remote set-url upstream <correct-url>`
+		};
+	}
+	await execaCommand("git fetch upstream");
+	try {
+		const { stdout } = await execaCommand("git merge upstream/main --no-edit");
+		const alreadyUpToDate = stdout.includes("Already up to date");
+		return {
+			success: true,
+			variant,
+			upstreamUrl: currentUrl,
+			alreadyUpToDate,
+			message: alreadyUpToDate ? "Already up to date." : "Successfully merged upstream changes."
+		};
+	} catch (mergeError) {
+		const output = getErrorOutput(mergeError);
+		if (!(output.includes("CONFLICT") || output.includes("Automatic merge failed"))) throw new Error(`Merge failed: ${output}`);
+		const { stdout: statusOutput } = await execaCommand("git diff --name-only --diff-filter=U");
+		const conflictPaths = statusOutput.trim().split("\n").filter(Boolean);
+		const cwd = process.cwd();
+		const conflicts = await Promise.all(conflictPaths.map(async (filePath) => {
+			let conflicted;
+			try {
+				conflicted = await fs.readFile(join(cwd, filePath), "utf-8");
+			} catch {
+				conflicted = void 0;
+			}
+			let base;
+			let ours;
+			let theirs;
+			try {
+				const { stdout: b } = await execa("git", ["show", `:1:${filePath}`]);
+				base = b;
+			} catch {
+				base = void 0;
+			}
+			try {
+				const { stdout: o } = await execa("git", ["show", `:2:${filePath}`]);
+				ours = o;
+			} catch {
+				ours = void 0;
+			}
+			try {
+				const { stdout: t } = await execa("git", ["show", `:3:${filePath}`]);
+				theirs = t;
+			} catch {
+				theirs = void 0;
+			}
+			return {
+				path: filePath,
+				conflicted,
+				base,
+				ours,
+				theirs
+			};
+		}));
+		return {
+			success: false,
+			variant,
+			upstreamUrl: currentUrl,
+			hasConflicts: true,
+			conflictCount: conflicts.length,
+			conflicts,
+			instructions: "Merge conflicts detected. For each conflict: review base, ours (local), and theirs (upstream) versions. Produce resolved content and call makerkit_project_resolve_conflicts. Ask the user for guidance when the intent behind local changes is unclear."
+		};
+	}
+}
+//#endregion
+//#region src/commands/project/update/update.command.ts
+function createProjectUpdateCommand(parentCommand) {
+	return parentCommand.command("update").description("Pull the latest changes from the upstream MakerKit repository.").action(async () => {
+		try {
+			const spinner = ora("Pulling latest changes from upstream...").start();
+			const result = await projectPull({ projectPath: process.cwd() });
+			if (result.success) {
+				const displayName = VARIANT_CATALOG.find((v) => v.id === result.variant)?.name ?? result.variant;
+				if (result.alreadyUpToDate) spinner.succeed(`Already up to date. (${chalk.cyan(displayName)})`);
+				else spinner.succeed(`Successfully pulled latest changes from upstream. (${chalk.cyan(displayName)})`);
+			} else if ("hasConflicts" in result) {
+				spinner.fail("Merge conflicts detected.");
+				console.log(chalk.yellow(`\n${result.conflictCount} conflicting file(s):`));
+				for (const conflict of result.conflicts) console.log(`  ${chalk.gray("-")} ${conflict.path}`);
+				console.log(chalk.yellow("\nPlease resolve them manually:"));
+				console.log(chalk.gray("  1. Fix the conflicting files"));
+				console.log(chalk.gray("  2. Run: git add ."));
+				console.log(chalk.gray("  3. Run: git commit"));
+				process.exit(1);
+			} else {
+				spinner.fail("Failed to pull from upstream.");
+				console.error(chalk.red(`\n${result.reason}`));
+				process.exit(1);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : "Unknown error";
+			console.error(chalk.red(`Error: ${message}`));
+			process.exit(1);
+		}
+	});
+}
+//#endregion
+//#region src/commands/project/project.command.ts
+const projectCommand = new Command().name("project").description("Manage your MakerKit project.");
+createProjectUpdateCommand(projectCommand);
+//#endregion
+//#region src/index.ts
+config({
+	path: ".env.local",
+	quiet: true
+});
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
+async function main() {
+	const program = new Command().name("makerkit").description("Your SaaS Kit companion. Add plugins, manage migrations, and more.").version(CLI_VERSION, "-v, --version", "display the version number");
+	program.addCommand(newCommand).addCommand(pluginsCommand).addCommand(projectCommand);
+	program.parse();
+}
+main();
+//#endregion
+export {};
+
+//# sourceMappingURL=index.mjs.map