create-whop-kit 0.2.0 → 0.3.0

package/dist/cli-create.js

@@ -11,9 +11,9 @@ import { runMain } from "citty";
 
 // src/commands/init.ts
 import { resolve, basename as basename2 } from "path";
-import { existsSync as existsSync4 } from "fs";
-import * as p2 from "@clack/prompts";
-import pc2 from "picocolors";
+import { existsSync as existsSync5 } from "fs";
+import * as p5 from "@clack/prompts";
+import pc5 from "picocolors";
 import { defineCommand } from "citty";
 
 // src/templates.ts
@@ -88,22 +88,266 @@ var DB_OPTIONS = {
   }
 };
 
-// src/utils/checks.ts
+// src/providers/neon.ts
 import * as p from "@clack/prompts";
 import pc from "picocolors";
+var neonProvider = {
+  name: "Neon",
+  description: "Serverless Postgres \u2014 free tier, scales to zero",
+  isInstalled() {
+    return hasCommand("neonctl") || hasCommand("neon");
+  },
+  async install() {
+    const s = p.spinner();
+    s.start("Installing neonctl...");
+    const result = exec("npm install -g neonctl");
+    if (result.success) {
+      s.stop("neonctl installed");
+      return true;
+    }
+    s.stop("Failed to install neonctl");
+    p.log.error(`Install manually: ${pc.bold("npm install -g neonctl")}`);
+    return false;
+  },
+  async provision(projectName) {
+    const cli = hasCommand("neonctl") ? "neonctl" : "neon";
+    const whoami = exec(`${cli} me`);
+    if (!whoami.success) {
+      p.log.info("You need to authenticate with Neon.");
+      p.log.info(`Running ${pc.bold(`${cli} auth`)} \u2014 this will open your browser.`);
+      const authResult = exec(`${cli} auth`);
+      if (!authResult.success) {
+        p.log.error("Neon authentication failed. Try running manually:");
+        p.log.info(pc.bold(`  ${cli} auth`));
+        return null;
+      }
+    }
+    const s = p.spinner();
+    s.start(`Creating Neon project "${projectName}"...`);
+    const createResult = exec(
+      `${cli} projects create --name "${projectName}" --set-context --output json`
+    );
+    if (!createResult.success) {
+      s.stop("Failed to create Neon project");
+      p.log.error("Try creating manually at https://console.neon.tech");
+      return null;
+    }
+    s.stop("Neon project created");
+    s.start("Getting connection string...");
+    const connResult = exec(`${cli} connection-string --prisma`);
+    if (!connResult.success) {
+      s.stop("Could not retrieve connection string");
+      p.log.error("Get it from: https://console.neon.tech");
+      return null;
+    }
+    s.stop("Connection string retrieved");
+    return {
+      connectionString: connResult.stdout,
+      provider: "neon"
+    };
+  }
+};
+
+// src/providers/supabase.ts
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+var supabaseProvider = {
+  name: "Supabase",
+  description: "Open-source Firebase alternative with Postgres",
+  isInstalled() {
+    return hasCommand("supabase");
+  },
+  async install() {
+    const s = p2.spinner();
+    s.start("Checking Supabase CLI...");
+    if (hasCommand("brew")) {
+      s.message("Installing via Homebrew...");
+      const result = exec("brew install supabase/tap/supabase");
+      if (result.success) {
+        s.stop("Supabase CLI installed");
+        return true;
+      }
+    }
+    s.stop("Supabase CLI not found");
+    p2.log.info("Install the Supabase CLI:");
+    p2.log.info(pc2.bold("  brew install supabase/tap/supabase"));
+    p2.log.info(pc2.dim("  or use npx supabase <command>"));
+    const useNpx = await p2.confirm({
+      message: "Continue with npx supabase? (slower but works without install)",
+      initialValue: true
+    });
+    if (p2.isCancel(useNpx) || !useNpx) return false;
+    return true;
+  },
+  async provision(projectName) {
+    const cli = hasCommand("supabase") ? "supabase" : "npx supabase";
+    const projectsList = exec(`${cli} projects list`);
+    if (!projectsList.success) {
+      p2.log.info("You need to authenticate with Supabase.");
+      p2.log.info(`Running ${pc2.bold(`${cli} login`)} \u2014 this will open your browser.`);
+      const authResult = exec(`${cli} login`);
+      if (!authResult.success) {
+        p2.log.error("Supabase authentication failed. Try:");
+        p2.log.info(pc2.bold(`  ${cli} login`));
+        return null;
+      }
+    }
+    const orgsResult = exec(`${cli} orgs list`);
+    let orgId = "";
+    if (orgsResult.success && orgsResult.stdout) {
+      const lines = orgsResult.stdout.split("\n").filter((l) => l.trim());
+      if (lines.length > 1) {
+        const orgInput = await p2.text({
+          message: "Supabase Organization ID",
+          placeholder: "Find in dashboard: supabase.com/dashboard",
+          validate: (v) => !v ? "Required" : void 0
+        });
+        if (p2.isCancel(orgInput)) return null;
+        orgId = orgInput;
+      }
+    }
+    const password = Array.from(crypto.getRandomValues(new Uint8Array(16))).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const s = p2.spinner();
+    s.start(`Creating Supabase project "${projectName}"...`);
+    const createCmd = orgId ? `${cli} projects create "${projectName}" --org-id "${orgId}" --db-password "${password}" --region us-east-1` : `${cli} projects create "${projectName}" --db-password "${password}" --region us-east-1`;
+    const createResult = exec(createCmd);
+    if (!createResult.success) {
+      s.stop("Failed to create Supabase project");
+      p2.log.error("Create manually at: https://supabase.com/dashboard");
+      return null;
+    }
+    s.stop("Supabase project created");
+    p2.log.info("");
+    p2.log.info(pc2.bold("Get your connection string:"));
+    p2.log.info("  1. Go to https://supabase.com/dashboard");
+    p2.log.info("  2. Select your new project");
+    p2.log.info('  3. Click "Connect" \u2192 "Session pooler"');
+    p2.log.info("  4. Copy the connection string");
+    p2.log.info("");
+    const connString = await p2.text({
+      message: "Paste your Supabase connection string",
+      placeholder: "postgresql://postgres.[ref]:[password]@...",
+      validate: (v) => {
+        if (!v) return "Required";
+        if (!v.startsWith("postgres")) return "Must be a PostgreSQL connection string";
+      }
+    });
+    if (p2.isCancel(connString)) return null;
+    return {
+      connectionString: connString,
+      provider: "supabase"
+    };
+  }
+};
+
+// src/providers/prisma-postgres.ts
+import * as p3 from "@clack/prompts";
+import pc3 from "picocolors";
+import { readFileSync, existsSync } from "fs";
+var prismaPostgresProvider = {
+  name: "Prisma Postgres",
+  description: "Instant Postgres \u2014 no auth needed, free tier",
+  isInstalled() {
+    return true;
+  },
+  async install() {
+    return true;
+  },
+  async provision(projectName) {
+    const region = await p3.select({
+      message: "Prisma Postgres region",
+      options: [
+        { value: "us-east-1", label: "US East (Virginia)", hint: "default" },
+        { value: "us-west-1", label: "US West (Oregon)" },
+        { value: "eu-central-1", label: "EU Central (Frankfurt)" },
+        { value: "eu-west-3", label: "EU West (Paris)" },
+        { value: "ap-southeast-1", label: "Asia Pacific (Singapore)" },
+        { value: "ap-northeast-1", label: "Asia Pacific (Tokyo)" }
+      ]
+    });
+    if (p3.isCancel(region)) return null;
+    const s = p3.spinner();
+    s.start("Creating Prisma Postgres database...");
+    const result = exec(`npx create-db@latest --region ${region} --json`);
+    if (!result.success) {
+      const fallback = exec(`npx -y create-db@latest --region ${region}`);
+      if (!fallback.success) {
+        s.stop("Failed to create database");
+        p3.log.error("Try manually: " + pc3.bold("npx create-db@latest"));
+        return null;
+      }
+      const match = fallback.stdout.match(/postgresql:\/\/[^\s"]+/);
+      if (match) {
+        s.stop("Prisma Postgres database created");
+        return {
+          connectionString: match[0],
+          provider: "prisma-postgres",
+          note: "This is a temporary database (24h). Claim it via the link in the output to make it permanent."
+        };
+      }
+    }
+    try {
+      const data = JSON.parse(result.stdout);
+      if (data.connectionString || data.url) {
+        s.stop("Prisma Postgres database created");
+        return {
+          connectionString: data.connectionString || data.url,
+          provider: "prisma-postgres",
+          note: "This is a temporary database (24h). Claim it to make it permanent."
+        };
+      }
+    } catch {
+      const match = result.stdout.match(/postgresql:\/\/[^\s"]+/);
+      if (match) {
+        s.stop("Prisma Postgres database created");
+        return {
+          connectionString: match[0],
+          provider: "prisma-postgres",
+          note: "This is a temporary database (24h). Claim it to make it permanent."
+        };
+      }
+    }
+    if (existsSync(".env")) {
+      const envContent = readFileSync(".env", "utf-8");
+      const match = envContent.match(/DATABASE_URL="?(postgresql:\/\/[^\s"]+)"?/);
+      if (match) {
+        s.stop("Prisma Postgres database created");
+        return {
+          connectionString: match[1],
+          provider: "prisma-postgres",
+          note: "This is a temporary database (24h). Claim it to make it permanent."
+        };
+      }
+    }
+    s.stop("Database created but could not extract connection string");
+    p3.log.warning("Check the output above for your DATABASE_URL, or visit https://console.prisma.io");
+    return null;
+  }
+};
+
+// src/providers/index.ts
+var DB_PROVIDERS = {
+  neon: neonProvider,
+  supabase: supabaseProvider,
+  "prisma-postgres": prismaPostgresProvider
+};
+
+// src/utils/checks.ts
+import * as p4 from "@clack/prompts";
+import pc4 from "picocolors";
 function checkNodeVersion(minimum = 18) {
   const major = parseInt(process.versions.node.split(".")[0], 10);
   if (major < minimum) {
-    p.log.error(
-      `Node.js ${pc.bold(`v${minimum}+`)} is required. You have ${pc.bold(`v${process.versions.node}`)}.`
+    p4.log.error(
+      `Node.js ${pc4.bold(`v${minimum}+`)} is required. You have ${pc4.bold(`v${process.versions.node}`)}.`
     );
     process.exit(1);
   }
 }
 function checkGit() {
   if (!hasCommand("git")) {
-    p.log.error(
-      `${pc.bold("git")} is required but not found. Install it from ${pc.cyan("https://git-scm.com")}`
+    p4.log.error(
+      `${pc4.bold("git")} is required but not found. Install it from ${pc4.cyan("https://git-scm.com")}`
     );
     process.exit(1);
   }
@@ -122,9 +366,9 @@ function validateWhopAppId(id) {
 }
 
 // src/utils/cleanup.ts
-import { rmSync, existsSync } from "fs";
+import { rmSync, existsSync as existsSync2 } from "fs";
 function cleanupDir(dir) {
-  if (existsSync(dir)) {
+  if (existsSync2(dir)) {
     try {
       rmSync(dir, { recursive: true, force: true });
     } catch {
@@ -133,25 +377,25 @@ function cleanupDir(dir) {
 }
 
 // src/scaffolding/clone.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync, rmSync as rmSync2 } from "fs";
 import { join, basename } from "path";
 function cloneTemplate(repo, projectDir) {
   const result = exec(
     `git clone --depth 1 https://github.com/${repo}.git "${projectDir}"`
   );
-  if (!result.success || !existsSync2(projectDir)) {
+  if (!result.success || !existsSync3(projectDir)) {
     return false;
   }
   const gitDir = join(projectDir, ".git");
-  if (existsSync2(gitDir)) {
+  if (existsSync3(gitDir)) {
     rmSync2(gitDir, { recursive: true, force: true });
   }
   return true;
 }
 function updatePackageName(projectDir, name) {
   const pkgPath = join(projectDir, "package.json");
-  if (existsSync2(pkgPath)) {
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  if (existsSync3(pkgPath)) {
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     pkg.name = basename(name);
     writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
   }
@@ -163,7 +407,7 @@ function initGit(projectDir) {
 }
 
 // src/scaffolding/env-file.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync4 } from "fs";
 import { join as join2 } from "path";
 function writeEnvFile(projectDir, values) {
   const examplePath = join2(projectDir, ".env.example");
@@ -171,8 +415,8 @@ function writeEnvFile(projectDir, values) {
   const filled = Object.fromEntries(
     Object.entries(values).filter(([, v]) => v)
   );
-  if (existsSync3(examplePath)) {
-    let content = readFileSync2(examplePath, "utf-8");
+  if (existsSync4(examplePath)) {
+    let content = readFileSync3(examplePath, "utf-8");
     for (const [key, value] of Object.entries(filled)) {
       const pattern = new RegExp(
         `^(#\\s*)?${escapeRegex(key)}=.*$`,
@@ -196,7 +440,7 @@ function escapeRegex(str) {
 
 // src/commands/init.ts
 function isCancelled(value) {
-  return p2.isCancel(value);
+  return p5.isCancel(value);
 }
 var init_default = defineCommand({
   meta: {
@@ -260,94 +504,127 @@ var init_default = defineCommand({
     checkNodeVersion(18);
     checkGit();
     console.log("");
-    p2.intro(`${pc2.bgCyan(pc2.black(" create-whop-kit "))} Create a Whop-powered app`);
+    p5.intro(`${pc5.bgCyan(pc5.black(" create-whop-kit "))} Create a Whop-powered app`);
     const isNonInteractive = !!(args.framework && args.db);
     let projectName = args.name;
     if (!projectName) {
-      const result = await p2.text({
+      const result = await p5.text({
         message: "Project name",
         placeholder: "my-whop-app",
         validate: (v) => {
           if (!v) return "Project name is required";
-          if (existsSync4(resolve(v))) return `Directory "${v}" already exists`;
+          if (existsSync5(resolve(v))) return `Directory "${v}" already exists`;
         }
       });
       if (isCancelled(result)) {
-        p2.cancel("Cancelled.");
+        p5.cancel("Cancelled.");
         process.exit(0);
       }
       projectName = result;
-    } else if (existsSync4(resolve(projectName))) {
-      p2.log.error(`Directory "${projectName}" already exists`);
+    } else if (existsSync5(resolve(projectName))) {
+      p5.log.error(`Directory "${projectName}" already exists`);
       process.exit(1);
     }
     let appType = args.type;
     if (!isNonInteractive && !args.yes) {
-      const result = await p2.select({
+      const result = await p5.select({
         message: "What are you building?",
         options: Object.entries(APP_TYPES).map(([value, t]) => ({
           value,
-          label: t.available ? t.name : `${t.name} ${pc2.dim("(coming soon)")}`,
+          label: t.available ? t.name : `${t.name} ${pc5.dim("(coming soon)")}`,
           hint: t.description,
           disabled: !t.available
         }))
       });
       if (isCancelled(result)) {
-        p2.cancel("Cancelled.");
+        p5.cancel("Cancelled.");
         process.exit(0);
       }
       appType = result;
     }
     let framework = args.framework;
     if (!framework) {
-      const result = await p2.select({
+      const result = await p5.select({
         message: "Which framework?",
         options: Object.entries(TEMPLATES).map(([value, t]) => ({
           value,
-          label: t.available ? t.name : `${t.name} ${pc2.dim("(coming soon)")}`,
+          label: t.available ? t.name : `${t.name} ${pc5.dim("(coming soon)")}`,
           hint: t.description,
           disabled: !t.available
         }))
       });
       if (isCancelled(result)) {
-        p2.cancel("Cancelled.");
+        p5.cancel("Cancelled.");
         process.exit(0);
       }
       framework = result;
     }
     const template = TEMPLATES[framework];
     if (!template || !template.available) {
-      p2.log.error(`Framework "${framework}" is not available. Options: ${Object.keys(TEMPLATES).filter((k) => TEMPLATES[k].available).join(", ")}`);
+      p5.log.error(`Framework "${framework}" is not available. Options: ${Object.keys(TEMPLATES).filter((k) => TEMPLATES[k].available).join(", ")}`);
       process.exit(1);
     }
     let database = args.db;
     if (!database) {
-      const result = await p2.select({
+      const result = await p5.select({
         message: "Which database?",
-        options: Object.entries(DB_OPTIONS).map(([value, d]) => ({
-          value,
-          label: d.name,
-          hint: d.description
-        }))
+        options: [
+          { value: "neon", label: "Neon", hint: "Serverless Postgres \u2014 auto-provisioned (recommended)" },
+          { value: "prisma-postgres", label: "Prisma Postgres", hint: "Instant database \u2014 no account needed" },
+          { value: "supabase", label: "Supabase", hint: "Open-source Firebase alternative" },
+          { value: "manual", label: "I have a connection string", hint: "Paste an existing PostgreSQL URL" },
+          { value: "later", label: "Configure later", hint: "Skip database setup for now" }
+        ]
       });
       if (isCancelled(result)) {
-        p2.cancel("Cancelled.");
+        p5.cancel("Cancelled.");
         process.exit(0);
       }
       database = result;
     }
     let dbUrl = args["db-url"] ?? "";
-    if (database !== "later" && !dbUrl) {
-      const result = await p2.text({
+    let dbNote = "";
+    if (database !== "later" && database !== "manual" && !dbUrl) {
+      const provider = DB_PROVIDERS[database];
+      if (provider) {
+        if (!provider.isInstalled()) {
+          const install = await p5.confirm({
+            message: `${provider.name} CLI not found. Install it now?`,
+            initialValue: true
+          });
+          if (isCancelled(install) || !install) {
+            p5.log.warning("Skipping database provisioning. You can configure it later.");
+            database = "later";
+          } else {
+            const installed = await provider.install();
+            if (!installed) {
+              p5.log.warning("Skipping database provisioning.");
+              database = "later";
+            }
+          }
+        }
+        if (database !== "later") {
+          const result = await provider.provision(projectName);
+          if (result) {
+            dbUrl = result.connectionString;
+            if (result.note) dbNote = result.note;
+            p5.log.success(`${pc5.bold(provider.name)} database ready`);
+          } else {
+            p5.log.warning("Database provisioning skipped. Configure manually later.");
+          }
+        }
+      }
+    } else if (database === "manual" && !dbUrl) {
+      const result = await p5.text({
         message: "Database URL",
-        placeholder: DB_OPTIONS[database]?.envVarHint ?? "postgresql://...",
+        placeholder: "postgresql://user:pass@host:5432/dbname",
         validate: (v) => {
           if (!v) return "Required (choose 'Configure later' to skip)";
           return validateDatabaseUrl(v);
         }
       });
       if (isCancelled(result)) {
-        p2.cancel("Cancelled.");
+        p5.cancel("Cancelled.");
         process.exit(0);
       }
       dbUrl = result;
@@ -356,13 +633,13 @@ var init_default = defineCommand({
     let apiKey = args["api-key"] ?? "";
     let webhookSecret = args["webhook-secret"] ?? "";
     if (!isNonInteractive && !args.yes) {
-      const setupWhop = await p2.confirm({
+      const setupWhop = await p5.confirm({
         message: "Configure Whop credentials now? (you can do this later via the setup wizard)",
         initialValue: false
       });
       if (!isCancelled(setupWhop) && setupWhop) {
         if (!appId) {
-          const result = await p2.text({
+          const result = await p5.text({
             message: "Whop App ID",
             placeholder: "app_xxxxxxxxx",
             validate: (v) => v ? validateWhopAppId(v) : void 0
@@ -370,14 +647,14 @@ var init_default = defineCommand({
           if (!isCancelled(result)) appId = result ?? "";
         }
         if (!apiKey) {
-          const result = await p2.text({
+          const result = await p5.text({
             message: "Whop API Key",
             placeholder: "apik_xxxxxxxxx (optional, press Enter to skip)"
           });
           if (!isCancelled(result)) apiKey = result ?? "";
         }
         if (!webhookSecret) {
-          const result = await p2.text({
+          const result = await p5.text({
             message: "Whop Webhook Secret",
             placeholder: "optional, press Enter to skip"
           });
@@ -386,25 +663,25 @@ var init_default = defineCommand({
       }
     }
     if (args["dry-run"]) {
-      p2.log.info(pc2.dim("Dry run \u2014 showing what would be created:\n"));
-      console.log(`  ${pc2.bold("Project:")}     ${projectName}`);
-      console.log(`  ${pc2.bold("Framework:")}   ${template.name}`);
-      console.log(`  ${pc2.bold("App type:")}    ${APP_TYPES[appType]?.name ?? appType}`);
-      console.log(`  ${pc2.bold("Database:")}    ${DB_OPTIONS[database]?.name ?? database}`);
-      console.log(`  ${pc2.bold("Template:")}    github.com/${template.repo}`);
-      if (dbUrl) console.log(`  ${pc2.bold("DB URL:")}      ${dbUrl.substring(0, 30)}...`);
-      if (appId) console.log(`  ${pc2.bold("Whop App:")}    ${appId}`);
+      p5.log.info(pc5.dim("Dry run \u2014 showing what would be created:\n"));
+      console.log(`  ${pc5.bold("Project:")}     ${projectName}`);
+      console.log(`  ${pc5.bold("Framework:")}   ${template.name}`);
+      console.log(`  ${pc5.bold("App type:")}    ${APP_TYPES[appType]?.name ?? appType}`);
+      console.log(`  ${pc5.bold("Database:")}    ${DB_OPTIONS[database]?.name ?? database}`);
+      console.log(`  ${pc5.bold("Template:")}    github.com/${template.repo}`);
+      if (dbUrl) console.log(`  ${pc5.bold("DB URL:")}      ${dbUrl.substring(0, 30)}...`);
+      if (appId) console.log(`  ${pc5.bold("Whop App:")}    ${appId}`);
       console.log("");
-      p2.outro("No files were created.");
+      p5.outro("No files were created.");
       return;
     }
     const projectDir = resolve(projectName);
-    const s = p2.spinner();
+    const s = p5.spinner();
     s.start(`Cloning ${template.name} template...`);
     const cloned = cloneTemplate(template.repo, projectDir);
     if (!cloned) {
       s.stop("Failed to clone template");
-      p2.log.error(`Could not clone github.com/${template.repo}. Check your internet connection.`);
+      p5.log.error(`Could not clone github.com/${template.repo}. Check your internet connection.`);
       cleanupDir(projectDir);
       process.exit(1);
     }
@@ -436,7 +713,7 @@ var init_default = defineCommand({
     const installResult = exec(`${pm} install`, projectDir);
     if (!installResult.success) {
       s.stop(`${pm} install failed`);
-      p2.log.warning("Dependency installation failed. Run it manually after setup.");
+      p5.log.warning("Dependency installation failed. Run it manually after setup.");
     } else {
       s.stop("Dependencies installed");
     }
@@ -453,26 +730,30 @@ var init_default = defineCommand({
     else missing.push("Webhook Secret");
     let summary = "";
     if (configured.length > 0) {
-      summary += `${pc2.green("\u2713")} ${configured.join(", ")}
+      summary += `${pc5.green("\u2713")} ${configured.join(", ")}
 `;
     }
     if (missing.length > 0) {
-      summary += `${pc2.yellow("\u25CB")} Missing: ${missing.join(", ")}
+      summary += `${pc5.yellow("\u25CB")} Missing: ${missing.join(", ")}
+`;
+      summary += `  ${pc5.dim("Configure via the setup wizard or .env.local")}
 `;
-      summary += `  ${pc2.dim("Configure via the setup wizard or .env.local")}
+    }
+    if (dbNote) {
+      summary += `${pc5.yellow("!")} ${dbNote}
 `;
     }
     summary += `
 `;
-    summary += `  ${pc2.bold("cd")} ${basename2(projectName)}
+    summary += `  ${pc5.bold("cd")} ${basename2(projectName)}
 `;
     if (dbUrl) {
-      summary += `  ${pc2.bold(`${pm} run db:push`)}
+      summary += `  ${pc5.bold(`${pm} run db:push`)}
 `;
     }
-    summary += `  ${pc2.bold(`${pm} run dev`)}`;
-    p2.note(summary, "Your app is ready");
-    p2.outro(`${pc2.green("Happy building!")} ${pc2.dim("\u2014 whop-kit")}`);
+    summary += `  ${pc5.bold(`${pm} run dev`)}`;
+    p5.note(summary, "Your app is ready");
+    p5.outro(`${pc5.green("Happy building!")} ${pc5.dim("\u2014 whop-kit")}`);
   }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-whop-kit",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Scaffold and manage Whop-powered apps with whop-kit",
   "type": "module",
   "license": "MIT",