@makerkit/cli 2.0.2 → 2.0.4

package/dist/mcp.mjs

@@ -0,0 +1,1354 @@
+#!/usr/bin/env node
+import path, { dirname, join } from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { config } from "dotenv";
+import { z } from "zod/v3";
+import fs from "fs-extra";
+import invariant from "tiny-invariant";
+import { homedir, tmpdir } from "os";
+import { execa, execaCommand } from "execa";
+import "prompts";
+//#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);
+	}
+}
+async function readBaseVersion(pluginId, fileTarget) {
+	const filePath = join(basesDir(pluginId), fileTarget);
+	try {
+		return await fs.readFile(filePath, "utf-8");
+	} catch {
+		return;
+	}
+}
+async function hasBaseVersions(pluginId) {
+	return fs.pathExists(basesDir(pluginId));
+}
+function computeFileStatus(params) {
+	const { base, local, remote } = params;
+	if (local !== void 0 && local === remote) return "unchanged";
+	if (base === void 0) {
+		if (local === void 0) return "added";
+		return "no_base";
+	}
+	if (local === void 0) return "deleted_locally";
+	if (base === local) return "updated";
+	if (base === remote) return "unchanged";
+	return "conflict";
+}
+//#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() === "";
+}
+//#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");
+}
+//#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/apply-plugin-update.ts
+async function applyPluginUpdate(options) {
+	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);
+	(await PluginRegistry.load()).validatePlugin(options.pluginId, variant);
+	const item = await fetchRegistryItem(variant, options.pluginId, username, majorVersion);
+	const remoteByPath = new Map(item.files.map((f) => [f.target, f.content]));
+	const cwd = process.cwd();
+	const written = [];
+	const skipped = [];
+	const deleted = [];
+	for (const file of options.files) {
+		const targetPath = join(cwd, file.path);
+		switch (file.action) {
+			case "write":
+				if (file.content === void 0) return {
+					success: false,
+					reason: `File "${file.path}" has action "write" but no content provided.`
+				};
+				await fs.ensureDir(dirname(targetPath));
+				await fs.writeFile(targetPath, file.content);
+				written.push(file.path);
+				break;
+			case "skip":
+				skipped.push(file.path);
+				break;
+			case "delete":
+				if (await fs.pathExists(targetPath)) await fs.remove(targetPath);
+				deleted.push(file.path);
+				break;
+		}
+		if (file.action !== "delete") {
+			const remoteContent = remoteByPath.get(file.path);
+			if (remoteContent !== void 0) await saveBaseVersions(options.pluginId, [{
+				path: "",
+				content: remoteContent,
+				type: "",
+				target: file.path
+			}]);
+		}
+	}
+	return {
+		success: true,
+		pluginId: options.pluginId,
+		variant,
+		written,
+		skipped,
+		deleted
+	};
+}
+//#endregion
+//#region src/utils/check-plugin-update.ts
+async function checkPluginUpdate(options) {
+	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);
+	(await PluginRegistry.load()).validatePlugin(options.pluginId, variant);
+	const item = await fetchRegistryItem(variant, options.pluginId, username, majorVersion);
+	const cwd = process.cwd();
+	const hasBase = await hasBaseVersions(options.pluginId);
+	const counts = {
+		unchanged: 0,
+		updated: 0,
+		conflict: 0,
+		added: 0,
+		deleted_locally: 0,
+		no_base: 0
+	};
+	const files = await Promise.all(item.files.map(async (file) => {
+		const localPath = join(cwd, file.target);
+		let local;
+		try {
+			local = await fs.readFile(localPath, "utf-8");
+		} catch {
+			local = void 0;
+		}
+		const base = await readBaseVersion(options.pluginId, file.target);
+		const remote = file.content;
+		const status = computeFileStatus({
+			base,
+			local,
+			remote
+		});
+		counts[status]++;
+		const result = {
+			path: file.target,
+			status
+		};
+		switch (status) {
+			case "unchanged": break;
+			case "updated":
+				result.remote = remote;
+				break;
+			case "conflict":
+				result.base = base;
+				result.local = local;
+				result.remote = remote;
+				break;
+			case "no_base":
+				result.local = local;
+				result.remote = remote;
+				break;
+			case "added":
+				result.remote = remote;
+				break;
+			case "deleted_locally":
+				result.base = base;
+				result.remote = remote;
+				break;
+		}
+		return result;
+	}));
+	return {
+		success: true,
+		pluginId: options.pluginId,
+		variant,
+		hasBaseVersions: hasBase,
+		counts,
+		files
+	};
+}
+//#endregion
+//#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/get-project-status.ts
+async function getProjectStatus(options) {
+	const { variant, version } = await validateProject();
+	const gitClean = await isGitClean();
+	const registryConfigured = !!getCachedUsername();
+	const plugins = (await PluginRegistry.load()).getPluginsForVariant(variant);
+	return {
+		variant,
+		version,
+		gitClean,
+		registryConfigured,
+		plugins: await Promise.all(plugins.map(async (p) => ({
+			id: p.id,
+			name: p.name,
+			installed: await isInstalled(p, variant)
+		})))
+	};
+}
+//#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/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/utils/outdated-plugins.ts
+async function isOutdated(plugin, variant, username, majorVersion) {
+	const item = await fetchRegistryItem(variant, plugin.id, username, majorVersion);
+	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;
+}
+async function outdatedPlugins(options) {
+	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 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) return {
+		success: true,
+		variant,
+		outdated: []
+	};
+	const outdated = [];
+	for (const plugin of installed) try {
+		if (await isOutdated(plugin, variant, username, majorVersion)) outdated.push({
+			id: plugin.id,
+			name: plugin.name,
+			path: getPath(plugin, variant)
+		});
+	} catch {}
+	return {
+		success: true,
+		variant,
+		outdated
+	};
+}
+//#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"
+	}
+];
+function listVariants() {
+	return { variants: VARIANT_CATALOG };
+}
+//#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/utils/resolve-conflicts.ts
+async function resolveConflicts(options) {
+	const cwd = process.cwd();
+	for (const file of options.files) {
+		const targetPath = join(cwd, file.path);
+		await fs.ensureDir(dirname(targetPath));
+		await fs.writeFile(targetPath, file.content);
+	}
+	const paths = options.files.map((f) => f.path);
+	await execa("git", ["add", ...paths]);
+	let remainingConflicts = [];
+	try {
+		const { stdout } = await execaCommand("git diff --name-only --diff-filter=U");
+		remainingConflicts = stdout.trim().split("\n").filter(Boolean);
+	} catch {
+		remainingConflicts = [];
+	}
+	if (remainingConflicts.length > 0) return {
+		success: false,
+		resolved: paths,
+		remaining: remainingConflicts,
+		message: `${paths.length} file(s) resolved, but ${remainingConflicts.length} conflict(s) remain. Resolve the remaining files and call makerkit_project_resolve_conflicts again.`
+	};
+	if (options.commitMessage) await execa("git", [
+		"commit",
+		"-m",
+		options.commitMessage
+	]);
+	else await execaCommand("git commit --no-edit");
+	return {
+		success: true,
+		resolved: paths,
+		message: "All conflicts resolved and merge commit created."
+	};
+}
+//#endregion
+//#region src/utils/with-project-dir.ts
+async function withProjectDir(projectPath, fn) {
+	const original = process.cwd();
+	try {
+		process.chdir(projectPath);
+		return await fn();
+	} finally {
+		process.chdir(original);
+	}
+}
+//#endregion
+//#region src/mcp.ts
+config({
+	path: ".env.local",
+	quiet: true
+});
+function textContent(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function errorContent(message) {
+	return {
+		content: [{
+			type: "text",
+			text: message
+		}],
+		isError: true
+	};
+}
+const server = new McpServer({
+	name: "makerkit-cli",
+	version: CLI_VERSION
+});
+server.registerTool("makerkit_status", {
+	description: "Project introspection: detect variant, git status, registry config, and plugin install status",
+	inputSchema: { projectPath: z.string().describe("Absolute path to the MakerKit project root") }
+}, async ({ projectPath }) => {
+	try {
+		const result = await withProjectDir(projectPath, () => getProjectStatus({ projectPath }));
+		return textContent(JSON.stringify(result, null, 2));
+	} catch (error) {
+		return errorContent(error instanceof Error ? error.message : "Unknown error");
+	}
+});
+server.registerTool("makerkit_list_variants", {
+	description: "List available MakerKit kit variants with metadata for the project creation wizard",
+	inputSchema: {}
+}, async () => {
+	try {
+		return textContent(JSON.stringify(listVariants(), null, 2));
+	} catch (error) {
+		return errorContent(error instanceof Error ? error.message : "Unknown error");
+	}
+});
+server.registerTool("makerkit_create_project", {
+	description: "Create a new MakerKit project: clones the selected kit variant, installs dependencies, and writes a .makerkit/config.json marker file.",
+	inputSchema: {
+		variant: z.enum(VARIANT_CATALOG.map((v) => v.id)).describe("Kit variant to create"),
+		name: z.string().min(1).describe("Project directory name"),
+		directory: z.string().describe("Absolute path to the parent directory where the project will be created"),
+		github_token: z.string().optional().describe("Optional GitHub PAT for HTTPS cloning (token is stripped from remote after clone)")
+	}
+}, async ({ variant, name, directory, github_token }) => {
+	try {
+		if (!path.isAbsolute(directory)) return errorContent(`"directory" must be an absolute path. Received: "${directory}"`);
+		const result = await createProject({
+			variant,
+			name,
+			directory,
+			githubToken: github_token
+		});
+		return textContent(JSON.stringify({
+			success: result.success,
+			project_path: result.projectPath,
+			variant: result.variant,
+			message: result.message
+		}, null, 2));
+	} catch (error) {
+		return errorContent(error instanceof Error ? error.message : "Unknown error");
+	}
+});
+server.registerTool("makerkit_list_plugins", {
+	description: "List all available plugins for the detected project variant with install status and metadata",
+	inputSchema: { projectPath: z.string().describe("Absolute path to the MakerKit project root") }
+}, async ({ projectPath }) => {
+	try {
+		const result = await withProjectDir(projectPath, () => listPlugins({ projectPath }));
+		return textContent(JSON.stringify(result, null, 2));
+	} catch (error) {
+		return errorContent(error instanceof Error ? error.message : "Unknown error");
+	}
+});
+server.registerTool("makerkit_add_plugin", {
+	description: "Install a MakerKit plugin: runs codemod, adds env vars, and returns structured result",
+	inputSchema: {
+		projectPath: z.string().describe("Absolute path to the MakerKit project root"),
+		pluginId: z.string().describe("Plugin identifier (e.g. feedback, waitlist, posthog)"),
+		githubUsername: z.string().optional().describe("GitHub username for registry auth (skips interactive prompt)"),
+		skipGitCheck: z.boolean().optional().describe("Skip git clean check (useful when installing multiple plugins in sequence)")
+	}
+}, async ({ projectPath, pluginId, githubUsername, skipGitCheck }) => {
+	try {
+		const result = await withProjectDir(projectPath, () => addPlugin({
+			projectPath,
+			pluginId,
+			githubUsername,
+			skipGitCheck
+		}));
+		if (!result.success) return errorContent(result.reason);
+		return textContent(JSON.stringify(result, null, 2));
+	} catch (error) {
+		return errorContent(error instanceof Error ? error.message : "Unknown error");
+	}
+});
+server.registerTool("makerkit_init_registry", {
+	description: "Cache the GitHub username used for MakerKit plugin registry authentication",
+	inputSchema: {
+		projectPath: z.string().describe("Absolute path to the MakerKit project root"),
+		githubUsername: z.string().describe("GitHub username registered with your MakerKit account")
+	}
+}, async ({ projectPath, githubUsername }) => {
+	try {
+		const result = await withProjectDir(projectPath, () => initRegistry({
+			projectPath,
+			githubUsername
+		}));
+		return textContent(JSON.stringify(result, null, 2));
+	} catch (error) {
+		return errorContent(error instanceof Error ? error.message : "Unknown error");
+	}
+});
+server.registerTool("makerkit_check_update", {
+	description: "Analyze a plugin update using three-way diff (base/local/remote). Returns per-file status and content for AI-powered merge resolution.",
+	inputSchema: {
+		projectPath: z.string().describe("Absolute path to the MakerKit project root"),
+		pluginId: z.string().describe("Plugin identifier (e.g. feedback, waitlist)"),
+		githubUsername: z.string().optional().describe("GitHub username for registry auth (uses cached if omitted)")
+	}
+}, async ({ projectPath, pluginId, githubUsername }) => {
+	try {
+		const result = await withProjectDir(projectPath, () => checkPluginUpdate({
+			projectPath,
+			pluginId,
+			githubUsername
+		}));
+		if (!result.success) return errorContent(result.reason);
+		return textContent(JSON.stringify({
+			...result,
+			note: "For conflict files, produce a merged version and pass it to makerkit_apply_update."
+		}, null, 2));
+	} catch (error) {
+		return errorContent(error instanceof Error ? error.message : "Unknown error");
+	}
+});
+server.registerTool("makerkit_apply_update", {
+	description: "Apply AI-resolved plugin update files. Writes merged content to disk and updates base versions for future three-way merges.",
+	inputSchema: {
+		projectPath: z.string().describe("Absolute path to the MakerKit project root"),
+		pluginId: z.string().describe("Plugin identifier"),
+		files: z.array(z.object({
+			path: z.string().describe("File path relative to project root (from check_update)"),
+			content: z.string().optional().describe("Resolved file content (required for write action)"),
+			action: z.enum([
+				"write",
+				"skip",
+				"delete"
+			]).describe("write: write content to disk, skip: keep local version, delete: remove file from disk")
+		})).describe("Array of file resolutions"),
+		installDependencies: z.boolean().optional().describe("Whether to install plugin dependencies (default true)"),
+		githubUsername: z.string().optional().describe("GitHub username for registry auth (uses cached if omitted)")
+	}
+}, async ({ projectPath, pluginId, files, installDependencies, githubUsername }) => {
+	try {
+		const result = await withProjectDir(projectPath, () => applyPluginUpdate({
+			projectPath,
+			pluginId,
+			files,
+			installDependencies,
+			githubUsername
+		}));
+		if (!result.success) return errorContent(result.reason);
+		return textContent(JSON.stringify({
+			...result,
+			note: "Base versions updated. Run makerkit_check_update again to verify all files show as unchanged."
+		}, null, 2));
+	} catch (error) {
+		return errorContent(error instanceof Error ? error.message : "Unknown error");
+	}
+});
+server.registerTool("makerkit_project_pull", {
+	description: "Pull latest upstream changes into a MakerKit project. Auto-detects kit variant, configures the upstream remote (SSH or HTTPS), fetches, and merges. Returns conflict details with base/local/remote content when merge conflicts occur so the AI can resolve them. After resolving, call makerkit_project_resolve_conflicts.",
+	inputSchema: { projectPath: z.string().describe("Absolute path to the MakerKit project root") }
+}, async ({ projectPath }) => {
+	try {
+		const result = await withProjectDir(projectPath, () => projectPull({ projectPath }));
+		if (!result.success) {
+			if ("hasConflicts" in result) return textContent(JSON.stringify(result, null, 2));
+			return errorContent(result.reason);
+		}
+		return textContent(JSON.stringify(result, null, 2));
+	} catch (error) {
+		return errorContent(error instanceof Error ? error.message : "Unknown error");
+	}
+});
+server.registerTool("makerkit_project_resolve_conflicts", {
+	description: "Resolve merge conflicts from makerkit_project_pull. Write resolved file contents, stage them, and complete the merge commit.",
+	inputSchema: {
+		projectPath: z.string().describe("Absolute path to the MakerKit project root"),
+		files: z.array(z.object({
+			path: z.string().describe("File path relative to project root"),
+			content: z.string().describe("Resolved file content")
+		})).describe("Array of resolved files"),
+		commitMessage: z.string().optional().describe("Custom merge commit message (defaults to auto-generated merge message)")
+	}
+}, async ({ projectPath, files, commitMessage }) => {
+	try {
+		const result = await withProjectDir(projectPath, () => resolveConflicts({
+			projectPath,
+			files,
+			commitMessage
+		}));
+		if (!result.success) return textContent(JSON.stringify(result, null, 2));
+		return textContent(JSON.stringify(result, null, 2));
+	} catch (error) {
+		return errorContent(error instanceof Error ? error.message : "Unknown error");
+	}
+});
+server.registerTool("makerkit_outdated_plugins", {
+	description: "Check all installed plugins for available updates. Returns a list of plugins whose remote files differ from the local copies.",
+	inputSchema: {
+		projectPath: z.string().describe("Absolute path to the MakerKit project root"),
+		githubUsername: z.string().optional().describe("GitHub username for registry auth (uses cached if omitted)")
+	}
+}, async ({ projectPath, githubUsername }) => {
+	try {
+		const result = await withProjectDir(projectPath, () => outdatedPlugins({
+			projectPath,
+			githubUsername
+		}));
+		if (!result.success) return errorContent(result.reason);
+		return textContent(JSON.stringify({
+			...result,
+			note: result.outdated.length > 0 ? "Use makerkit_check_update on each plugin to see detailed diffs." : "All installed plugins are up to date."
+		}, null, 2));
+	} catch (error) {
+		return errorContent(error instanceof Error ? error.message : "Unknown error");
+	}
+});
+async function main() {
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+}
+main();
+//#endregion
+export {};
+
+//# sourceMappingURL=mcp.mjs.map