@makerkit/cli 1.3.17 → 2.0.0

package/dist/mcp.js

@@ -0,0 +1,1508 @@
+#!/usr/bin/env node
+
+// src/mcp.ts
+import path 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";
+
+// src/plugins-model.ts
+import { join as join2 } from "path";
+import fs2 from "fs-extra";
+import invariant from "tiny-invariant";
+
+// src/utils/plugins-cache.ts
+import { join } from "path";
+import { homedir } from "os";
+import fs from "fs-extra";
+var CACHE_DIR = join(homedir(), ".makerkit");
+var CACHE_FILE = join(CACHE_DIR, "plugins.json");
+var CACHE_TTL_MS = 60 * 60 * 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 data = await response.json();
+      const plugins = data.plugins;
+      await writeCache(plugins);
+      return plugins;
+    }
+  } catch {
+  }
+  return cached?.plugins ?? fallback;
+}
+
+// src/plugins-model.ts
+var 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"
+      }
+    }
+  },
+  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-cms",
+    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;
+    const plugins = await fetchPluginRegistry(registryUrl, DEFAULT_PLUGINS);
+    return new _PluginRegistry(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 = join2(process.cwd(), pluginPath, "package.json");
+  if (!await fs2.pathExists(pkgJsonPath)) {
+    return false;
+  }
+  try {
+    const pkg = await fs2.readJson(pkgJsonPath);
+    return !!pkg.name && !!pkg.exports;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/base-store.ts
+import { dirname, join as join3 } from "path";
+import fs3 from "fs-extra";
+function basesDir(pluginId) {
+  return join3(process.cwd(), "node_modules", ".cache", "makerkit", "bases", pluginId);
+}
+async function saveBaseVersions(pluginId, files) {
+  const dir = basesDir(pluginId);
+  for (const file of files) {
+    const targetPath = join3(dir, file.target);
+    await fs3.ensureDir(dirname(targetPath));
+    await fs3.writeFile(targetPath, file.content);
+  }
+}
+async function readBaseVersion(pluginId, fileTarget) {
+  const filePath = join3(basesDir(pluginId), fileTarget);
+  try {
+    return await fs3.readFile(filePath, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+async function hasBaseVersions(pluginId) {
+  return fs3.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";
+}
+
+// src/utils/git.ts
+import { execaCommand } from "execa";
+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() === "";
+}
+
+// src/utils/install-registry-files.ts
+import { dirname as dirname2, join as join4 } from "path";
+import fs4 from "fs-extra";
+async function fetchRegistryItem(variant, pluginId, username) {
+  const url = `https://makerkit.dev/r/${variant}/${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) {
+  const item = await fetchRegistryItem(variant, pluginId, username);
+  const cwd = process.cwd();
+  for (const file of item.files) {
+    const targetPath = join4(cwd, file.target);
+    await fs4.ensureDir(dirname2(targetPath));
+    await fs4.writeFile(targetPath, file.content);
+  }
+  return item;
+}
+
+// src/utils/run-codemod.ts
+import { execaCommand as execaCommand2 } from "execa";
+var CODEMOD_TIMEOUT_MS = 5 * 60 * 1e3;
+async function runCodemod(variant, pluginId, options) {
+  try {
+    const localPath = process.env.MAKERKIT_CODEMODS_PATH;
+    const runner = process.env.MAKERKIT_PACKAGE_RUNNER ?? "npx --yes";
+    const command = localPath ? `${runner} codemod workflow run --allow-dirty -w ${localPath}/codemods/${variant}/${pluginId}` : `${runner} codemod --allow-dirty @makerkit/${variant}-${pluginId}`;
+    const { stdout, stderr } = await execaCommand2(command, {
+      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 += `
+${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
+    };
+  }
+}
+
+// src/utils/username-cache.ts
+import { join as join5 } from "path";
+import { tmpdir } from "os";
+import fs5 from "fs-extra";
+import prompts from "prompts";
+var USERNAME_FILE = join5(tmpdir(), "makerkit-username");
+function getCachedUsername() {
+  try {
+    const username = fs5.readFileSync(USERNAME_FILE, "utf-8").trim();
+    return username.length > 0 ? username : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function cacheUsername(username) {
+  fs5.writeFileSync(USERNAME_FILE, username, "utf-8");
+}
+
+// src/utils/workspace.ts
+import { join as join6 } from "path";
+import fs6 from "fs-extra";
+async function readDeps(pkgPath) {
+  if (!await fs6.pathExists(pkgPath)) {
+    return {};
+  }
+  const pkg = await fs6.readJson(pkgPath);
+  return {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+}
+async function detectVariant() {
+  const cwd = process.cwd();
+  const rootPkgPath = join6(cwd, "package.json");
+  if (!await fs6.pathExists(rootPkgPath)) {
+    throw new Error(
+      "No package.json found. Please run this command from a MakerKit project root."
+    );
+  }
+  const rootDeps = await readDeps(rootPkgPath);
+  if (!rootDeps["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(join6(cwd, "apps", "web", "package.json"));
+  const dbDeps = await readDeps(
+    join6(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 rootPkg = await fs6.readJson(join6(process.cwd(), "package.json"));
+  return {
+    variant,
+    version: rootPkg.version ?? "unknown"
+  };
+}
+
+// src/utils/add-plugin.ts
+async function addPlugin(options) {
+  if (!options.skipGitCheck) {
+    const gitClean = await isGitClean();
+    if (!gitClean) {
+      return {
+        success: false,
+        reason: "Git working directory has uncommitted changes. Please commit or stash them before adding a plugin."
+      };
+    }
+  }
+  const { variant } = 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 registry = await PluginRegistry.load();
+  const plugin = registry.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);
+  await saveBaseVersions(options.pluginId, item.files);
+  const codemodResult = await runCodemod(variant, options.pluginId, {
+    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.
+${codemodResult.output}`
+  };
+}
+
+// src/utils/apply-plugin-update.ts
+import { dirname as dirname3, join as join7 } from "path";
+import fs7 from "fs-extra";
+async function applyPluginUpdate(options) {
+  const { variant } = 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 registry = await PluginRegistry.load();
+  registry.validatePlugin(options.pluginId, variant);
+  const item = await fetchRegistryItem(variant, options.pluginId, username);
+  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 = join7(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 fs7.ensureDir(dirname3(targetPath));
+        await fs7.writeFile(targetPath, file.content);
+        written.push(file.path);
+        break;
+      }
+      case "skip": {
+        skipped.push(file.path);
+        break;
+      }
+      case "delete": {
+        if (await fs7.pathExists(targetPath)) {
+          await fs7.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
+  };
+}
+
+// src/utils/check-plugin-update.ts
+import { join as join8 } from "path";
+import fs8 from "fs-extra";
+async function checkPluginUpdate(options) {
+  const { variant } = 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 registry = await PluginRegistry.load();
+  registry.validatePlugin(options.pluginId, variant);
+  const item = await fetchRegistryItem(variant, options.pluginId, username);
+  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 = join8(cwd, file.target);
+      let local;
+      try {
+        local = await fs8.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
+  };
+}
+
+// src/utils/create-project.ts
+import { join as join10 } from "path";
+import { execa } from "execa";
+import fs10 from "fs-extra";
+
+// src/utils/marker-file.ts
+import { join as join9 } from "path";
+import fs9 from "fs-extra";
+
+// src/version.ts
+var CLI_VERSION = "2.0.0-beta.1";
+
+// src/utils/marker-file.ts
+async function writeMarkerFile(projectPath, variant, kitRepo) {
+  const dir = join9(projectPath, ".makerkit");
+  await fs9.ensureDir(dir);
+  const config2 = {
+    version: 1,
+    variant,
+    kit_repo: kitRepo,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    cli_version: CLI_VERSION
+  };
+  await fs9.writeJson(join9(dir, "config.json"), config2, { spaces: 2 });
+}
+
+// src/utils/upstream.ts
+import { execaCommand as execaCommand3 } from "execa";
+var 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 execaCommand3("ssh -T git@github.com -o StrictHostKeyChecking=no", {
+      timeout: 1e4
+    });
+    return true;
+  } catch (error) {
+    const stderr = error instanceof Error && "stderr" in error ? String(error.stderr) : "";
+    return stderr.includes("successfully authenticated");
+  }
+}
+function getUpstreamUrl(variant, useSsh) {
+  const repo = VARIANT_REPO_MAP[variant];
+  return useSsh ? sshUrl(repo) : httpsUrl(repo);
+}
+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 execaCommand3("git remote get-url upstream");
+    return stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function setUpstreamRemote(url) {
+  const currentUrl = await getUpstreamRemoteUrl();
+  if (currentUrl) {
+    await execaCommand3(`git remote set-url upstream ${url}`);
+  } else {
+    await execaCommand3(`git remote add upstream ${url}`);
+  }
+}
+
+// src/utils/create-project.ts
+async function createProject(options) {
+  const { variant, name, directory, githubToken } = options;
+  const projectPath = join10(directory, name);
+  const repo = VARIANT_REPO_MAP[variant];
+  if (await fs10.pathExists(projectPath)) {
+    throw new Error(
+      `Target directory "${projectPath}" already exists. Choose a different name or remove it first.`
+    );
+  }
+  if (!await fs10.pathExists(directory)) {
+    throw new Error(
+      `Parent directory "${directory}" does not exist.`
+    );
+  }
+  let cloneUrl;
+  if (githubToken) {
+    cloneUrl = `https://${githubToken}@github.com/${repo}`;
+  } else {
+    const useSsh = await hasSshAccess();
+    cloneUrl = useSsh ? `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}".`
+  };
+}
+
+// src/utils/get-project-status.ts
+async function getProjectStatus(options) {
+  const { variant, version } = await validateProject();
+  const gitClean = await isGitClean();
+  const registryConfigured = !!getCachedUsername();
+  const registry = await PluginRegistry.load();
+  const plugins = registry.getPluginsForVariant(variant);
+  const pluginStatuses = await Promise.all(
+    plugins.map(async (p) => ({
+      id: p.id,
+      name: p.name,
+      installed: await isInstalled(p, variant)
+    }))
+  );
+  return {
+    variant,
+    version,
+    gitClean,
+    registryConfigured,
+    plugins: pluginStatuses
+  };
+}
+
+// src/utils/init-registry.ts
+async function initRegistry(options) {
+  const variant = await detectVariant();
+  cacheUsername(options.githubUsername);
+  return {
+    success: true,
+    variant,
+    username: options.githubUsername
+  };
+}
+
+// src/utils/list-plugins.ts
+async function listPlugins(options) {
+  const variant = await detectVariant();
+  const registry = await PluginRegistry.load();
+  const plugins = registry.getPluginsForVariant(variant);
+  const pluginList = 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
+    }))
+  );
+  return { variant, plugins: pluginList };
+}
+
+// src/utils/list-variants.ts
+var 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 };
+}
+
+// src/utils/project-pull.ts
+import { join as join11 } from "path";
+import { execa as execa2, execaCommand as execaCommand4 } from "execa";
+import fs11 from "fs-extra";
+async function projectPull(options) {
+  const { variant } = await validateProject();
+  const gitClean = await isGitClean();
+  if (!gitClean) {
+    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 useSsh = await hasSshAccess();
+    const url = getUpstreamUrl(variant, useSsh);
+    await setUpstreamRemote(url);
+    currentUrl = url;
+  } else if (!isUpstreamUrlValid(currentUrl, variant)) {
+    const useSsh = currentUrl.startsWith("git@");
+    const expectedUrl = getUpstreamUrl(variant, useSsh);
+    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 execaCommand4("git fetch upstream");
+  try {
+    const { stdout } = await execaCommand4(
+      "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);
+    const isConflict = output.includes("CONFLICT") || output.includes("Automatic merge failed");
+    if (!isConflict) {
+      throw new Error(`Merge failed: ${output}`);
+    }
+    const { stdout: statusOutput } = await execaCommand4(
+      "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 fs11.readFile(join11(cwd, filePath), "utf-8");
+        } catch {
+          conflicted = void 0;
+        }
+        let base;
+        let ours;
+        let theirs;
+        try {
+          const { stdout: b } = await execa2("git", [
+            "show",
+            `:1:${filePath}`
+          ]);
+          base = b;
+        } catch {
+          base = void 0;
+        }
+        try {
+          const { stdout: o } = await execa2("git", [
+            "show",
+            `:2:${filePath}`
+          ]);
+          ours = o;
+        } catch {
+          ours = void 0;
+        }
+        try {
+          const { stdout: t } = await execa2("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."
+    };
+  }
+}
+
+// src/utils/resolve-conflicts.ts
+import { dirname as dirname4, join as join12 } from "path";
+import { execa as execa3, execaCommand as execaCommand5 } from "execa";
+import fs12 from "fs-extra";
+async function resolveConflicts(options) {
+  const cwd = process.cwd();
+  for (const file of options.files) {
+    const targetPath = join12(cwd, file.path);
+    await fs12.ensureDir(dirname4(targetPath));
+    await fs12.writeFile(targetPath, file.content);
+  }
+  const paths = options.files.map((f) => f.path);
+  await execa3("git", ["add", ...paths]);
+  let remainingConflicts = [];
+  try {
+    const { stdout } = await execaCommand5(
+      "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 execa3("git", ["commit", "-m", options.commitMessage]);
+  } else {
+    await execaCommand5("git commit --no-edit");
+  }
+  return {
+    success: true,
+    resolved: paths,
+    message: "All conflicts resolved and merge commit created."
+  };
+}
+
+// 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);
+  }
+}
+
+// src/mcp.ts
+config({ path: ".env.local" });
+function textContent(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errorContent(message) {
+  return { content: [{ type: "text", text: message }], isError: true };
+}
+var 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");
+    }
+  }
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+void main();
+//# sourceMappingURL=mcp.js.map