@makerkit/cli 1.3.18 → 2.0.0

package/dist/index.js

@@ -1,765 +1,1652 @@
 #!/usr/bin/env node
 
-// src/commands/i18n/i18n-service.ts
-import { join as join2 } from "path";
+// src/commands/new/new.command.ts
+import chalk from "chalk";
+import { Command } from "commander";
+import ora from "ora";
+import prompts from "prompts";
 
-// src/utils/openai-client.ts
-import OpenAI from "openai";
-function getOpenAIClient() {
-  const apiKey = process.env.OPENAI_API_KEY;
-  if (!apiKey) {
-    throw new Error(
-      "OPENAI_API_KEY env variable is not set. Please set it in your .env.local file of your Makerkit workspace."
-    );
-  }
-  return new OpenAI({ apiKey });
-}
-var openai_client_default = getOpenAIClient;
+// src/utils/create-project.ts
+import { join as join2 } from "path";
+import { execa } from "execa";
+import fs2 from "fs-extra";
 
-// src/utils/workspace.ts
+// src/utils/marker-file.ts
 import { join } from "path";
+import fs from "fs-extra";
 
-// src/plugins-model.ts
-import invariant from "tiny-invariant";
-var PluginsModel = {
-  CookieBanner: {
-    name: `Cookie Banner`,
-    id: `cookie-banner`,
-    branch: `cookie-banner`,
-    description: `Add a cookie banner to your site.`,
-    folder: `plugins/cookie-banner`
-  },
-  AiChatBot: {
-    name: `AI Chatbot`,
-    id: `chatbot-v1`,
-    branch: `chatbot`,
-    description: `Add an AI Chatbot to your site.`,
-    folder: `plugins/chatbot`
-  },
-  FeedbackPopup: {
-    name: `Feedback Popup`,
-    id: `feedback-popup-v1`,
-    branch: `feedback-popup`,
-    description: `Add a feedback popup to your site.`,
-    folder: `plugins/feedback-popup`
-  },
-  AiTextEditor: {
-    name: `AI Text Editor`,
-    id: `text-editor-v1`,
-    branch: `text-editor`,
-    description: `Add an AI Text Editor to your site.`,
-    folder: `plugins/text-editor`
-  },
-  AiTextEditorTurbo: {
-    name: `AI Text Editor`,
-    id: `text-editor`,
-    branch: `text-editor`,
-    description: `Add an AI Text Editor to your site.`,
-    folder: `packages/plugins/text-editor`
-  },
-  Waitlist: {
-    name: `Waitlist`,
-    id: `waitlist`,
-    branch: `waitlist`,
-    description: `Add a waitlist to your site.`,
-    folder: `packages/plugins/waitlist`
-  },
-  FeedbackPopupTurbo: {
-    name: `Feedback Popup`,
-    id: `feedback`,
-    branch: `feedback`,
-    description: `Add a feedback popup to your site.`,
-    folder: `packages/plugins/feedback`
-  },
-  AiChatBotTurbo: {
-    name: `AI Chatbot`,
-    id: `chatbot`,
-    branch: `chatbot`,
-    description: `Add an AI Chatbot to your site.`,
-    folder: `packages/plugins/chatbot`
-  },
-  Testimonial: {
-    name: `Testimonial`,
-    id: `testimonial`,
-    branch: `testimonial`,
-    description: `Add a testimonial to your site.`,
-    folder: `packages/plugins/testimonial`
-  },
-  Roadmap: {
-    name: `Roadmap`,
-    id: `roadmap`,
-    branch: `roadmap`,
-    description: `Add a Roadmap to your site.`,
-    folder: `packages/plugins/roadmap`
-  },
-  Kanban: {
-    name: `Kanban`,
-    id: `kanban`,
-    branch: `kanban`,
-    description: `Add a Kanban component to your site.`,
-    folder: `packages/plugins/kanban`
-  },
-  GoogleAnalytics: {
-    name: `Google Analytics`,
-    id: `google-analytics`,
-    branch: `google-analytics`,
-    description: `Add Google Analytics to your site.`,
-    folder: `packages/plugins/analytics/google-analytics`
-  },
-  Posthog: {
-    name: `Posthog`,
-    id: `posthog`,
-    branch: `posthog`,
-    description: `Add Posthog Analytics to your site.`,
-    folder: `packages/plugins/analytics/posthog`
-  },
-  Umami: {
-    name: `Umami`,
-    id: `umami`,
-    branch: `umami`,
-    description: `Add Umami Analytics to your site.`,
-    folder: `packages/plugins/analytics/umami`
-  },
-  Signoz: {
-    name: `Signoz`,
-    id: `signoz`,
-    branch: `signoz`,
-    description: `Add Signoz Monitoring to your app.`,
-    folder: `packages/plugins/signoz`
-  },
-  Paddle: {
-    name: `Paddle`,
-    id: `paddle`,
-    branch: `paddle`,
-    description: `Add Paddle Billing to your app.`,
-    folder: `packages/plugins/paddle`
-  },
-  SupabaseCMS: {
-    name: `Supabase CMS`,
-    id: `supabase-cms`,
-    branch: `supabase-cms`,
-    description: `Add Supabase CMS provider to your app.`,
-    folder: `packages/plugins/supabase-cms`
-  }
+// src/version.ts
+var CLI_VERSION = "2.0.0-beta.1";
+
+// src/utils/marker-file.ts
+async function writeMarkerFile(projectPath, variant, kitRepo) {
+  const dir = join(projectPath, ".makerkit");
+  await fs.ensureDir(dir);
+  const config2 = {
+    version: 1,
+    variant,
+    kit_repo: kitRepo,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    cli_version: CLI_VERSION
+  };
+  await fs.writeJson(join(dir, "config.json"), config2, { spaces: 2 });
+}
+
+// src/utils/upstream.ts
+import { execaCommand } 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 getPluginById(id) {
-  return Object.values(PluginsModel).find((plugin) => plugin.id === id);
-}
-function validatePlugin(pluginId) {
-  const plugin = getPluginById(pluginId);
-  invariant(plugin, `Plugin ${pluginId} not found`);
-  return plugin;
-}
-
-// src/kits-model.ts
-import invariant2 from "tiny-invariant";
-var KitsModel = {
-  NextJsFirebase: {
-    name: `Next.js Firebase`,
-    id: `next-firebase`,
-    repository: `git@github.com:makerkit/next-firebase-saas-kit`,
-    blogPath: `_posts`,
-    localePath: `public/locales`,
-    plugins: [
-      PluginsModel.CookieBanner.id,
-      PluginsModel.AiChatBot.id,
-      PluginsModel.FeedbackPopup.id
-    ]
-  },
-  NextJsSupabase: {
-    name: `Next.js Supabase`,
-    id: `next-supabase`,
-    localePath: `public/locales`,
-    blogPath: `src/content/posts`,
-    repository: `git@github.com:makerkit/next-supabase-saas-kit`,
-    plugins: [
-      PluginsModel.AiChatBot.id,
-      PluginsModel.FeedbackPopup.id,
-      PluginsModel.CookieBanner.id,
-      PluginsModel.AiTextEditor.id
-    ]
-  },
-  NextJsSupabaseTurbo: {
-    name: `Next.js Supabase Turbo`,
-    id: `next-supabase-turbo`,
-    localePath: `apps/web/public/locales`,
-    blogPath: `apps/web/content/posts`,
-    repository: `git@github.com:makerkit/next-supabase-saas-kit-turbo`,
-    plugins: [
-      PluginsModel.Waitlist.id,
-      PluginsModel.Testimonial.id,
-      PluginsModel.Roadmap.id,
-      PluginsModel.Kanban.id,
-      PluginsModel.AiChatBotTurbo.id,
-      PluginsModel.FeedbackPopupTurbo.id,
-      PluginsModel.AiTextEditorTurbo.id,
-      PluginsModel.GoogleAnalytics.id,
-      PluginsModel.Posthog.id,
-      PluginsModel.Umami.id,
-      PluginsModel.Signoz.id,
-      PluginsModel.Paddle.id,
-      PluginsModel.SupabaseCMS.id
-    ]
-  },
-  RemixSupabaseTurbo: {
-    name: `Remix Supabase Turbo`,
-    id: `remix-supabase-turbo`,
-    localePath: `apps/web/public/locales`,
-    blogPath: `apps/web/content/posts`,
-    repository: `git@github.com:makerkit/remix-supabase-saas-kit-turbo`,
-    plugins: [
-      PluginsModel.Waitlist.id,
-      PluginsModel.Testimonial.id,
-      PluginsModel.AiChatBotTurbo.id,
-      PluginsModel.FeedbackPopupTurbo.id,
-      PluginsModel.AiTextEditorTurbo.id,
-      PluginsModel.GoogleAnalytics.id,
-      PluginsModel.Posthog.id,
-      PluginsModel.Umami.id
-    ]
-  },
-  NextJsSupabaseLite: {
-    name: `Next.js Supabase Lite`,
-    id: `next-supabase-lite`,
-    localePath: `public/locales`,
-    blogPath: `src/content/posts`,
-    repository: `git@github.com:makerkit/next-supabase-saas-kit-lite`,
-    plugins: []
-  },
-  RemixFirebase: {
-    name: `Remix Firebase`,
-    id: `remix-firebase`,
-    localePath: `public/locales`,
-    blogPath: "",
-    repository: `git@github.com:makerkit/remix-firebase-saas-kit`,
-    plugins: []
-  },
-  RemixSupabase: {
-    name: `Remix Supabase`,
-    id: `remix-supabase`,
-    localePath: `public/locales`,
-    blogPath: `app/content/posts`,
-    repository: `git@github.com:makerkit/remix-supabase-saas-kit`,
-    plugins: [
-      PluginsModel.AiChatBot.id,
-      PluginsModel.FeedbackPopup.id,
-      PluginsModel.CookieBanner.id,
-      PluginsModel.AiTextEditor.id
-    ]
+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) {
+    const stderr = error instanceof Error && "stderr" in error ? String(error.stderr) : "";
+    return stderr.includes("successfully authenticated");
   }
-};
-function getKitById(id) {
-  return Object.values(KitsModel).find((kit) => kit.id === id);
 }
-function validateKit(kitId) {
-  const kit = getKitById(kitId);
-  invariant2(kit, `Kit ${kitId} not found`);
-  return kit;
+function getUpstreamUrl(variant, useSsh) {
+  const repo = VARIANT_REPO_MAP[variant];
+  return useSsh ? sshUrl(repo) : httpsUrl(repo);
 }
-
-// src/utils/workspace.ts
-import chalk from "chalk";
-import fs from "fs-extra";
-var Workspace = class _Workspace {
-  static async getKitMeta() {
-    const packageJson = await getPackageJson();
-    const kit = await detectKitVersion();
-    return {
-      ...kit,
-      version: packageJson.version ?? "unknown"
-    };
+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 void 0;
   }
-  static async logWorkspaceInfo() {
-    const meta = await _Workspace.getKitMeta();
-    console.log(
-      `Makerkit version: ${chalk.cyan(meta.name)} - ${chalk.cyan(
-        meta.version ?? "unknown"
-      )}.
-`
-    );
+}
+async function setUpstreamRemote(url) {
+  const currentUrl = await getUpstreamRemoteUrl();
+  if (currentUrl) {
+    await execaCommand(`git remote set-url upstream ${url}`);
+  } else {
+    await execaCommand(`git remote add upstream ${url}`);
   }
-};
-async function detectKitVersion() {
-  let packageJson = await getPackageJson();
-  if (!packageJson) {
+}
+
+// src/utils/create-project.ts
+async function createProject(options) {
+  const { variant, name, directory, githubToken } = options;
+  const projectPath = join2(directory, name);
+  const repo = VARIANT_REPO_MAP[variant];
+  if (await fs2.pathExists(projectPath)) {
     throw new Error(
-      "No package.json found. Please run this command in a Makerkit workspace."
+      `Target directory "${projectPath}" already exists. Choose a different name or remove it first.`
     );
   }
-  let deps = Object.keys(packageJson.dependencies ?? []);
-  if (deps.length === 0) {
-    deps = Object.keys(packageJson.devDependencies ?? []);
-  }
-  if (deps.includes("turbo")) {
-    packageJson = await fs.readJSON(
-      join(process.cwd(), "apps/web/package.json")
+  if (!await fs2.pathExists(directory)) {
+    throw new Error(
+      `Parent directory "${directory}" does not exist.`
     );
-    deps = Object.keys(packageJson.dependencies ?? []);
-    if (deps.includes("next")) {
-      return KitsModel.NextJsSupabaseTurbo;
-    }
-    if (deps.includes("@remix-run/react")) {
-      return KitsModel.RemixSupabaseTurbo;
-    }
-  }
-  if (deps.includes("next") && deps.includes("firebase")) {
-    return KitsModel.NextJsFirebase;
-  }
-  if (deps.includes("next") && deps.includes("@supabase/supabase-js")) {
-    return KitsModel.NextJsSupabase;
-  }
-  if (deps.includes("@remix-run/react") && deps.includes("@supabase/supabase-js")) {
-    return KitsModel.RemixSupabase;
   }
-  throw new Error(
-    "Could not detect Makerkit workspace. Please run this command in a Makerkit workspace."
-  );
-}
-async function getPackageJson() {
-  return fs.readJSON(join(process.cwd(), "package.json")).catch(() => void 0);
-}
-
-// src/commands/i18n/i18n-service.ts
-import chalk2 from "chalk";
-import fs2 from "fs-extra";
-var I18nService = class {
-  /**
-   * @name verify
-   * @description Verifies if the locale files are in sync
-   */
-  static async verify(base = "en") {
-    const kit = await Workspace.getKitMeta();
-    const allLocales = fs2.readdirSync(kit.localePath).filter((locale) => {
-      return locale !== base;
-    });
-    const baseLocaleFolderPath = `${kit.localePath}/${base}`;
-    const localeFiles = fs2.readdirSync(baseLocaleFolderPath).filter((file) => {
-      return file.endsWith(".json");
-    });
-    for (const localeFile of localeFiles) {
-      for (const locale of allLocales) {
-        const baseLocaleFilePath = `${baseLocaleFolderPath}/${localeFile}`;
-        const targetLocaleFilePath = `${kit.localePath}/${locale}/${localeFile}`;
-        const baseLocaleFile = fs2.readJSONSync(baseLocaleFilePath);
-        const file = fs2.readJSONSync(targetLocaleFilePath);
-        const missingKeys = collectMissingKeys([baseLocaleFile, file]);
-        if (!missingKeys.length) {
-          console.log(
-            chalk2.green(`Locale ${locale}/${localeFile} is in sync!`)
-          );
-          continue;
-        }
-        console.log(
-          chalk2.yellow(
-            `Locale ${locale}/${localeFile} is missing the following keys: ${missingKeys.join(
-              ", "
-            )}`
-          )
-        );
-      }
-    }
+  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}`;
   }
-  /**
-   * @name translate
-   * @description Translates the locale files from source to target
-   * @param source
-   * @param target
-   */
-  static async translate(source, target) {
-    const kit = await Workspace.getKitMeta();
-    const client = openai_client_default();
-    const targetJsonPath = `${kit.localePath}/${target}`;
-    const sourceLocalePath = `${kit.localePath}/${source}`;
-    const sourceLocale = await fs2.exists(sourceLocalePath);
-    if (!sourceLocale) {
-      throw new Error(`Source locale at ${sourceLocalePath} not found`);
-    }
-    const files = fs2.readdirSync(sourceLocalePath).filter((file) => {
-      return file.endsWith(".json");
-    });
-    console.log(`Found the following files: ${files.join(", ")}`);
-    for (const file of files) {
-      const data = {};
-      const localeFile = fs2.readJSONSync(join2(sourceLocalePath, file));
-      console.log(
-        chalk2.cyan(`Translating "${file}". This can take a while...`)
-      );
-      for (const key in localeFile) {
-        data[key] = await translateKey(source, target, localeFile[key], client);
-      }
-      console.log(chalk2.green(`File "${file}" successfully translated!`));
-      console.log(chalk2.cyan(`Writing file "${file}" to ${targetJsonPath}`));
-      await fs2.exists(targetJsonPath) || await fs2.mkdir(targetJsonPath);
-      await fs2.writeJSON(join2(targetJsonPath, file), data, {});
-      console.log(chalk2.green(`File "${file}" successfully written!`));
-    }
+  await execa("git", ["clone", cloneUrl, name], { cwd: directory });
+  if (githubToken) {
+    await execa(
+      "git",
+      ["remote", "set-url", "origin", `https://github.com/${repo}`],
+      { cwd: projectPath }
+    );
   }
-};
-async function translateKey(source, target, key, client) {
-  if (typeof key === "string") {
-    return translateString(source, target, key, client);
-  }
-  const data = {};
-  for (const k in key) {
-    data[k] = await translateKey(source, target, key[k], client);
-  }
-  return data;
-}
-async function translateString(source, target, key, client) {
-  if (!key.trim() || key.length <= 1) {
-    return "";
-  }
-  const response = await client.chat.completions.create({
-    model: "gpt-3.5-turbo",
-    max_tokens: target.split(" ").length + 50,
-    temperature: 0.3,
-    messages: [
-      {
-        role: "user",
-        content: `Translate the text from locale ${source} to ${target}. Text: ${key}. Translation:`
-      }
-    ]
-  });
-  return response.choices[0].message.content ?? "";
-}
-function collectMissingKeys(objects) {
-  const allKeys = [];
-  objects.forEach((obj) => {
-    Object.keys(obj).forEach((key) => {
-      if (!allKeys.includes(key)) {
-        allKeys.push(key);
-      }
-    });
-  });
-  const missingKeys = [];
-  objects.forEach((obj) => {
-    allKeys.forEach((key) => {
-      if (!Object.keys(obj).includes(key)) {
-        missingKeys.push(key);
-      }
-    });
-  });
-  return missingKeys;
-}
-
-// src/commands/i18n/translate/translate.command.ts
-import chalk3 from "chalk";
-import prompts from "prompts";
-function createTranslateI18nCommand(parentCommand) {
-  return parentCommand.command("translate").argument("[source-locale]", "Source Locale").argument("[target-locale]", "Target Locale").description("Translate i18n files from source locale to target locale").action(async (sourceLocale, targetLocale) => {
-    const locales = await promptLocales(sourceLocale, targetLocale);
-    await I18nService.translate(locales.sourceLocale, locales.targetLocale);
-  });
-}
-async function promptLocales(maybeSource, maybeTarget) {
-  const hint = "e.g. en, fr, es, etc.";
-  const sourceLocale = maybeSource || (await prompts([
-    {
-      type: "text",
-      name: "locale",
-      message: `Enter your ${chalk3.cyan("Source Locale")}. ${hint}`,
-      hint
-    }
-  ])).locale;
-  const targetLocale = maybeTarget || (await prompts([
-    {
-      type: "text",
-      name: "locale",
-      message: `Enter your ${chalk3.cyan("Target Locale")}. ${hint}`,
-      hint
-    }
-  ])).locale;
+  await execa("pnpm", ["install"], { cwd: projectPath });
+  await writeMarkerFile(projectPath, variant, repo);
   return {
-    sourceLocale,
-    targetLocale
+    success: true,
+    projectPath,
+    variant,
+    kitRepo: repo,
+    message: `Project "${name}" created successfully with variant "${variant}".`
   };
 }
 
-// src/commands/i18n/verify/verify.command.ts
-function createVerifyI18nCommand(parentCommand) {
-  return parentCommand.command("verify").argument("[base-locale]", "Base Locale").description(
-    "Verify i18n files have no missing keys compared to base locale"
-  ).action(async (baseLocale = "en") => {
-    await I18nService.verify(baseLocale);
-  });
-}
-
-// src/commands/i18n/i18n.command.ts
-import { Command } from "commander";
-var i18nCommand = new Command().name("i18n").description("Manage and translate your i18n files").hook("preAction", () => {
-  return Workspace.logWorkspaceInfo();
-});
-createTranslateI18nCommand(i18nCommand);
-createVerifyI18nCommand(i18nCommand);
-
-// src/commands/license/activate/activate-license.command.ts
-import chalk4 from "chalk";
-import ora from "ora";
-import prompts2 from "prompts";
-import { z } from "zod";
-var schema = z.object({
-  licenseKey: z.string().min(1).max(32),
-  githubUsername: z.string().min(1).max(64)
-});
-function createActivateLicenseCommand(parentCommand) {
-  return parentCommand.command("activate").description("Activate your license key for MakerKit").action(async () => {
-    const params = await prompts2([
-      {
-        type: "text",
-        name: "licenseKey",
-        message: `Enter your ${chalk4.cyan("License Key")}.`,
-        validate: (value) => {
-          if (value.length < 1) {
-            return `Please enter a valid license key`;
-          }
-          return true;
-        }
-      },
-      {
-        type: "text",
-        name: "githubUsername",
-        message: `Enter your ${chalk4.cyan("Github username")}.`,
-        validate: (value) => {
-          if (value.length < 1) {
-            return `Please enter a valid username`;
-          }
-          return true;
-        }
-      }
-    ]);
-    const spinner = ora(`Activating license...`).start();
-    const onError = () => {
-      spinner.fail(`Failed to activate license`);
-      process.exit(1);
-    };
-    try {
-      const response = await activateLicense(schema.parse(params));
-      if (!response.ok) {
-        return onError();
-      }
-      spinner.succeed(`License activated successfully`);
-    } catch (e) {
-      onError();
-    }
-  });
-}
-async function activateLicense(params) {
-  return fetch(`https://makerkit.dev/api/ls/license/activate`, {
-    method: "POST",
-    body: JSON.stringify(params)
-  });
-}
-
-// src/commands/license/license.command.ts
-import { Command as Command2 } from "commander";
-var licenseCommand = new Command2().name("license").description("Manage Licenses");
-createActivateLicenseCommand(licenseCommand);
+// 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"
+  }
+];
 
 // src/commands/new/new.command.ts
-import { join as join3 } from "path";
-import chalk5 from "chalk";
-import { Command as Command3 } from "commander";
-import { execa } from "execa";
-import ora2 from "ora";
-import prompts3 from "prompts";
-var newCommand = new Command3().name("new").description("Initialize a new Makerkit project").action(async () => {
-  const choices = Object.values(KitsModel).map((kit2) => {
-    return {
-      title: kit2.name,
-      value: kit2.id
-    };
-  });
-  const { kit, name: projectName } = await prompts3([
+var newCommand = new Command().name("new").description("Initialize a new Makerkit project").action(async () => {
+  const choices = VARIANT_CATALOG.map((v) => ({
+    title: v.name,
+    value: v.id
+  }));
+  const { kit, name: projectName } = await prompts([
     {
       type: "select",
       name: "kit",
-      message: `Select the ${chalk5.cyan(`SaaS Kit`)} you want to clone`,
+      message: `Select the ${chalk.cyan(`SaaS Kit`)} you want to clone`,
       choices
     },
     {
       type: "text",
       name: "name",
-      message: `Enter your ${chalk5.cyan("Project Name")}.`
+      message: `Enter your ${chalk.cyan("Project Name")}.`
     }
   ]);
-  const { repository, name: kitName } = validateKit(kit);
-  const { confirm } = await prompts3([
+  const selected = VARIANT_CATALOG.find((v) => v.id === kit);
+  if (!selected) {
+    console.log("Invalid kit selection. Aborting...");
+    process.exit(1);
+  }
+  const { confirm } = await prompts([
     {
       type: "confirm",
       name: "confirm",
-      message: `Are you sure you want to clone ${chalk5.cyan(
-        kitName
-      )} to ${chalk5.cyan(projectName)}?`
+      message: `Are you sure you want to clone ${chalk.cyan(
+        selected.name
+      )} to ${chalk.cyan(projectName)}?`
     }
   ]);
   if (!confirm) {
     console.log("Aborting...");
     process.exit(0);
   }
-  await pullFromGithub(repository, kitName, projectName);
-  await installDependencies(projectName);
-});
-async function pullFromGithub(repository, kit, projectName) {
-  const spinner = ora2(`Cloning ${kit}...`).start();
-  try {
-    await execa("git", ["clone", repository, projectName]);
-    spinner.succeed(`Cloned ${kit} to ${projectName}...`);
-  } catch (e) {
-    console.error(e);
-    spinner.fail(`Failed to clone ${kit}`);
-    return Promise.reject(`Failed to clone ${kit}`);
-  }
-}
-async function installDependencies(projectName) {
-  const cwd = join3(process.cwd(), projectName);
-  const spinner = ora2(`Installing dependencies. Please wait...`).start();
+  const spinner = ora(`Cloning ${selected.name}...`).start();
   try {
-    await execa("npm", ["install"], { cwd });
-    spinner.succeed(`Dependencies successfully installed!`);
+    const result = await createProject({
+      variant: selected.id,
+      name: projectName,
+      directory: process.cwd()
+    });
+    spinner.succeed(`${result.message}`);
     console.log(
-      `\u{1F389} You can now get started. Open the project in your IDE and read the README.md file for more information.`
+      `You can now get started. Open the project in your IDE and read the README.md file for more information.`
     );
   } catch (e) {
     console.error(e);
-    spinner.fail(`Failed to install dependencies`);
-    return Promise.reject(`Failed to install dependencies`);
+    spinner.fail(`Failed to create project`);
+    process.exit(1);
   }
-}
+});
 
-// src/commands/plugins/plugins-service.ts
-import chalk6 from "chalk";
-import { execaCommand } from "execa";
-import ora3 from "ora";
-import prompts4 from "prompts";
-var PluginsService = class {
-  static async install(pluginId) {
-    const action = "add" /* Add */;
-    const plugin = pluginId || await getPluginFromPrompts(action);
-    await initPluginCommand(plugin, action);
-  }
-  static async pull(pluginId) {
-    const action = "pull" /* Pull */;
-    const plugin = pluginId || await getPluginFromPrompts(action);
-    await initPluginCommand(plugin, action);
+// src/plugins-model.ts
+import { join as join4 } from "path";
+import fs4 from "fs-extra";
+import invariant from "tiny-invariant";
+
+// src/utils/plugins-cache.ts
+import { join as join3 } from "path";
+import { homedir } from "os";
+import fs3 from "fs-extra";
+var CACHE_DIR = join3(homedir(), ".makerkit");
+var CACHE_FILE = join3(CACHE_DIR, "plugins.json");
+var CACHE_TTL_MS = 60 * 60 * 1e3;
+async function readCache() {
+  try {
+    if (!await fs3.pathExists(CACHE_FILE)) {
+      return null;
+    }
+    return await fs3.readJson(CACHE_FILE);
+  } catch {
+    return null;
   }
-};
-async function initPluginCommand(pluginId, action) {
-  const { id: kitId } = await Workspace.getKitMeta();
-  const plugin = validatePlugin(pluginId);
-  const kit = validateKit(kitId);
-  if (!kit.plugins.includes(plugin.id)) {
-    throw new Error(
-      `Plugin ${plugin.name} is not compatible with kit ${kit.name}`
+}
+async function writeCache(plugins) {
+  try {
+    await fs3.ensureDir(CACHE_DIR);
+    await fs3.writeJson(
+      CACHE_FILE,
+      { fetchedAt: Date.now(), plugins },
+      { spaces: 2 }
     );
+  } catch {
   }
-  const repository = buildPluginRepositoryName(kit.repository);
-  const verb = action === "add" /* Add */ ? "Installing" : "Updating";
-  console.log(
-    `${verb} ${chalk6.cyan(plugin.name)} to kit ${chalk6.cyan(
-      kit.name
-    )} using repo: ${repository} ...`
-  );
-  return executePluginCommand({
-    action,
-    repository,
-    branch: plugin.branch,
-    folder: plugin.folder
-  });
 }
-async function getPluginFromPrompts(action) {
-  const kit = await Workspace.getKitMeta();
-  const choices = Object.values(PluginsModel).filter((plugin2) => {
-    return kit.plugins.includes(plugin2.id);
-  }).map((plugin2) => {
-    return {
-      title: plugin2.name,
-      value: plugin2.id
-    };
-  });
-  const verb = action === "add" /* Add */ ? "install" : "update";
-  const { plugin } = await prompts4([
-    {
-      type: "select",
-      name: "plugin",
-      message: `Which ${chalk6.cyan("Plugin")} would you like to ${verb}?`,
-      choices
-    }
-  ]);
-  return plugin;
-}
-function buildPluginRepositoryName(repository) {
-  return repository + `-plugins.git`;
-}
-async function executePluginCommand({
-  action,
-  repository,
-  branch,
-  folder
-}) {
-  const verb = action === "add" /* Add */ ? "Installing" : "Updating";
-  const spinner = ora3(`${verb} plugin...`).start();
-  const commandString = `git subtree ${action} --prefix ${folder} ${repository} ${branch} --squash`;
+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 {
-    await execaCommand(commandString);
-    const verb2 = action === "add" /* Add */ ? "installed" : "updated";
-    spinner.succeed(`Plugin ${verb2} at ${folder}`);
-  } catch (e) {
-    console.error(e);
-    const verb2 = action === "add" /* Add */ ? "installation" : "update";
-    spinner.fail(`Plugin ${verb2} failed`);
+    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/commands/plugins/install/install-plugin.command.ts
-function createInstallPluginCommand(parentCommand) {
-  return parentCommand.command("install").argument("[plugin-id]", "Plugin id").description("Install plugin").action(async (maybePluginId) => {
-    await PluginsService.install(maybePluginId);
-  });
-}
-
-// src/commands/plugins/list/list-plugins.command.ts
-import chalk7 from "chalk";
-function createListPluginsCommand(parentCommand) {
-  return parentCommand.command("list").description("List available plugins.").action(() => {
-    const kits = Object.values(KitsModel);
-    console.log(chalk7.white("Makerkit available plugins..."));
-    console.log(
-      `[${chalk7.green("Plugin Name")} (${chalk7.gray("plugin-id")})]
-`
-    );
-    for (const kit of kits) {
-      console.log(`${chalk7.cyan(kit.name)}`);
-      if (!kit.plugins.length) {
-        console.log(chalk7.yellow(`- No plugins available`) + "\n");
-        continue;
+// 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"
       }
-      for (const plugin of kit.plugins) {
-        const { name, id } = validatePlugin(plugin);
-        console.log(`- ${chalk7.green(name)} (${chalk7.gray(id)})`);
+    }
+  },
+  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"
       }
-      console.log("");
     }
-  });
-}
-
-// src/commands/plugins/update/update-plugin.command.ts
-function createUpdatePluginCommand(parentCommand) {
-  return parentCommand.command("update").argument("[plugin-id]", "Plugin id").description("Update plugin to the latest version").action(async (maybePluginId) => {
-    await PluginsService.pull(maybePluginId);
-  });
-}
-
-// src/commands/plugins/plugins.command.ts
-import { Command as Command4 } from "commander";
-var pluginsCommand = new Command4().name("plugins").description("List and install plugins.").hook("preAction", () => {
-  return Workspace.logWorkspaceInfo();
-});
-createListPluginsCommand(pluginsCommand);
-createInstallPluginCommand(pluginsCommand);
-createUpdatePluginCommand(pluginsCommand);
-
-// src/index.ts
-import { Command as Command5 } from "commander";
+  },
+  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 = join4(process.cwd(), pluginPath, "package.json");
+  if (!await fs4.pathExists(pkgJsonPath)) {
+    return false;
+  }
+  try {
+    const pkg = await fs4.readJson(pkgJsonPath);
+    return !!pkg.name && !!pkg.exports;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/base-store.ts
+import { dirname, join as join5 } from "path";
+import fs5 from "fs-extra";
+function basesDir(pluginId) {
+  return join5(process.cwd(), "node_modules", ".cache", "makerkit", "bases", pluginId);
+}
+async function saveBaseVersions(pluginId, files) {
+  const dir = basesDir(pluginId);
+  for (const file of files) {
+    const targetPath = join5(dir, file.target);
+    await fs5.ensureDir(dirname(targetPath));
+    await fs5.writeFile(targetPath, file.content);
+  }
+}
+
+// src/utils/git.ts
+import { execaCommand as execaCommand2 } 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 execaCommand2("git status --porcelain");
+  return stdout.trim() === "";
+}
+async function getGitUsername() {
+  try {
+    const { stdout } = await execaCommand2("git config --get user.username");
+    const username = stdout.trim();
+    return username.length > 0 ? username : void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/utils/install-registry-files.ts
+import { dirname as dirname2, join as join6 } from "path";
+import fs6 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 = join6(cwd, file.target);
+    await fs6.ensureDir(dirname2(targetPath));
+    await fs6.writeFile(targetPath, file.content);
+  }
+  return item;
+}
+
+// src/utils/run-codemod.ts
+import { execaCommand as execaCommand3 } 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 execaCommand3(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 join7 } from "path";
+import { tmpdir } from "os";
+import fs7 from "fs-extra";
+import prompts2 from "prompts";
+var USERNAME_FILE = join7(tmpdir(), "makerkit-username");
+function getCachedUsername() {
+  try {
+    const username = fs7.readFileSync(USERNAME_FILE, "utf-8").trim();
+    return username.length > 0 ? username : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function cacheUsername(username) {
+  fs7.writeFileSync(USERNAME_FILE, username, "utf-8");
+}
+function clearCachedUsername() {
+  try {
+    fs7.removeSync(USERNAME_FILE);
+  } catch {
+  }
+}
+async function promptForUsername() {
+  const gitUsername = await getGitUsername();
+  const response = await prompts2({
+    type: "text",
+    name: "githubUsername",
+    message: "Enter the GitHub username registered with your Makerkit account",
+    initial: gitUsername,
+    validate: (value) => {
+      return value.trim().length > 0 ? true : "GitHub username is required";
+    }
+  });
+  const username = response.githubUsername?.trim();
+  if (!username) {
+    throw new Error("Setup cancelled. GitHub username is required.");
+  }
+  cacheUsername(username);
+  return username;
+}
+async function getOrPromptUsername(providedUsername) {
+  if (providedUsername?.trim()) {
+    const username = providedUsername.trim();
+    cacheUsername(username);
+    return username;
+  }
+  const cached = getCachedUsername();
+  if (cached) {
+    return cached;
+  }
+  return promptForUsername();
+}
+
+// src/utils/workspace.ts
+import { join as join8 } from "path";
+import fs8 from "fs-extra";
+async function readDeps(pkgPath) {
+  if (!await fs8.pathExists(pkgPath)) {
+    return {};
+  }
+  const pkg = await fs8.readJson(pkgPath);
+  return {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+}
+async function detectVariant() {
+  const cwd = process.cwd();
+  const rootPkgPath = join8(cwd, "package.json");
+  if (!await fs8.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(join8(cwd, "apps", "web", "package.json"));
+  const dbDeps = await readDeps(
+    join8(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 fs8.readJson(join8(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/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/commands/plugins/add/add.command.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+import prompts3 from "prompts";
+function createAddCommand(parentCommand) {
+  return parentCommand.command("add").argument("[plugin-id...]", "Plugins to install (e.g. feedback waitlist)").description("Install one or more MakerKit plugins.").action(async (pluginIds) => {
+    try {
+      const gitClean = await isGitClean();
+      if (!gitClean) {
+        console.error(
+          chalk2.red(
+            "Your git working directory has uncommitted changes. Please commit or stash them before adding a plugin."
+          )
+        );
+        process.exit(1);
+      }
+      if (!pluginIds || pluginIds.length === 0) {
+        const pluginsResult = await listPlugins({ projectPath: process.cwd() });
+        const available = pluginsResult.plugins.filter((p) => !p.installed);
+        if (available.length === 0) {
+          console.log(chalk2.green("All plugins are already installed."));
+          return;
+        }
+        const response = await prompts3({
+          type: "multiselect",
+          name: "pluginIds",
+          message: "Select plugins to install",
+          choices: available.map((p) => ({
+            title: `${p.name} ${chalk2.gray(`(${p.id})`)}`,
+            value: p.id
+          }))
+        });
+        pluginIds = response.pluginIds ?? [];
+        if (pluginIds.length === 0) {
+          return;
+        }
+      }
+      let username = await getOrPromptUsername();
+      for (const pluginId of pluginIds) {
+        console.log(
+          `
+Installing ${chalk2.cyan(pluginId)}...
+`
+        );
+        const filesSpinner = ora2("Installing plugin...").start();
+        let result;
+        try {
+          result = await addPlugin({
+            projectPath: process.cwd(),
+            pluginId,
+            githubUsername: username,
+            skipGitCheck: true,
+            captureCodemodOutput: false
+          });
+        } catch (error) {
+          filesSpinner.fail("Failed to install plugin.");
+          clearCachedUsername();
+          console.log(
+            chalk2.yellow("\nRetrying with a different username...\n")
+          );
+          username = await getOrPromptUsername();
+          const retrySpinner = ora2("Installing plugin...").start();
+          try {
+            result = await addPlugin({
+              projectPath: process.cwd(),
+              pluginId,
+              githubUsername: username,
+              skipGitCheck: true,
+              captureCodemodOutput: false
+            });
+          } catch (retryError) {
+            retrySpinner.fail("Failed to install plugin.");
+            const message = retryError instanceof Error ? retryError.message : "Unknown error";
+            console.error(chalk2.red(`
+Error installing "${pluginId}": ${message}`));
+            console.log(
+              chalk2.yellow(
+                "\nTo revert changes, run: git checkout . && git clean -fd"
+              )
+            );
+            process.exit(1);
+          }
+          if (result.success) {
+            retrySpinner.succeed("Plugin installed.");
+          } else {
+            retrySpinner.stop();
+          }
+        }
+        if (!result.success) {
+          if (result.reason.includes("already installed")) {
+            filesSpinner.warn(result.reason + " Skipping.");
+            continue;
+          }
+          filesSpinner.fail("Failed to install plugin.");
+          console.error(chalk2.red(`
+${result.reason}`));
+          console.log(
+            chalk2.yellow(
+              "\nTo revert changes, run: git checkout . && git clean -fd"
+            )
+          );
+          process.exit(1);
+        }
+        if (result.codemodWarning) {
+          filesSpinner.warn(
+            `${result.pluginName} installed with warnings \u2014 some automated steps may not have completed.`
+          );
+          console.log(chalk2.yellow(`
+${result.codemodWarning}`));
+          console.log(
+            chalk2.yellow(
+              "\nPlugin files were written successfully. Review the changes with `git diff` and complete any missing steps manually."
+            )
+          );
+        } else if (filesSpinner.isSpinning) {
+          filesSpinner.succeed(`${result.pluginName} installed successfully!`);
+        }
+        if (result.envVars.length > 0) {
+          console.log(chalk2.white("\nEnvironment variables to configure:"));
+          for (const envVar of result.envVars) {
+            console.log(
+              `  ${chalk2.cyan(envVar.key)} - ${envVar.description}`
+            );
+          }
+        }
+        if (result.postInstallMessage) {
+          console.log(chalk2.white("\nNext steps:"));
+          console.log(`  ${chalk2.cyan(result.postInstallMessage)}`);
+        }
+      }
+      console.log("");
+      console.log(chalk2.yellow("Important:"));
+      console.log(
+        chalk2.yellow(
+          "  This plugin was installed using an automated migration."
+        )
+      );
+      console.log(
+        chalk2.yellow(
+          "  Please review the changes manually and test thoroughly before committing."
+        )
+      );
+      console.log("");
+      console.log(chalk2.white("Tips:"));
+      console.log(
+        `  ${chalk2.gray("-")} Run ${chalk2.cyan("git diff")} to review all changes made by the migration.`
+      );
+      console.log(
+        `  ${chalk2.gray("-")} Use an AI assistant (e.g. Claude) as a first pass to review the diff for issues.`
+      );
+      console.log(
+        `  ${chalk2.gray("-")} Run your test suite and verify the app builds before committing.`
+      );
+      console.log(
+        `  ${chalk2.gray("-")} To undo all changes: ${chalk2.cyan("git checkout . && git clean -fd")}`
+      );
+      console.log("");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(chalk2.red(`Error: ${message}`));
+      console.log(
+        chalk2.yellow(
+          "\nTo revert changes, run: git checkout . && git clean -fd"
+        )
+      );
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/plugins/diff/diff.command.ts
+import { dirname as dirname3, join as join9 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import chalk3 from "chalk";
+import { execa as execa2 } from "execa";
+import fs9 from "fs-extra";
+import ora3 from "ora";
+import prompts4 from "prompts";
+function createDiffCommand(parentCommand) {
+  return parentCommand.command("diff").argument("[plugin-id]", "Plugin to diff (e.g. feedback, waitlist)").description("Show differences between installed plugin files and the latest registry version.").action(async (pluginId) => {
+    try {
+      const { variant } = await validateProject();
+      const registry = await PluginRegistry.load();
+      if (!pluginId) {
+        const plugins = registry.getPluginsForVariant(variant);
+        const installed = [];
+        for (const p of plugins) {
+          if (await isInstalled(p, variant)) {
+            installed.push(p);
+          }
+        }
+        if (installed.length === 0) {
+          console.log(chalk3.yellow("No plugins installed."));
+          return;
+        }
+        const response = await prompts4({
+          type: "select",
+          name: "pluginId",
+          message: "Select a plugin to diff",
+          choices: installed.map((p) => ({
+            title: `${p.name} ${chalk3.gray(`(${p.id})`)}`,
+            value: p.id
+          }))
+        });
+        pluginId = response.pluginId;
+        if (!pluginId) {
+          return;
+        }
+      }
+      const plugin = registry.validatePlugin(pluginId, variant);
+      if (!await isInstalled(plugin, variant)) {
+        console.error(
+          chalk3.yellow(`Plugin "${plugin.name}" is not installed.`)
+        );
+        return;
+      }
+      const username = await getOrPromptUsername();
+      const spinner = ora3("Fetching latest plugin files...").start();
+      const item = await fetchRegistryItem(variant, pluginId, username);
+      spinner.succeed("Fetched latest plugin files.");
+      const tempDir = join9(tmpdir2(), `makerkit-diff-${pluginId}`);
+      await fs9.ensureDir(tempDir);
+      try {
+        const cwd = process.cwd();
+        let hasDiff = false;
+        for (const file of item.files) {
+          const localPath = join9(cwd, file.target);
+          const remotePath = join9(tempDir, file.target);
+          await fs9.ensureDir(dirname3(join9(tempDir, file.target)));
+          await fs9.writeFile(remotePath, file.content);
+          if (!await fs9.pathExists(localPath)) {
+            console.log(chalk3.green(`
+New file: ${file.target}`));
+            hasDiff = true;
+            continue;
+          }
+          const localContent = await fs9.readFile(localPath, "utf-8");
+          if (localContent !== file.content) {
+            hasDiff = true;
+            console.log(chalk3.white(`
+--- ${file.target}`));
+            await execa2("git", ["diff", "--no-index", "--color", "--", localPath, remotePath], {
+              stdio: "inherit",
+              reject: false
+            });
+          }
+        }
+        if (!hasDiff) {
+          console.log(
+            chalk3.green(`
+${plugin.name} is up to date.`)
+          );
+        }
+      } finally {
+        await fs9.remove(tempDir);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(chalk3.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/utils/init-registry.ts
+async function initRegistry(options) {
+  const variant = await detectVariant();
+  cacheUsername(options.githubUsername);
+  return {
+    success: true,
+    variant,
+    username: options.githubUsername
+  };
+}
+
+// src/commands/plugins/init/init.command.ts
+import chalk4 from "chalk";
+function createInitCommand(parentCommand) {
+  return parentCommand.command("init").description(
+    "Initialize MakerKit plugin registry in your project (one-time setup)."
+  ).action(async () => {
+    try {
+      const username = await getOrPromptUsername();
+      const initResult = await initRegistry({
+        projectPath: process.cwd(),
+        githubUsername: username
+      });
+      console.log(
+        `Detected project variant: ${chalk4.cyan(initResult.variant)}
+`
+      );
+      console.log(chalk4.green("Registry configured.\n"));
+      const pluginsResult = await listPlugins({ projectPath: process.cwd() });
+      console.log(chalk4.white("Available plugins:\n"));
+      for (const plugin of pluginsResult.plugins) {
+        console.log(
+          `  ${chalk4.green(plugin.name)} ${chalk4.gray(`(${plugin.id})`)}`
+        );
+      }
+      console.log(
+        `
+Run ${chalk4.cyan("makerkit plugins add <plugin-id>")} to install a plugin.`
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(chalk4.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/plugins/list/list-plugins.command.ts
+import chalk5 from "chalk";
+function createListPluginsCommand(parentCommand) {
+  return parentCommand.command("list").description("List available and installed plugins.").action(async () => {
+    const result = await listPlugins({ projectPath: process.cwd() });
+    console.log(
+      chalk5.white(`MakerKit Plugins ${chalk5.gray(`(${result.variant})`)}
+`)
+    );
+    console.log(
+      `  ${chalk5.green("Plugin Name")} ${chalk5.gray("(plugin-id)")} \u2014 Status
+`
+    );
+    let installedCount = 0;
+    for (const plugin of result.plugins) {
+      if (plugin.installed) {
+        installedCount++;
+      }
+      const status = plugin.installed ? chalk5.green("installed") : chalk5.gray("available");
+      console.log(
+        `  ${chalk5.cyan(plugin.name)} ${chalk5.gray(`(${plugin.id})`)} \u2014 ${status}`
+      );
+    }
+    console.log(
+      `
+  ${chalk5.white(`${installedCount} installed`)} / ${chalk5.gray(`${result.plugins.length} available`)}
+`
+    );
+    if (installedCount === 0) {
+      console.log(
+        `Run ${chalk5.cyan("makerkit plugins init")} to set up the registry, then ${chalk5.cyan("makerkit plugins add <plugin-id>")} to install.`
+      );
+    }
+  });
+}
+
+// src/commands/plugins/outdated/outdated.command.ts
+import { join as join10 } from "path";
+import chalk6 from "chalk";
+import fs10 from "fs-extra";
+import ora4 from "ora";
+async function isOutdated(plugin, variant, username) {
+  const item = await fetchRegistryItem(variant, plugin.id, username);
+  const cwd = process.cwd();
+  for (const file of item.files) {
+    const localPath = join10(cwd, file.target);
+    if (!await fs10.pathExists(localPath)) {
+      return true;
+    }
+    const localContent = await fs10.readFile(localPath, "utf-8");
+    if (localContent !== file.content) {
+      return true;
+    }
+  }
+  return false;
+}
+function createOutdatedCommand(parentCommand) {
+  return parentCommand.command("outdated").description("Check installed plugins for updates.").action(async () => {
+    try {
+      const { variant } = await validateProject();
+      const registry = await PluginRegistry.load();
+      const plugins = registry.getPluginsForVariant(variant);
+      const installed = [];
+      for (const p of plugins) {
+        if (await isInstalled(p, variant)) {
+          installed.push(p);
+        }
+      }
+      if (installed.length === 0) {
+        console.log(chalk6.yellow("No plugins installed."));
+        return;
+      }
+      const username = await getOrPromptUsername();
+      const spinner = ora4(
+        `Checking ${installed.length} plugin${installed.length > 1 ? "s" : ""} for updates...`
+      ).start();
+      const outdated = [];
+      for (const plugin of installed) {
+        try {
+          if (await isOutdated(plugin, variant, username)) {
+            outdated.push(plugin);
+          }
+        } catch {
+        }
+      }
+      spinner.stop();
+      if (outdated.length === 0) {
+        console.log(chalk6.green("All plugins are up to date."));
+        return;
+      }
+      console.log(
+        chalk6.yellow(
+          `
+${outdated.length} plugin${outdated.length > 1 ? "s have" : " has"} updates available:
+`
+        )
+      );
+      for (const plugin of outdated) {
+        const pluginPath = getPath(plugin, variant);
+        console.log(
+          `  ${chalk6.cyan(plugin.name)} ${chalk6.gray(`(${plugin.id})`)}${pluginPath ? chalk6.gray(` \u2014 ${pluginPath}`) : ""}`
+        );
+      }
+      console.log(
+        `
+Run ${chalk6.cyan("makerkit plugins diff <plugin-id>")} to see what changed.`
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(chalk6.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/plugins/update/update.command.ts
+import { dirname as dirname4, join as join11 } from "path";
+import chalk7 from "chalk";
+import fs11 from "fs-extra";
+import ora5 from "ora";
+import prompts5 from "prompts";
+function createUpdateCommand(parentCommand) {
+  return parentCommand.command("update").argument("[plugin-id...]", "Plugins to update (e.g. feedback waitlist)").description("Update installed plugins to the latest registry version.").action(async (pluginIds) => {
+    try {
+      const { variant } = await validateProject();
+      const registry = await PluginRegistry.load();
+      if (!pluginIds || pluginIds.length === 0) {
+        const plugins = registry.getPluginsForVariant(variant);
+        const installed = [];
+        for (const p of plugins) {
+          if (await isInstalled(p, variant)) {
+            installed.push(p);
+          }
+        }
+        if (installed.length === 0) {
+          console.log(chalk7.yellow("No plugins installed."));
+          return;
+        }
+        const response = await prompts5({
+          type: "multiselect",
+          name: "pluginIds",
+          message: "Select plugins to update",
+          choices: installed.map((p) => ({
+            title: `${p.name} ${chalk7.gray(`(${p.id})`)}`,
+            value: p.id
+          }))
+        });
+        pluginIds = response.pluginIds ?? [];
+        if (pluginIds.length === 0) {
+          return;
+        }
+      }
+      const username = await getOrPromptUsername();
+      for (const pluginId of pluginIds) {
+        const plugin = registry.validatePlugin(pluginId, variant);
+        if (!await isInstalled(plugin, variant)) {
+          console.log(
+            chalk7.yellow(
+              `Plugin "${plugin.name}" is not installed. Use "plugins add ${pluginId}" to install it.`
+            )
+          );
+          continue;
+        }
+        const spinner = ora5(`Fetching latest ${plugin.name} files...`).start();
+        const item = await fetchRegistryItem(variant, pluginId, username);
+        spinner.succeed(`Fetched latest ${plugin.name} files.`);
+        const cwd = process.cwd();
+        const modifiedFiles = [];
+        for (const file of item.files) {
+          const localPath = join11(cwd, file.target);
+          if (await fs11.pathExists(localPath)) {
+            const localContent = await fs11.readFile(localPath, "utf-8");
+            if (localContent !== file.content) {
+              modifiedFiles.push(file.target);
+            }
+          }
+        }
+        if (modifiedFiles.length === 0) {
+          console.log(chalk7.green(`${plugin.name} is already up to date.`));
+          continue;
+        }
+        console.log(
+          chalk7.yellow(
+            `
+${modifiedFiles.length} file${modifiedFiles.length > 1 ? "s" : ""} will be overwritten:`
+          )
+        );
+        for (const file of modifiedFiles) {
+          console.log(`  ${chalk7.gray(file)}`);
+        }
+        const { confirm } = await prompts5({
+          type: "confirm",
+          name: "confirm",
+          message: `Update ${plugin.name}? Local changes will be lost.`,
+          initial: false
+        });
+        if (!confirm) {
+          console.log(chalk7.gray(`Skipped ${plugin.name}.`));
+          continue;
+        }
+        const writeSpinner = ora5(`Updating ${plugin.name}...`).start();
+        for (const file of item.files) {
+          const targetPath = join11(cwd, file.target);
+          await fs11.ensureDir(dirname4(targetPath));
+          await fs11.writeFile(targetPath, file.content);
+        }
+        await saveBaseVersions(pluginId, item.files);
+        writeSpinner.succeed(`${plugin.name} updated.`);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(chalk7.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/plugins/plugins.command.ts
+import { Command as Command2 } from "commander";
+var pluginsCommand = new Command2().name("plugins").description("Manage MakerKit plugins.");
+createInitCommand(pluginsCommand);
+createAddCommand(pluginsCommand);
+createUpdateCommand(pluginsCommand);
+createDiffCommand(pluginsCommand);
+createOutdatedCommand(pluginsCommand);
+createListPluginsCommand(pluginsCommand);
+
+// src/utils/project-pull.ts
+import { join as join12 } from "path";
+import { execa as execa3, execaCommand as execaCommand4 } from "execa";
+import fs12 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 fs12.readFile(join12(cwd, filePath), "utf-8");
+        } catch {
+          conflicted = void 0;
+        }
+        let base;
+        let ours;
+        let theirs;
+        try {
+          const { stdout: b } = await execa3("git", [
+            "show",
+            `:1:${filePath}`
+          ]);
+          base = b;
+        } catch {
+          base = void 0;
+        }
+        try {
+          const { stdout: o } = await execa3("git", [
+            "show",
+            `:2:${filePath}`
+          ]);
+          ours = o;
+        } catch {
+          ours = void 0;
+        }
+        try {
+          const { stdout: t } = await execa3("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/commands/project/update/update.command.ts
+import chalk8 from "chalk";
+import ora6 from "ora";
+function createProjectUpdateCommand(parentCommand) {
+  return parentCommand.command("update").description(
+    "Pull the latest changes from the upstream MakerKit repository."
+  ).action(async () => {
+    try {
+      const spinner = ora6("Pulling latest changes from upstream...").start();
+      const result = await projectPull({ projectPath: process.cwd() });
+      if (result.success) {
+        const displayName = VARIANT_CATALOG.find((v) => v.id === result.variant)?.name ?? result.variant;
+        if (result.alreadyUpToDate) {
+          spinner.succeed(
+            `Already up to date. (${chalk8.cyan(displayName)})`
+          );
+        } else {
+          spinner.succeed(
+            `Successfully pulled latest changes from upstream. (${chalk8.cyan(displayName)})`
+          );
+        }
+      } else if ("hasConflicts" in result) {
+        spinner.fail("Merge conflicts detected.");
+        console.log(
+          chalk8.yellow(
+            `
+${result.conflictCount} conflicting file(s):`
+          )
+        );
+        for (const conflict of result.conflicts) {
+          console.log(`  ${chalk8.gray("-")} ${conflict.path}`);
+        }
+        console.log(
+          chalk8.yellow("\nPlease resolve them manually:")
+        );
+        console.log(chalk8.gray("  1. Fix the conflicting files"));
+        console.log(chalk8.gray("  2. Run: git add ."));
+        console.log(chalk8.gray("  3. Run: git commit"));
+        process.exit(1);
+      } else {
+        spinner.fail("Failed to pull from upstream.");
+        console.error(chalk8.red(`
+${result.reason}`));
+        process.exit(1);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      console.error(chalk8.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/project/project.command.ts
+import { Command as Command3 } from "commander";
+var projectCommand = new Command3().name("project").description("Manage your MakerKit project.");
+createProjectUpdateCommand(projectCommand);
+
+// src/index.ts
+import { Command as Command4 } from "commander";
 import { config } from "dotenv";
 config({
   path: ".env.local"
@@ -767,10 +1654,10 @@ config({
 process.on("SIGINT", () => process.exit(0));
 process.on("SIGTERM", () => process.exit(0));
 async function main() {
-  const program = new Command5().name("makerkit").description(
+  const program = new Command4().name("makerkit").description(
     "Your SaaS Kit companion. Add plugins, manage migrations, and more."
-  ).version("-v, --version", "display the version number");
-  program.addCommand(newCommand).addCommand(pluginsCommand).addCommand(i18nCommand).addCommand(licenseCommand);
+  ).version(CLI_VERSION, "-v, --version", "display the version number");
+  program.addCommand(newCommand).addCommand(pluginsCommand).addCommand(projectCommand);
   program.parse();
 }
 void main();