@revealui/cli 0.0.1-pre.1 → 0.2.0

package/dist/cli.js

@@ -0,0 +1,1075 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.56.2_@types+node@25.3.0__@swc+core@1.15.11_@swc+h_406b258ea3c313c6308725a34065a5eb/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_@microsoft+api-extractor@7.56.2_@types+node@25.3.0__@swc+core@1.15.11_@swc+h_406b258ea3c313c6308725a34065a5eb/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/validators/node-version.ts
+import { createLogger } from "@revealui/setup/utils";
+function validateNodeVersion() {
+  const currentVersion = process.version.slice(1);
+  const [currentMajor, currentMinor] = currentVersion.split(".").map(Number);
+  const [requiredMajor, requiredMinor] = REQUIRED_NODE_VERSION.split(".").map(Number);
+  if (currentMajor < requiredMajor || currentMajor === requiredMajor && currentMinor < requiredMinor) {
+    logger.error(
+      `Node.js ${REQUIRED_NODE_VERSION} or higher is required. You have ${currentVersion}.`
+    );
+    logger.info("Please upgrade Node.js: https://nodejs.org/");
+    return false;
+  }
+  return true;
+}
+var logger, REQUIRED_NODE_VERSION;
+var init_node_version = __esm({
+  "src/validators/node-version.ts"() {
+    "use strict";
+    init_esm_shims();
+    logger = createLogger({ prefix: "Setup" });
+    REQUIRED_NODE_VERSION = "24.12.0";
+  }
+});
+
+// src/generators/devbox.ts
+import fs from "fs/promises";
+import path2 from "path";
+async function generateDevbox(projectPath) {
+  const devboxConfig = {
+    packages: ["nodejs@24.12.0", "pnpm@10.28.2", "postgresql@16", "stripe-cli@latest"],
+    shell: {
+      init_hook: [
+        "corepack enable",
+        'echo "\u{1F680} RevealUI Devbox shell ready!"',
+        'echo "Run: pnpm dev to start development"'
+      ],
+      scripts: {
+        dev: "pnpm dev",
+        setup: "pnpm install && pnpm db:init",
+        test: "pnpm test"
+      }
+    },
+    env: {
+      NODE_ENV: "development"
+    }
+  };
+  await fs.writeFile(
+    path2.join(projectPath, "devbox.json"),
+    JSON.stringify(devboxConfig, null, 2),
+    "utf-8"
+  );
+}
+var init_devbox = __esm({
+  "src/generators/devbox.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/generators/devcontainer.ts
+import fs2 from "fs/promises";
+import path3 from "path";
+async function generateDevContainer(projectPath) {
+  const devcontainerDir = path3.join(projectPath, ".devcontainer");
+  await fs2.mkdir(devcontainerDir, { recursive: true });
+  const devcontainerConfig = {
+    name: "RevealUI Development",
+    image: "mcr.microsoft.com/devcontainers/typescript-node:24",
+    features: {
+      "ghcr.io/devcontainers/features/common-utils:2": {
+        installZsh: true,
+        installOhMyZsh: true
+      }
+    },
+    forwardPorts: [3e3, 4e3, 5432],
+    portsAttributes: {
+      "3000": {
+        label: "Web App",
+        onAutoForward: "notify"
+      },
+      "4000": {
+        label: "CMS",
+        onAutoForward: "notify"
+      },
+      "5432": {
+        label: "PostgreSQL",
+        onAutoForward: "silent"
+      }
+    },
+    postCreateCommand: "corepack enable && pnpm install",
+    customizations: {
+      vscode: {
+        extensions: [
+          "dbaeumer.vscode-eslint",
+          "biomejs.biome",
+          "bradlc.vscode-tailwindcss",
+          "Prisma.prisma",
+          "ms-azuretools.vscode-docker",
+          "streetsidesoftware.code-spell-checker"
+        ],
+        settings: {
+          "editor.defaultFormatter": "biomejs.biome",
+          "editor.formatOnSave": true,
+          "editor.codeActionsOnSave": {
+            "quickfix.biome": "explicit",
+            "source.organizeImports.biome": "explicit"
+          }
+        }
+      }
+    },
+    remoteUser: "node"
+  };
+  await fs2.writeFile(
+    path3.join(devcontainerDir, "devcontainer.json"),
+    JSON.stringify(devcontainerConfig, null, 2),
+    "utf-8"
+  );
+  const dockerCompose = `version: '3.8'
+
+services:
+  app:
+    build:
+      context: ..
+      dockerfile: .devcontainer/Dockerfile
+    volumes:
+      - ..:/workspace:cached
+    command: sleep infinity
+    network_mode: service:db
+
+  db:
+    image: pgvector/pgvector:pg16
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: revealui
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+
+volumes:
+  postgres-data:
+`;
+  await fs2.writeFile(path3.join(devcontainerDir, "docker-compose.yml"), dockerCompose, "utf-8");
+  const dockerfile = `FROM mcr.microsoft.com/devcontainers/typescript-node:24
+
+# Install additional tools
+RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \\
+    && apt-get -y install --no-install-recommends postgresql-client
+
+# Enable pnpm
+RUN corepack enable
+`;
+  await fs2.writeFile(path3.join(devcontainerDir, "Dockerfile"), dockerfile, "utf-8");
+  const readme = `# Dev Container Setup
+
+This directory contains the Dev Container configuration for RevealUI.
+
+## Usage
+
+### VS Code
+
+1. Install the "Dev Containers" extension
+2. Open this folder in VS Code
+3. Press F1 and select "Dev Containers: Reopen in Container"
+
+### GitHub Codespaces
+
+1. Click the green "Code" button on GitHub
+2. Select "Codespaces" tab
+3. Click "Create codespace on main"
+
+## What's Included
+
+- Node.js 24.12.0
+- pnpm package manager
+- PostgreSQL 16 with pgvector
+- VS Code extensions:
+  - ESLint
+  - Biome
+  - Tailwind CSS
+  - Prisma
+  - Docker
+  - Code Spell Checker
+
+## Environment Variables
+
+Environment variables are loaded from \`.env.development.local\`.
+For GitHub Codespaces, set secrets in your repository settings.
+
+## Ports
+
+- 3000: Web application
+- 4000: CMS
+- 5432: PostgreSQL database
+`;
+  await fs2.writeFile(path3.join(devcontainerDir, "README.md"), readme, "utf-8");
+}
+var init_devcontainer = __esm({
+  "src/generators/devcontainer.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/generators/readme.ts
+import fs3 from "fs/promises";
+import path4 from "path";
+async function generateReadme(projectPath, projectConfig) {
+  const readme = `# ${projectConfig.projectName}
+
+A RevealUI project created with @revealui/cli.
+
+## Getting Started
+
+First, install dependencies:
+
+\`\`\`bash
+pnpm install
+\`\`\`
+
+Then, initialize the database:
+
+\`\`\`bash
+pnpm db:init
+pnpm db:migrate
+\`\`\`
+
+Run the development server:
+
+\`\`\`bash
+pnpm dev
+\`\`\`
+
+Open [http://localhost:4000](http://localhost:4000) with your browser to access the CMS.
+
+The web application runs on [http://localhost:3000](http://localhost:3000).
+
+## Development Environments
+
+### Standard Setup
+
+Requirements:
+- Node.js 24.12.0 or higher
+- pnpm 10.28.2 or higher
+- PostgreSQL 16
+
+### Dev Containers
+
+Open in VS Code and select "Reopen in Container", or use GitHub Codespaces.
+
+### Devbox
+
+Install Devbox:
+
+\`\`\`bash
+curl -fsSL https://get.jetpack.io/devbox | bash
+\`\`\`
+
+Then start the Devbox shell:
+
+\`\`\`bash
+devbox shell
+pnpm dev
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+${projectConfig.projectName}/
+\u251C\u2500\u2500 apps/
+\u2502   \u251C\u2500\u2500 cms/              # CMS application
+\u2502   \u2514\u2500\u2500 web/              # Frontend application
+\u251C\u2500\u2500 packages/
+\u2502   \u251C\u2500\u2500 auth/             # Authentication
+\u2502   \u251C\u2500\u2500 db/               # Database
+\u2502   \u2514\u2500\u2500 ...               # Other shared packages
+\u251C\u2500\u2500 .devcontainer/        # Dev Container configuration
+\u251C\u2500\u2500 devbox.json           # Devbox configuration
+\u2514\u2500\u2500 .env.development.local # Environment variables
+\`\`\`
+
+## Available Scripts
+
+- \`pnpm dev\` - Start development servers
+- \`pnpm build\` - Build for production
+- \`pnpm test\` - Run tests
+- \`pnpm lint\` - Run linters
+- \`pnpm typecheck\` - Type check
+- \`pnpm db:init\` - Initialize database
+- \`pnpm db:migrate\` - Run migrations
+- \`pnpm db:seed\` - Seed database
+
+## Learn More
+
+- [RevealUI Documentation](https://github.com/your-org/RevealUI)
+- [Next.js Documentation](https://nextjs.org/docs)
+- [Hono Documentation](https://hono.dev)
+
+## Template
+
+This project was created using the **${projectConfig.template}** template.
+
+## License
+
+MIT
+`;
+  await fs3.writeFile(path4.join(projectPath, "README.md"), readme, "utf-8");
+}
+var init_readme = __esm({
+  "src/generators/readme.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/installers/dependencies.ts
+import { createLogger as createLogger2 } from "@revealui/setup/utils";
+import { execa } from "execa";
+import ora from "ora";
+async function installDependencies(projectPath) {
+  const spinner = ora("Installing dependencies with pnpm...").start();
+  try {
+    await execa("pnpm", ["install"], {
+      cwd: projectPath,
+      stdio: "pipe"
+    });
+    spinner.succeed("Dependencies installed successfully");
+  } catch (error) {
+    spinner.fail("Failed to install dependencies");
+    logger2.error('Please run "pnpm install" manually');
+    throw error;
+  }
+}
+async function isPnpmInstalled() {
+  try {
+    await execa("pnpm", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var logger2;
+var init_dependencies = __esm({
+  "src/installers/dependencies.ts"() {
+    "use strict";
+    init_esm_shims();
+    logger2 = createLogger2({ prefix: "Install" });
+  }
+});
+
+// src/utils/git.ts
+import { createLogger as createLogger3 } from "@revealui/setup/utils";
+import { execa as execa2 } from "execa";
+async function initializeGitRepo(projectPath) {
+  try {
+    await execa2("git", ["init"], { cwd: projectPath });
+    logger3.success("Initialized git repository");
+  } catch (error) {
+    logger3.warn("Failed to initialize git repository");
+    throw error;
+  }
+}
+async function createInitialCommit(projectPath) {
+  try {
+    await execa2("git", ["add", "."], { cwd: projectPath });
+    await execa2("git", ["commit", "-m", "Initial commit from @revealui/cli"], { cwd: projectPath });
+    logger3.success("Created initial commit");
+  } catch (error) {
+    logger3.warn("Failed to create initial commit");
+    throw error;
+  }
+}
+async function isGitInstalled() {
+  try {
+    await execa2("git", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var logger3;
+var init_git = __esm({
+  "src/utils/git.ts"() {
+    "use strict";
+    init_esm_shims();
+    logger3 = createLogger3({ prefix: "Git" });
+  }
+});
+
+// src/commands/create.ts
+import crypto from "crypto";
+import fs4 from "fs/promises";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { createLogger as createLogger4 } from "@revealui/setup/utils";
+import ora2 from "ora";
+function buildEnvLocal(cfg) {
+  const lines = [
+    "# Generated by @revealui/cli \u2014 fill in the remaining placeholders before running `pnpm dev`",
+    "",
+    "# Core",
+    `REVEALUI_SECRET=${generateSecret()}`,
+    `REVEALUI_PUBLIC_SERVER_URL=http://localhost:4000`,
+    `NEXT_PUBLIC_SERVER_URL=http://localhost:4000`,
+    "",
+    "# Database"
+  ];
+  if (cfg.database.postgresUrl) {
+    lines.push(`POSTGRES_URL=${cfg.database.postgresUrl}`);
+  } else {
+    lines.push("POSTGRES_URL=postgresql://postgres:postgres@localhost:5432/revealui");
+  }
+  lines.push("", "# Storage (Vercel Blob)");
+  if (cfg.storage.provider === "vercel-blob" && cfg.storage.blobToken) {
+    lines.push(`BLOB_READ_WRITE_TOKEN=${cfg.storage.blobToken}`);
+  } else {
+    lines.push("BLOB_READ_WRITE_TOKEN=vercel_blob_rw_placeholder");
+  }
+  lines.push("", "# Stripe");
+  if (cfg.payment.enabled && cfg.payment.stripeSecretKey) {
+    lines.push(`STRIPE_SECRET_KEY=${cfg.payment.stripeSecretKey}`);
+    lines.push(`STRIPE_WEBHOOK_SECRET=${cfg.payment.stripeWebhookSecret || "whsec_placeholder"}`);
+    lines.push(
+      `NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=${cfg.payment.stripePublishableKey || "pk_test_placeholder"}`
+    );
+  } else {
+    lines.push("STRIPE_SECRET_KEY=sk_test_placeholder");
+    lines.push("STRIPE_WEBHOOK_SECRET=whsec_placeholder");
+    lines.push("NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY=pk_test_placeholder");
+  }
+  lines.push("", "# Admin bootstrap (used on first run only)");
+  lines.push("REVEALUI_ADMIN_EMAIL=admin@example.com");
+  lines.push("REVEALUI_ADMIN_PASSWORD=changeme-min-12-chars");
+  return `${lines.join("\n")}
+`;
+}
+function generateSecret() {
+  return crypto.randomBytes(24).toString("hex");
+}
+async function copyTemplate(templateName, targetPath) {
+  const templatePath = path5.join(TEMPLATES_DIR, templateName);
+  try {
+    await fs4.access(templatePath);
+  } catch {
+    throw new Error(
+      `Template "${templateName}" not found at ${templatePath}. Available templates: minimal, basic-blog, e-commerce, portfolio`
+    );
+  }
+  await copyDir(templatePath, targetPath);
+}
+async function copyDir(src, dest) {
+  await fs4.mkdir(dest, { recursive: true });
+  const entries = await fs4.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path5.join(src, entry.name);
+    const destName = entry.name === "_gitignore" ? ".gitignore" : entry.name;
+    const destPath = path5.join(dest, destName);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs4.copyFile(srcPath, destPath);
+    }
+  }
+}
+function resolveTemplateName(template) {
+  const map = {
+    "basic-blog": "minimal",
+    "e-commerce": "minimal",
+    portfolio: "minimal"
+  };
+  return map[template] ?? "minimal";
+}
+async function createProject(cfg) {
+  const { project, skipGit = false, skipInstall = false } = cfg;
+  const { projectPath, projectName, template } = project;
+  const spinner = ora2(`Copying template "${template}"...`).start();
+  try {
+    await copyTemplate(resolveTemplateName(template), projectPath);
+    spinner.succeed("Template files copied");
+  } catch (err) {
+    spinner.fail("Failed to copy template files");
+    throw err;
+  }
+  const pkgJsonPath = path5.join(projectPath, "package.json");
+  try {
+    const raw = await fs4.readFile(pkgJsonPath, "utf-8");
+    await fs4.writeFile(pkgJsonPath, raw.replaceAll("{{PROJECT_NAME}}", projectName), "utf-8");
+  } catch {
+  }
+  const envSpinner = ora2("Writing .env.local...").start();
+  try {
+    await fs4.writeFile(path5.join(projectPath, ".env.local"), buildEnvLocal(cfg), "utf-8");
+    envSpinner.succeed(".env.local written");
+  } catch (err) {
+    envSpinner.fail("Failed to write .env.local");
+    throw err;
+  }
+  await generateReadme(projectPath, project);
+  logger4.success("README.md generated");
+  if (cfg.devenv.createDevContainer) {
+    await generateDevContainer(projectPath);
+    logger4.success(".devcontainer/ generated");
+  }
+  if (cfg.devenv.createDevbox) {
+    await generateDevbox(projectPath);
+    logger4.success("devbox.json generated");
+  }
+  if (!skipInstall) {
+    const pnpmOk = await isPnpmInstalled();
+    if (!pnpmOk) {
+      logger4.warn("pnpm not found \u2014 skipping dependency installation. Run `pnpm install` manually.");
+    } else {
+      await installDependencies(projectPath);
+    }
+  } else {
+    logger4.info("Skipping dependency installation (--skip-install)");
+  }
+  if (!skipGit) {
+    const gitOk = await isGitInstalled();
+    if (!gitOk) {
+      logger4.warn("git not found \u2014 skipping repository initialisation.");
+    } else {
+      await initializeGitRepo(projectPath);
+      await createInitialCommit(projectPath);
+    }
+  } else {
+    logger4.info("Skipping git initialisation (--skip-git)");
+  }
+}
+var logger4, __filename2, __dirname2, TEMPLATES_DIR;
+var init_create = __esm({
+  "src/commands/create.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_devbox();
+    init_devcontainer();
+    init_readme();
+    init_dependencies();
+    init_git();
+    logger4 = createLogger4({ prefix: "Create" });
+    __filename2 = fileURLToPath2(import.meta.url);
+    __dirname2 = path5.dirname(__filename2);
+    TEMPLATES_DIR = path5.resolve(__dirname2, "../../templates");
+  }
+});
+
+// src/validators/credentials.ts
+import { createLogger as createLogger5 } from "@revealui/setup/utils";
+async function validateStripeKey(key) {
+  if (!(key.startsWith("sk_test_") || key.startsWith("sk_live_"))) {
+    return {
+      valid: false,
+      message: "Stripe key must start with sk_test_ or sk_live_"
+    };
+  }
+  return { valid: true };
+}
+async function validateNeonUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (!parsed.protocol.startsWith("postgres")) {
+      return {
+        valid: false,
+        message: "Database URL must use postgres:// or postgresql:// protocol"
+      };
+    }
+    return { valid: true };
+  } catch {
+    return {
+      valid: false,
+      message: "Invalid database URL format"
+    };
+  }
+}
+async function validateVercelToken(token) {
+  if (!token || token.length < 20) {
+    return {
+      valid: false,
+      message: "Vercel token appears invalid (too short)"
+    };
+  }
+  return { valid: true };
+}
+async function validateSupabaseUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (!parsed.hostname.includes("supabase")) {
+      logger5.warn("URL does not appear to be a Supabase URL");
+    }
+    return { valid: true };
+  } catch {
+    return {
+      valid: false,
+      message: "Invalid Supabase URL format"
+    };
+  }
+}
+var logger5;
+var init_credentials = __esm({
+  "src/validators/credentials.ts"() {
+    "use strict";
+    init_esm_shims();
+    logger5 = createLogger5({ prefix: "Validator" });
+  }
+});
+
+// src/prompts/database.ts
+import inquirer from "inquirer";
+async function promptDatabaseConfig() {
+  const { provider } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "provider",
+      message: "Which database provider would you like to use?",
+      choices: [
+        {
+          name: "NeonDB - Serverless PostgreSQL (recommended)",
+          value: "neon"
+        },
+        {
+          name: "Supabase - PostgreSQL with built-in features",
+          value: "supabase"
+        },
+        {
+          name: "Local PostgreSQL - Use existing local database",
+          value: "local"
+        },
+        {
+          name: "Skip - Configure later",
+          value: "skip"
+        }
+      ],
+      default: "neon"
+    }
+  ]);
+  if (provider === "skip") {
+    return { provider: "skip" };
+  }
+  if (provider === "local") {
+    const { postgresUrl: postgresUrl2 } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "postgresUrl",
+        message: "Enter your PostgreSQL connection string:",
+        default: "postgresql://postgres:postgres@localhost:5432/revealui",
+        validate: async (input) => {
+          const result = await validateNeonUrl(input);
+          return result.valid ? true : result.message || "Invalid database URL";
+        }
+      }
+    ]);
+    return { provider: "local", postgresUrl: postgresUrl2 };
+  }
+  const { postgresUrl } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "postgresUrl",
+      message: `Enter your ${provider === "neon" ? "Neon" : "Supabase"} database connection string:`,
+      validate: async (input) => {
+        if (!input || input.trim() === "") {
+          return "Database URL is required";
+        }
+        const result = await validateNeonUrl(input);
+        return result.valid ? true : result.message || "Invalid database URL";
+      }
+    }
+  ]);
+  return { provider, postgresUrl };
+}
+var init_database = __esm({
+  "src/prompts/database.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_credentials();
+  }
+});
+
+// src/prompts/devenv.ts
+import inquirer2 from "inquirer";
+async function promptDevEnvConfig() {
+  const answers = await inquirer2.prompt([
+    {
+      type: "confirm",
+      name: "createDevContainer",
+      message: "Create Dev Container configuration for VS Code / GitHub Codespaces?",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "createDevbox",
+      message: "Create Devbox configuration for Nix-powered development?",
+      default: true
+    }
+  ]);
+  return answers;
+}
+var init_devenv = __esm({
+  "src/prompts/devenv.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/prompts/payments.ts
+import inquirer3 from "inquirer";
+async function promptPaymentConfig() {
+  const { enabled } = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "enabled",
+      message: "Do you want to configure Stripe payments?",
+      default: true
+    }
+  ]);
+  if (!enabled) {
+    return { enabled: false };
+  }
+  const answers = await inquirer3.prompt([
+    {
+      type: "input",
+      name: "stripeSecretKey",
+      message: "Enter your Stripe secret key (sk_test_... or sk_live_...):",
+      validate: async (input) => {
+        if (!input || input.trim() === "") {
+          return "Stripe secret key is required";
+        }
+        const result = await validateStripeKey(input);
+        return result.valid ? true : result.message || "Invalid Stripe key";
+      }
+    },
+    {
+      type: "input",
+      name: "stripePublishableKey",
+      message: "Enter your Stripe publishable key (pk_test_... or pk_live_...):",
+      validate: (input) => {
+        if (!input || input.trim() === "") {
+          return "Stripe publishable key is required";
+        }
+        if (!(input.startsWith("pk_test_") || input.startsWith("pk_live_"))) {
+          return "Stripe publishable key must start with pk_test_ or pk_live_";
+        }
+        return true;
+      }
+    },
+    {
+      type: "input",
+      name: "stripeWebhookSecret",
+      message: "Enter your Stripe webhook secret (whsec_..., optional - press Enter to skip):",
+      default: ""
+    }
+  ]);
+  return {
+    enabled: true,
+    stripeSecretKey: answers.stripeSecretKey,
+    stripePublishableKey: answers.stripePublishableKey,
+    stripeWebhookSecret: answers.stripeWebhookSecret || void 0
+  };
+}
+var init_payments = __esm({
+  "src/prompts/payments.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_credentials();
+  }
+});
+
+// src/prompts/project.ts
+import fs5 from "fs";
+import path6 from "path";
+import inquirer4 from "inquirer";
+async function promptProjectConfig(defaultName) {
+  const answers = await inquirer4.prompt([
+    {
+      type: "input",
+      name: "projectName",
+      message: "What is your project name?",
+      default: defaultName || "my-revealui-project",
+      validate: (input) => {
+        if (!/^[a-z0-9-]+$/.test(input)) {
+          return "Project name must contain only lowercase letters, numbers, and hyphens";
+        }
+        const projectPath = path6.resolve(process.cwd(), input);
+        if (fs5.existsSync(projectPath)) {
+          return `Directory "${input}" already exists`;
+        }
+        return true;
+      }
+    },
+    {
+      type: "list",
+      name: "template",
+      message: "Which template would you like to use?",
+      choices: [
+        {
+          name: "Basic Blog - A simple blog with posts and pages",
+          value: "basic-blog"
+        },
+        {
+          name: "E-commerce - Product catalog with checkout",
+          value: "e-commerce"
+        },
+        {
+          name: "Portfolio - Personal portfolio site",
+          value: "portfolio"
+        }
+      ],
+      default: "basic-blog"
+    }
+  ]);
+  return {
+    projectName: answers.projectName,
+    projectPath: path6.resolve(process.cwd(), answers.projectName),
+    template: answers.template
+  };
+}
+var init_project = __esm({
+  "src/prompts/project.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/prompts/storage.ts
+import inquirer5 from "inquirer";
+async function promptStorageConfig() {
+  const { provider } = await inquirer5.prompt([
+    {
+      type: "list",
+      name: "provider",
+      message: "Which storage provider would you like to use?",
+      choices: [
+        {
+          name: "Vercel Blob - Simple object storage (recommended)",
+          value: "vercel-blob"
+        },
+        {
+          name: "Supabase Storage - Integrated with Supabase",
+          value: "supabase"
+        },
+        {
+          name: "Skip - Configure later",
+          value: "skip"
+        }
+      ],
+      default: "vercel-blob"
+    }
+  ]);
+  if (provider === "skip") {
+    return { provider: "skip" };
+  }
+  if (provider === "vercel-blob") {
+    const { blobToken } = await inquirer5.prompt([
+      {
+        type: "input",
+        name: "blobToken",
+        message: "Enter your Vercel Blob read/write token:",
+        validate: async (input) => {
+          if (!input || input.trim() === "") {
+            return "Blob token is required";
+          }
+          const result = await validateVercelToken(input);
+          return result.valid ? true : result.message || "Invalid token";
+        }
+      }
+    ]);
+    return { provider: "vercel-blob", blobToken };
+  }
+  const answers = await inquirer5.prompt([
+    {
+      type: "input",
+      name: "supabaseUrl",
+      message: "Enter your Supabase project URL:",
+      validate: async (input) => {
+        if (!input || input.trim() === "") {
+          return "Supabase URL is required";
+        }
+        const result = await validateSupabaseUrl(input);
+        return result.valid ? true : result.message || "Invalid URL";
+      }
+    },
+    {
+      type: "input",
+      name: "supabaseAnonKey",
+      message: "Enter your Supabase anonymous key:",
+      validate: (input) => {
+        if (!input || input.trim() === "") {
+          return "Supabase anonymous key is required";
+        }
+        return true;
+      }
+    }
+  ]);
+  return {
+    provider: "supabase",
+    supabaseUrl: answers.supabaseUrl,
+    supabaseAnonKey: answers.supabaseAnonKey
+  };
+}
+var init_storage = __esm({
+  "src/prompts/storage.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_credentials();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  run: () => run
+});
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { createLogger as createLogger6 } from "@revealui/setup/utils";
+function checkProLicense() {
+  let key = process.env.REVEALUI_LICENSE_KEY;
+  if (!key) {
+    try {
+      const licenseFile = join(homedir(), ".revealui", "license.json");
+      const parsed = JSON.parse(readFileSync(licenseFile, "utf8"));
+      key = parsed.key;
+    } catch {
+    }
+  }
+  if (!key) return false;
+  try {
+    const parts = key.split(".");
+    if (parts.length < 2) return false;
+    const payload = JSON.parse(Buffer.from(parts[1] ?? "", "base64").toString("utf8"));
+    const tier = payload.tier ?? "free";
+    return tier === "pro" || tier === "enterprise";
+  } catch {
+    return false;
+  }
+}
+async function run(projectName, _options) {
+  try {
+    logger6.info("[1/8] Validating Node.js version...");
+    if (!validateNodeVersion()) {
+      process.exit(1);
+    }
+    logger6.success(`Node.js version: ${process.version}`);
+    logger6.info("[2/8] Configure your project");
+    const projectConfig = await promptProjectConfig(projectName);
+    logger6.success(`Project: ${projectConfig.projectName}`);
+    logger6.success(`Template: ${projectConfig.template}`);
+    if (PRO_TEMPLATES.has(projectConfig.template)) {
+      if (!checkProLicense()) {
+        logger6.error(`The "${projectConfig.template}" template requires a RevealUI Pro license.`);
+        logger6.info("Get Pro at https://revealui.com/pricing");
+        logger6.info("Set your license key: export REVEALUI_LICENSE_KEY=<your-key>");
+        process.exit(2);
+      }
+      logger6.success("Pro license verified");
+    }
+    logger6.info("[3/8] Configure database");
+    const databaseConfig = await promptDatabaseConfig();
+    if (databaseConfig.provider !== "skip") {
+      logger6.success(`Database: ${databaseConfig.provider}`);
+    } else {
+      logger6.info("Database configuration skipped");
+    }
+    logger6.info("[4/8] Configure storage");
+    const storageConfig = await promptStorageConfig();
+    if (storageConfig.provider !== "skip") {
+      logger6.success(`Storage: ${storageConfig.provider}`);
+    } else {
+      logger6.info("Storage configuration skipped");
+    }
+    logger6.info("[5/8] Configure payments");
+    const paymentConfig = await promptPaymentConfig();
+    if (paymentConfig.enabled) {
+      logger6.success("Stripe configured");
+    } else {
+      logger6.info("Payments disabled");
+    }
+    logger6.info("[6/8] Configure development environment");
+    const devEnvConfig = await promptDevEnvConfig();
+    logger6.success(
+      `Dev Container: ${devEnvConfig.createDevContainer ? "Yes" : "No"}, Devbox: ${devEnvConfig.createDevbox ? "Yes" : "No"}`
+    );
+    logger6.info("[7/8] Creating project...");
+    await createProject({
+      project: projectConfig,
+      database: databaseConfig,
+      storage: storageConfig,
+      payment: paymentConfig,
+      devenv: devEnvConfig,
+      skipGit: _options.skipGit,
+      skipInstall: _options.skipInstall
+    });
+    logger6.success("Project created successfully");
+    logger6.info("[8/8] Next steps");
+    logger6.divider();
+    logger6.info(`cd ${projectConfig.projectName}`);
+    logger6.info("pnpm install");
+    logger6.info("pnpm dev");
+    logger6.divider();
+    logger6.success(`\u{1F389} Project ${projectConfig.projectName} created successfully!`);
+  } catch (error) {
+    if (error instanceof Error) {
+      logger6.error(`Failed to create project: ${error.message}`);
+    } else {
+      logger6.error("An unexpected error occurred");
+    }
+    process.exit(1);
+  }
+}
+var logger6, PRO_TEMPLATES;
+var init_index = __esm({
+  "src/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_cli();
+    init_node_version();
+    init_create();
+    init_database();
+    init_devenv();
+    init_payments();
+    init_project();
+    init_storage();
+    logger6 = createLogger6({ prefix: "@revealui/cli" });
+    PRO_TEMPLATES = /* @__PURE__ */ new Set(["e-commerce", "portfolio"]);
+    if (import.meta.url === `file://${process.argv[1]}`) {
+      const cli = createCli();
+      cli.parse(process.argv);
+    }
+  }
+});
+
+// src/cli.ts
+import { createLogger as createLogger7 } from "@revealui/setup/utils";
+import { Command } from "commander";
+function createCli() {
+  const program = new Command();
+  program.name("create-revealui").description("Create a new RevealUI project").version("0.1.0").argument("[project-name]", "Name of the project").option("-t, --template <name>", "Template to use (basic-blog, e-commerce, portfolio)").option("--skip-git", "Skip git initialization", false).option("--skip-install", "Skip dependency installation", false).action(async (projectName, options) => {
+    logger7.header("\u{1F680} Create RevealUI Project");
+    const { run: run2 } = await Promise.resolve().then(() => (init_index(), index_exports));
+    await run2(projectName, options);
+  });
+  return program;
+}
+var logger7;
+var init_cli = __esm({
+  "src/cli.ts"() {
+    init_esm_shims();
+    logger7 = createLogger7({ prefix: "CLI" });
+  }
+});
+init_cli();
+export {
+  createCli
+};
+//# sourceMappingURL=cli.js.map