@moneydevkit/create 0.3.2 → 0.4.0-beta.0

package/dist/index.cjs

@@ -28,8 +28,8 @@ var import_client = require("@orpc/client");
 var import_fetch = require("@orpc/client/fetch");
 var p = __toESM(require("@clack/prompts"), 1);
 var import_minimist = __toESM(require("minimist"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
-var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_fs5 = __toESM(require("fs"), 1);
 var import_node_os = __toESM(require("os"), 1);
 var import_open = __toESM(require("open"), 1);
 var import_clipboardy = __toESM(require("clipboardy"), 1);
@@ -72,6 +72,392 @@ function deriveProjectName(input, webhookUrl) {
   return webhookUrl;
 }
 
+// src/utils/nextjs-detector.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_semver = __toESM(require("semver"), 1);
+var NEXT_CONFIG_BASENAMES = [
+  "next.config.js",
+  "next.config.cjs",
+  "next.config.mjs",
+  "next.config.ts",
+  "next.config.mts"
+];
+var APP_DIR_CANDIDATES = ["app", import_node_path2.default.join("src", "app")];
+var PAGES_DIR_CANDIDATES = ["pages", import_node_path2.default.join("src", "pages")];
+function fileExists(target) {
+  try {
+    return import_node_fs.default.existsSync(target);
+  } catch {
+    return false;
+  }
+}
+function readPackageJson(pkgPath) {
+  try {
+    const content = import_node_fs.default.readFileSync(pkgPath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function hasNextDependency(pkg) {
+  const deps = pkg.dependencies;
+  const devDeps = pkg.devDependencies;
+  return Boolean(deps?.next || devDeps?.next);
+}
+function extractNextVersion(pkg) {
+  const deps = pkg.dependencies;
+  const devDeps = pkg.devDependencies;
+  return deps?.next ?? devDeps?.next ?? void 0;
+}
+function findNearestPackageJson(startDir) {
+  let current = import_node_path2.default.resolve(startDir);
+  while (true) {
+    const candidate = import_node_path2.default.join(current, "package.json");
+    if (fileExists(candidate)) {
+      return candidate;
+    }
+    const parent = import_node_path2.default.dirname(current);
+    if (parent === current) {
+      return void 0;
+    }
+    current = parent;
+  }
+}
+function findNextConfig(rootDir) {
+  for (const basename of NEXT_CONFIG_BASENAMES) {
+    const candidate = import_node_path2.default.join(rootDir, basename);
+    if (fileExists(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function detectNextJsProject(startDir) {
+  const pkgPath = findNearestPackageJson(startDir);
+  const rootDir = pkgPath ? import_node_path2.default.dirname(pkgPath) : import_node_path2.default.resolve(startDir);
+  const pkg = pkgPath ? readPackageJson(pkgPath) : null;
+  const hasNext = pkg ? hasNextDependency(pkg) : false;
+  const nextVersion = pkg ? extractNextVersion(pkg) : void 0;
+  let versionIsSupported = true;
+  if (nextVersion) {
+    const minVersion = import_semver.default.minVersion(nextVersion);
+    if (minVersion) {
+      versionIsSupported = import_semver.default.gte(minVersion, "15.0.0");
+    }
+  }
+  const nextConfigPath = findNextConfig(rootDir);
+  const appDir = APP_DIR_CANDIDATES.map((candidate) => import_node_path2.default.join(rootDir, candidate)).find(
+    (candidate) => fileExists(candidate)
+  );
+  const pagesDir = PAGES_DIR_CANDIDATES.map((candidate) => import_node_path2.default.join(rootDir, candidate)).find(
+    (candidate) => fileExists(candidate)
+  );
+  const usesTypeScript = fileExists(import_node_path2.default.join(rootDir, "tsconfig.json")) || fileExists(import_node_path2.default.join(rootDir, "next-env.d.ts"));
+  const found = Boolean(hasNext || nextConfigPath || appDir || pagesDir);
+  return {
+    found,
+    rootDir: found ? rootDir : void 0,
+    nextConfigPath,
+    appDir,
+    pagesDir,
+    usesTypeScript,
+    nextVersion,
+    versionIsSupported
+  };
+}
+
+// src/scaffold/nextjs.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_node_child_process = require("child_process");
+
+// src/utils/package-manager.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+function detectPackageManager(rootDir) {
+  if (import_node_fs2.default.existsSync(import_node_path3.default.join(rootDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (import_node_fs2.default.existsSync(import_node_path3.default.join(rootDir, "yarn.lock"))) return "yarn";
+  if (import_node_fs2.default.existsSync(import_node_path3.default.join(rootDir, "bun.lockb"))) return "bun";
+  if (import_node_fs2.default.existsSync(import_node_path3.default.join(rootDir, "package-lock.json"))) return "npm";
+  return "npm";
+}
+function hasDependency(rootDir, depName) {
+  try {
+    const pkg = JSON.parse(import_node_fs2.default.readFileSync(import_node_path3.default.join(rootDir, "package.json"), "utf8"));
+    return Boolean(pkg.dependencies?.[depName] || pkg.devDependencies?.[depName]);
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/fs-utils.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+function ensureDir(filePath) {
+  const dir = import_node_path4.default.dirname(filePath);
+  import_node_fs3.default.mkdirSync(dir, { recursive: true });
+}
+function readFileSafe(filePath) {
+  try {
+    return import_node_fs3.default.readFileSync(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function writeFileIfAbsent(filePath, content) {
+  if (import_node_fs3.default.existsSync(filePath)) {
+    const existing = readFileSafe(filePath);
+    if (existing?.trim() === content.trim()) {
+      return { status: "skipped-exists", path: filePath };
+    }
+    return { status: "skipped-different", path: filePath };
+  }
+  ensureDir(filePath);
+  import_node_fs3.default.writeFileSync(filePath, content, "utf8");
+  return { status: "created", path: filePath };
+}
+function writeFileWithBackup(filePath, content) {
+  if (!import_node_fs3.default.existsSync(filePath)) {
+    ensureDir(filePath);
+    import_node_fs3.default.writeFileSync(filePath, content, "utf8");
+    return { status: "created", path: filePath };
+  }
+  const existing = readFileSafe(filePath) ?? "";
+  if (existing.trim() === content.trim()) {
+    return { status: "skipped-exists", path: filePath };
+  }
+  const backupPath = `${filePath}.mdk-backup`;
+  import_node_fs3.default.writeFileSync(backupPath, existing, "utf8");
+  import_node_fs3.default.writeFileSync(filePath, content, "utf8");
+  return { status: "updated-with-backup", path: filePath, backupPath };
+}
+
+// src/scaffold/nextjs.ts
+var import_meta = {};
+var templateRoot = new URL("../templates/nextjs/", import_meta.url);
+function readTemplate(relativePath) {
+  return import_node_fs4.default.readFileSync(new URL(relativePath, templateRoot), "utf8");
+}
+function findExistingConfig(rootDir, preferred) {
+  if (preferred && import_node_fs4.default.existsSync(preferred)) return preferred;
+  const candidates = [
+    "next.config.js",
+    "next.config.cjs",
+    "next.config.mjs",
+    "next.config.ts",
+    "next.config.mts"
+  ];
+  for (const candidate of candidates) {
+    const fullPath = import_node_path5.default.join(rootDir, candidate);
+    if (import_node_fs4.default.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return void 0;
+}
+async function installNextjsPackage(rootDir, packageManager) {
+  if (hasDependency(rootDir, "@moneydevkit/nextjs")) {
+    return { installed: false, skipped: true };
+  }
+  const commandForPm = {
+    pnpm: ["pnpm", ["add", "@moneydevkit/nextjs"]],
+    yarn: ["yarn", ["add", "@moneydevkit/nextjs"]],
+    npm: ["npm", ["install", "@moneydevkit/nextjs"]],
+    bun: ["bun", ["add", "@moneydevkit/nextjs"]]
+  };
+  const [cmd, args] = commandForPm[packageManager];
+  await new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process.spawn)(cmd, args, { stdio: "inherit", cwd: rootDir });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`${cmd} ${args.join(" ")} failed with code ${code}`));
+      }
+    });
+    child.on("error", reject);
+  });
+  return { installed: true, skipped: false };
+}
+function createAppRouteContent(isTypeScript) {
+  return readTemplate(`app/api/mdk/route.${isTypeScript ? "ts" : "js"}`);
+}
+function createAppCheckoutPageContent(isTypeScript) {
+  return readTemplate(
+    `app/checkout/[id]/page.${isTypeScript ? "tsx" : "js"}`
+  );
+}
+function isTypeScriptConfig(configPath) {
+  return configPath.endsWith(".ts") || configPath.endsWith(".mts");
+}
+function patchNextConfigTypes(source) {
+  let patched = source.replace(
+    /import\s+type\s+\{\s*NextConfig\s*\}\s+from\s+["']next["'];?\s*\n?/g,
+    ""
+  );
+  patched = patched.replace(/:\s*NextConfig\b/g, ": NextConfigOverrides");
+  return patched;
+}
+function updateConfigFile(configPath) {
+  const isTs = isTypeScriptConfig(configPath);
+  const pluginImport = isTs ? 'import withMdkCheckout, { type NextConfigOverrides } from "@moneydevkit/nextjs/next-plugin";' : 'import withMdkCheckout from "@moneydevkit/nextjs/next-plugin";';
+  if (!import_node_fs4.default.existsSync(configPath)) {
+    const content = [
+      pluginImport,
+      "",
+      "// Wrap your existing Next.js config with withMdkCheckout to enable Money Dev Kit.",
+      "// Example: export default withMdkCheckout(yourConfig)",
+      isTs ? "const nextConfig: NextConfigOverrides = {};" : "const nextConfig = {};",
+      "",
+      "export default withMdkCheckout(nextConfig);",
+      ""
+    ].join("\n");
+    const writeResult = writeFileWithBackup(configPath, content);
+    return {
+      status: "created",
+      path: configPath,
+      backupPath: writeResult.status === "updated-with-backup" ? writeResult.backupPath : void 0
+    };
+  }
+  const original = readFileSafe(configPath) ?? "";
+  if (original.includes("@moneydevkit/nextjs/next-plugin") || original.includes("withMdkCheckout")) {
+    return { status: "skipped", path: configPath, reason: "already configured" };
+  }
+  if (original.includes("module.exports")) {
+    const re = /module\.exports\s*=\s*(\{[\s\S]*?\});?/;
+    const match = original.match(re);
+    if (match) {
+      const prefix = 'const withMdkCheckout = require("@moneydevkit/nextjs/next-plugin").default ?? require("@moneydevkit/nextjs/next-plugin");\n';
+      const replaced = original.replace(
+        re,
+        `module.exports = withMdkCheckout(${match[1]});`
+      );
+      const result = writeFileWithBackup(configPath, `${prefix}${replaced}`);
+      return {
+        status: "updated",
+        path: configPath,
+        backupPath: result.status === "updated-with-backup" ? result.backupPath : void 0
+      };
+    }
+  }
+  if (original.includes("export default")) {
+    const reDefaultObject = /export\s+default\s+(\{[\s\S]*?\});?/;
+    const objectMatch = original.match(reDefaultObject);
+    if (objectMatch) {
+      const content = [
+        pluginImport,
+        "",
+        isTs ? "const nextConfig: NextConfigOverrides = " + objectMatch[1] + ";" : "const nextConfig = " + objectMatch[1] + ";",
+        "",
+        "export default withMdkCheckout(nextConfig);",
+        ""
+      ].join("\n");
+      const writeResult = writeFileWithBackup(configPath, content);
+      return {
+        status: "updated",
+        path: configPath,
+        backupPath: writeResult.status === "updated-with-backup" ? writeResult.backupPath : void 0
+      };
+    }
+    const reNamed = /export\s+default\s+([a-zA-Z0-9_]+)\s*;?/;
+    const namedMatch = original.match(reNamed);
+    if (namedMatch) {
+      const name = namedMatch[1];
+      const patched = isTs && original.includes("NextConfig") ? patchNextConfigTypes(original) : original;
+      const lines = [
+        pluginImport,
+        patched.replace(reNamed, `export default withMdkCheckout(${name});`)
+      ];
+      const writeResult = writeFileWithBackup(configPath, lines.join("\n"));
+      return {
+        status: "updated",
+        path: configPath,
+        backupPath: writeResult.status === "updated-with-backup" ? writeResult.backupPath : void 0
+      };
+    }
+  }
+  return {
+    status: "skipped",
+    path: configPath,
+    reason: "unrecognized format; wrap your export with withMdkCheckout, e.g. export default withMdkCheckout(yourConfig)"
+  };
+}
+function scaffoldAppRouter(appDir, isTypeScript) {
+  const added = [];
+  const skipped = [];
+  const routePath = import_node_path5.default.join(
+    appDir,
+    "api",
+    "mdk",
+    `route.${isTypeScript ? "ts" : "js"}`
+  );
+  const routeResult = writeFileIfAbsent(
+    routePath,
+    createAppRouteContent(isTypeScript)
+  );
+  if (routeResult.status === "created") {
+    added.push(routeResult.path);
+  } else {
+    skipped.push(routeResult.path);
+  }
+  const pagePath = import_node_path5.default.join(
+    appDir,
+    "checkout",
+    "[id]",
+    `page.${isTypeScript ? "tsx" : "js"}`
+  );
+  const pageResult = writeFileIfAbsent(
+    pagePath,
+    createAppCheckoutPageContent(isTypeScript)
+  );
+  if (pageResult.status === "created") {
+    added.push(pageResult.path);
+  } else {
+    skipped.push(pageResult.path);
+  }
+  return { added, skipped };
+}
+async function scaffoldNextJs(options) {
+  const { detection, jsonMode, skipInstall } = options;
+  if (!detection.rootDir) {
+    throw new Error("Next.js project root not found for scaffolding.");
+  }
+  const warnings = [];
+  const rootDir = detection.rootDir;
+  const packageManager = detectPackageManager(rootDir);
+  const installResult = skipInstall ? { installed: false, skipped: true } : await installNextjsPackage(rootDir, packageManager);
+  const configPath = findExistingConfig(rootDir, detection.nextConfigPath) ?? import_node_path5.default.join(rootDir, "next.config.js");
+  const configResult = updateConfigFile(configPath);
+  if (configResult.status === "skipped") {
+    warnings.push(
+      `Could not automatically update ${import_node_path5.default.basename(configPath)} (${configResult.reason}). Please wrap your Next.js config with withMdkCheckout manually.`
+    );
+  }
+  const appDir = detection.appDir ?? import_node_path5.default.join(rootDir, "app");
+  const fileResults = scaffoldAppRouter(appDir, detection.usesTypeScript);
+  if (!detection.appDir) {
+    warnings.push(
+      "No app/ directory detected; created App Router scaffolding in app/."
+    );
+  }
+  if (!jsonMode) {
+    if (!installResult.installed && installResult.skipped) {
+      console.log("@moneydevkit/nextjs already present; skipping install.");
+    }
+  }
+  return {
+    rootDir,
+    packageManager,
+    installedPackage: installResult.installed,
+    installSkipped: installResult.skipped,
+    addedFiles: fileResults.added,
+    skippedFiles: fileResults.skipped,
+    config: configResult,
+    warnings
+  };
+}
+
 // src/index.ts
 var DEFAULT_BASE_URL = "https://moneydevkit.com";
 var DEFAULT_ENV_FILE = ".env.local";
@@ -109,7 +495,7 @@ var CookieJar = class {
 };
 function parseFlags(argv) {
   const result = (0, import_minimist.default)(argv, {
-    boolean: ["json", "no-clipboard", "no-open", "force-new-webhook", "yes"],
+    boolean: ["json", "no-clipboard", "no-open", "force-new-webhook", "scaffold-nextjs"],
     string: [
       "base-url",
       "env-target",
@@ -125,14 +511,14 @@ function parseFlags(argv) {
       "no-open": false,
       json: false,
       "force-new-webhook": false,
-      yes: false
+      "scaffold-nextjs": false
     }
   });
   return {
     json: Boolean(result.json),
     noClipboard: Boolean(result["no-clipboard"]),
     noOpen: Boolean(result["no-open"]),
-    yes: Boolean(result.yes),
+    scaffoldNextjs: Boolean(result["scaffold-nextjs"]),
     baseUrl: result["base-url"],
     envFile: result["env-target"],
     projectName: typeof result["project-name"] === "string" ? result["project-name"] : void 0,
@@ -142,20 +528,20 @@ function parseFlags(argv) {
   };
 }
 function normalizeDirectory(dir) {
-  if (import_node_path2.default.isAbsolute(dir)) return dir;
-  return import_node_path2.default.resolve(process.cwd(), dir);
+  if (import_node_path6.default.isAbsolute(dir)) return dir;
+  return import_node_path6.default.resolve(process.cwd(), dir);
 }
 function ensureDirectoryExists(dir) {
-  if (!import_node_fs.default.existsSync(dir)) {
-    import_node_fs.default.mkdirSync(dir, { recursive: true });
+  if (!import_node_fs5.default.existsSync(dir)) {
+    import_node_fs5.default.mkdirSync(dir, { recursive: true });
   }
 }
 function readEnvFile(filePath) {
   const env = /* @__PURE__ */ new Map();
-  if (!import_node_fs.default.existsSync(filePath)) {
+  if (!import_node_fs5.default.existsSync(filePath)) {
     return env;
   }
-  const contents = import_node_fs.default.readFileSync(filePath, "utf8");
+  const contents = import_node_fs5.default.readFileSync(filePath, "utf8");
   for (const line of contents.split(/\r?\n/)) {
     if (!line || line.startsWith("#")) continue;
     const [key, ...rest] = line.split("=");
@@ -176,22 +562,23 @@ function writeEnvFile(filePath, existing, updates) {
     existing.set(key, value);
   }
   const content = Array.from(existing.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}=${value}`).join(import_node_os.default.EOL) + import_node_os.default.EOL;
-  import_node_fs.default.writeFileSync(filePath, content, "utf8");
+  import_node_fs5.default.writeFileSync(filePath, content, "utf8");
 }
 function ensureEnvFileExists(filePath) {
-  const dir = import_node_path2.default.dirname(filePath);
+  const dir = import_node_path6.default.dirname(filePath);
   ensureDirectoryExists(dir);
-  if (!import_node_fs.default.existsSync(filePath)) {
-    import_node_fs.default.writeFileSync(filePath, "", "utf8");
+  if (!import_node_fs5.default.existsSync(filePath)) {
+    import_node_fs5.default.writeFileSync(filePath, "", "utf8");
   }
 }
 function resolveLocalEnvPath(options) {
-  const trimmed = options.organizationId?.trim();
-  if (!trimmed) {
+  const organization = options.organizationId?.trim();
+  const apiKey = options.apiKeyId?.trim();
+  if (!organization || !apiKey) {
     return void 0;
   }
   const homeDir = import_node_os.default.homedir();
-  return import_node_path2.default.join(homeDir, ".mdk", trimmed, ".env");
+  return import_node_path6.default.join(homeDir, ".mdk", organization, apiKey, ".env");
 }
 function isValidHttpUrl(value) {
   if (!value) return false;
@@ -255,7 +642,7 @@ async function runDeviceFlow(options) {
       p.note(
         [
           `Device code: ${device.userCode}`,
-          `Webhook URL: ${webhookUrl}`,
+          `Domain: ${webhookUrl}`,
           "Open the authorization page, click Authorize, then return to this terminal."
         ].join("\n"),
         "Authorize this device"
@@ -384,7 +771,7 @@ async function main() {
     }
     envFile = envPrompt.trim() || DEFAULT_ENV_FILE;
   }
-  const envPath = import_node_path2.default.join(projectDir, envFile);
+  const envPath = import_node_path6.default.join(projectDir, envFile);
   const existingEnvValues = readEnvFile(envPath);
   const mnemonicAlreadySet = existingEnvValues.get("MDK_MNEMONIC")?.trim();
   if (mnemonicAlreadySet) {
@@ -411,7 +798,7 @@ async function main() {
   }
   while (!webhookUrl) {
     const webhookInput = await p.text({
-      message: "Webhook URL for your application",
+      message: "Domain for your application",
       initialValue: "https://",
       placeholder: "https://yourapp.com",
       validate: (value) => isValidHttpUrl(value?.trim()) ? void 0 : "Enter a valid http(s) URL (e.g. https://yourapp.com)"
@@ -435,6 +822,39 @@ async function main() {
     projectName = namePrompt.trim() || void 0;
   }
   projectName = deriveProjectName(projectName, webhookUrl);
+  const nextJsDetection = detectNextJsProject(projectDir);
+  let shouldScaffoldNextJs = false;
+  if (flags.scaffoldNextjs) {
+    if (nextJsDetection.found) {
+      if (nextJsDetection.versionIsSupported) {
+        shouldScaffoldNextJs = true;
+      } else {
+        console.warn(
+          `Next.js version ${nextJsDetection.nextVersion ?? "unknown"} detected, but @moneydevkit/nextjs requires Next.js 15+. Skipping installation and scaffolding.`
+        );
+      }
+    } else {
+      console.warn(
+        "No NextJS app found, skipping @moneydevkit/nextjs installation. Please install manually."
+      );
+    }
+  } else if (!jsonMode && nextJsDetection.found) {
+    if (!nextJsDetection.versionIsSupported) {
+      console.warn(
+        `Next.js version ${nextJsDetection.nextVersion ?? "unknown"} detected, but @moneydevkit/nextjs requires Next.js 15+. Skipping scaffolding prompt.`
+      );
+    } else {
+      const scaffoldPrompt = await p.confirm({
+        message: `Next.js application detected at ${nextJsDetection.rootDir ?? projectDir} (version ${nextJsDetection.nextVersion ?? "unknown"}). Install and scaffold @moneydevkit/nextjs?`,
+        initialValue: true
+      });
+      if (p.isCancel(scaffoldPrompt)) {
+        p.cancel("Aborted.");
+        process.exit(1);
+      }
+      shouldScaffoldNextJs = Boolean(scaffoldPrompt);
+    }
+  }
   try {
     const result = await runDeviceFlow({
       flags,
@@ -445,7 +865,6 @@ async function main() {
     });
     const updates = {
       MDK_ACCESS_TOKEN: result.credentials.apiKey,
-      MDK_WEBHOOK_SECRET: result.credentials.webhookSecret,
       MDK_MNEMONIC: result.mnemonic
     };
     ensureEnvFileExists(envPath);
@@ -453,7 +872,8 @@ async function main() {
     const preview = renderEnvPreview(existingEnv, updates);
     writeEnvFile(envPath, existingEnv, updates);
     const localEnvPath = resolveLocalEnvPath({
-      organizationId: result.credentials.organizationId
+      organizationId: result.credentials.organizationId,
+      apiKeyId: result.credentials.apiKeyId
     });
     if (localEnvPath) {
       ensureEnvFileExists(localEnvPath);
@@ -465,11 +885,77 @@ async function main() {
     }
     if (!flags.noClipboard) {
       await import_clipboardy.default.write(
-        [`MDK_ACCESS_TOKEN=${updates.MDK_ACCESS_TOKEN}`, `MDK_WEBHOOK_SECRET=${updates.MDK_WEBHOOK_SECRET}`, `MDK_MNEMONIC=${updates.MDK_MNEMONIC}`].join(
+        [`MDK_ACCESS_TOKEN=${updates.MDK_ACCESS_TOKEN}`, `MDK_MNEMONIC=${updates.MDK_MNEMONIC}`].join(
           "\n"
         )
       );
     }
+    let scaffoldSummary = null;
+    if (shouldScaffoldNextJs && nextJsDetection.found) {
+      try {
+        scaffoldSummary = await scaffoldNextJs({
+          detection: nextJsDetection,
+          jsonMode
+        });
+        if (!jsonMode && scaffoldSummary) {
+          const lines = [
+            scaffoldSummary.installedPackage ? `Installed @moneydevkit/nextjs with ${scaffoldSummary.packageManager}.` : scaffoldSummary.installSkipped ? "@moneydevkit/nextjs already installed; skipped package install." : "Skipped @moneydevkit/nextjs installation."
+          ];
+          if (scaffoldSummary.config) {
+            const cfg = scaffoldSummary.config;
+            if (cfg.status === "created") {
+              lines.push(`Created ${cfg.path} with withMdkCheckout().`);
+              if (cfg.backupPath) {
+                lines.push(`Created backup at ${cfg.backupPath}.`);
+              }
+            } else if (cfg.status === "updated") {
+              lines.push(`Updated ${cfg.path} with withMdkCheckout().`);
+              if (cfg.backupPath) {
+                lines.push(`Created backup at ${cfg.backupPath}.`);
+              }
+            } else {
+              lines.push(
+                `Could not update ${cfg.path} automatically (${cfg.reason ?? "unknown reason"}).`
+              );
+            }
+          }
+          if (scaffoldSummary.addedFiles.length > 0) {
+            lines.push(
+              `Added: ${scaffoldSummary.addedFiles.map((p2) => import_node_path6.default.relative(projectDir, p2)).join(", ")}`
+            );
+          }
+          if (scaffoldSummary.skippedFiles.length > 0) {
+            lines.push(
+              `Skipped existing files: ${scaffoldSummary.skippedFiles.map((p2) => import_node_path6.default.relative(projectDir, p2)).join(", ")}`
+            );
+          }
+          p.note(lines.join("\n"), "Next.js scaffolding");
+        }
+        if (scaffoldSummary?.warnings.length) {
+          for (const warning of scaffoldSummary.warnings) {
+            console.warn(warning);
+          }
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (jsonMode) {
+          console.error(
+            JSON.stringify(
+              {
+                status: "error",
+                error: {
+                  message: `Next.js scaffolding failed: ${message}`
+                }
+              },
+              null,
+              2
+            )
+          );
+        } else {
+          console.warn(`Next.js scaffolding failed: ${message}`);
+        }
+      }
+    }
     const summary = {
       projectDir,
       envFile: envPath,
@@ -477,7 +963,8 @@ async function main() {
       webhookId: result.credentials.webhookId,
       organizationId: result.credentials.organizationId,
       webhookUrl: result.credentials.webhookUrl,
-      mnemonic: updates.MDK_MNEMONIC
+      mnemonic: updates.MDK_MNEMONIC,
+      scaffoldedNextjs: Boolean(scaffoldSummary)
     };
     if (jsonMode) {
       console.log(
@@ -492,7 +979,8 @@ async function main() {
               webhookSecret: result.credentials.webhookSecret,
               webhookUrl: result.credentials.webhookUrl,
               organizationId: result.credentials.organizationId,
-              mnemonic: updates.MDK_MNEMONIC
+              mnemonic: updates.MDK_MNEMONIC,
+              scaffoldedNextjs: Boolean(scaffoldSummary)
             }
           },
           null,