@revealui/cli 0.2.0 → 0.3.0

package/dist/cli.js

@@ -1,141 +1,455 @@
-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 });
-};
+// src/cli.ts
+import { createLogger as createLogger11 } from "@revealui/setup/utils";
+import { Command } from "commander";
 
-// ../../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/commands/create-flow.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { createLogger as createLogger6 } from "@revealui/setup/utils";
+import { importSPKI, jwtVerify } from "jose";
 
-// src/validators/node-version.ts
+// src/prompts/database.ts
+import inquirer from "inquirer";
+
+// src/validators/credentials.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;
+var logger = createLogger({ prefix: "Validator" });
+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 true;
+  return { valid: 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";
+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")) {
+      logger.warn("URL does not appear to be a Supabase URL");
+    }
+    return { valid: true };
+  } catch {
+    return {
+      valid: false,
+      message: "Invalid Supabase URL format"
+    };
   }
-});
+}
 
-// 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"'
+// src/prompts/database.ts
+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"
+        }
       ],
-      scripts: {
-        dev: "pnpm dev",
-        setup: "pnpm install && pnpm db:init",
-        test: "pnpm test"
+      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";
       }
-    },
-    env: {
-      NODE_ENV: "development"
     }
-  };
-  await fs.writeFile(
-    path2.join(projectPath, "devbox.json"),
-    JSON.stringify(devboxConfig, null, 2),
-    "utf-8"
-  );
+  ]);
+  return { provider, postgresUrl };
 }
-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
-      }
+// 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
     },
-    forwardPorts: [3e3, 4e3, 5432],
-    portsAttributes: {
-      "3000": {
-        label: "Web App",
-        onAutoForward: "notify"
-      },
-      "4000": {
-        label: "CMS",
-        onAutoForward: "notify"
-      },
-      "5432": {
-        label: "PostgreSQL",
-        onAutoForward: "silent"
+    {
+      type: "confirm",
+      name: "createDevbox",
+      message: "Create Devbox configuration for Nix-powered development?",
+      default: true
+    }
+  ]);
+  return answers;
+}
+
+// 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";
       }
     },
-    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"
-          }
+    {
+      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;
       }
     },
-    remoteUser: "node"
-  };
-  await fs2.writeFile(
-    path3.join(devcontainerDir, "devcontainer.json"),
-    JSON.stringify(devcontainerConfig, null, 2),
-    "utf-8"
-  );
-  const dockerCompose = `version: '3.8'
+    {
+      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
+  };
+}
+
+// src/prompts/project.ts
+import fs from "fs";
+import path from "path";
+import inquirer4 from "inquirer";
+var VALID_TEMPLATES = ["basic-blog", "e-commerce", "portfolio"];
+async function promptProjectConfig(defaultName, templateArg) {
+  let projectName;
+  if (defaultName) {
+    projectName = defaultName;
+  } else {
+    const answers = await inquirer4.prompt([
+      {
+        type: "input",
+        name: "projectName",
+        message: "What is your project name?",
+        default: "my-revealui-project",
+        validate: (input) => {
+          if (!/^[a-z0-9-]+$/.test(input)) {
+            return "Project name must contain only lowercase letters, numbers, and hyphens";
+          }
+          const projectPath = path.resolve(process.cwd(), input);
+          if (fs.existsSync(projectPath)) {
+            return `Directory "${input}" already exists`;
+          }
+          return true;
+        }
+      }
+    ]);
+    projectName = answers.projectName;
+  }
+  let template;
+  if (templateArg && VALID_TEMPLATES.includes(templateArg)) {
+    template = templateArg;
+  } else {
+    const answers = await inquirer4.prompt([
+      {
+        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"
+      }
+    ]);
+    template = answers.template;
+  }
+  return {
+    projectName,
+    projectPath: path.resolve(process.cwd(), projectName),
+    template
+  };
+}
+
+// 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: "supabasePublishableKey",
+      message: "Enter your Supabase publishable key (sb_publishable_...):",
+      validate: (input) => {
+        if (!input || input.trim() === "") {
+          return "Supabase publishable key is required";
+        }
+        return true;
+      }
+    }
+  ]);
+  return {
+    provider: "supabase",
+    supabaseUrl: answers.supabaseUrl,
+    supabasePublishableKey: answers.supabasePublishableKey
+  };
+}
+
+// src/validators/node-version.ts
+import { createLogger as createLogger2 } from "@revealui/setup/utils";
+var logger2 = createLogger2({ prefix: "Setup" });
+var REQUIRED_NODE_VERSION = "24.13.0";
+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) {
+    logger2.error(
+      `Node.js ${REQUIRED_NODE_VERSION} or higher is required. You have ${currentVersion}.`
+    );
+    logger2.info("Please upgrade Node.js: https://nodejs.org/");
+    return false;
+  }
+  return true;
+}
+
+// src/commands/create.ts
+import crypto from "crypto";
+import fs5 from "fs/promises";
+import path5 from "path";
+import { fileURLToPath } from "url";
+import { createLogger as createLogger5 } from "@revealui/setup/utils";
+import ora2 from "ora";
+
+// src/generators/devbox.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+async function generateDevbox(projectPath) {
+  const devboxConfig = {
+    packages: ["nodejs@24.13.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 fs2.writeFile(
+    path2.join(projectPath, "devbox.json"),
+    JSON.stringify(devboxConfig, null, 2),
+    "utf-8"
+  );
+}
+
+// src/generators/devcontainer.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+async function generateDevContainer(projectPath) {
+  const devcontainerDir = path3.join(projectPath, ".devcontainer");
+  await fs3.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: [
+          "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 fs3.writeFile(
+    path3.join(devcontainerDir, "devcontainer.json"),
+    JSON.stringify(devcontainerConfig, null, 2),
+    "utf-8"
+  );
+  const dockerCompose = `version: '3.8'
 
 services:
   app:
@@ -160,7 +474,7 @@ services:
 volumes:
   postgres-data:
 `;
-  await fs2.writeFile(path3.join(devcontainerDir, "docker-compose.yml"), dockerCompose, "utf-8");
+  await fs3.writeFile(path3.join(devcontainerDir, "docker-compose.yml"), dockerCompose, "utf-8");
   const dockerfile = `FROM mcr.microsoft.com/devcontainers/typescript-node:24
 
 # Install additional tools
@@ -170,7 +484,7 @@ RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \\
 # Enable pnpm
 RUN corepack enable
 `;
-  await fs2.writeFile(path3.join(devcontainerDir, "Dockerfile"), dockerfile, "utf-8");
+  await fs3.writeFile(path3.join(devcontainerDir, "Dockerfile"), dockerfile, "utf-8");
   const readme = `# Dev Container Setup
 
 This directory contains the Dev Container configuration for RevealUI.
@@ -191,11 +505,10 @@ This directory contains the Dev Container configuration for RevealUI.
 
 ## What's Included
 
-- Node.js 24.12.0
+- Node.js 24.13.0
 - pnpm package manager
 - PostgreSQL 16 with pgvector
 - VS Code extensions:
-  - ESLint
   - Biome
   - Tailwind CSS
   - Prisma
@@ -213,17 +526,11 @@ For GitHub Codespaces, set secrets in your repository settings.
 - 4000: CMS
 - 5432: PostgreSQL database
 `;
-  await fs2.writeFile(path3.join(devcontainerDir, "README.md"), readme, "utf-8");
+  await fs3.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 fs4 from "fs/promises";
 import path4 from "path";
 async function generateReadme(projectPath, projectConfig) {
   const readme = `# ${projectConfig.projectName}
@@ -260,7 +567,7 @@ The web application runs on [http://localhost:3000](http://localhost:3000).
 ### Standard Setup
 
 Requirements:
-- Node.js 24.12.0 or higher
+- Node.js 24.13.0 or higher
 - pnpm 10.28.2 or higher
 - PostgreSQL 16
 
@@ -324,19 +631,14 @@ This project was created using the **${projectConfig.template}** template.
 
 MIT
 `;
-  await fs3.writeFile(path4.join(projectPath, "README.md"), readme, "utf-8");
+  await fs4.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 { createLogger as createLogger3 } from "@revealui/setup/utils";
 import { execa } from "execa";
 import ora from "ora";
+var logger3 = createLogger3({ prefix: "Install" });
 async function installDependencies(projectPath) {
   const spinner = ora("Installing dependencies with pnpm...").start();
   try {
@@ -347,7 +649,7 @@ async function installDependencies(projectPath) {
     spinner.succeed("Dependencies installed successfully");
   } catch (error) {
     spinner.fail("Failed to install dependencies");
-    logger2.error('Please run "pnpm install" manually');
+    logger3.error('Please run "pnpm install" manually');
     throw error;
   }
 }
@@ -359,24 +661,17 @@ async function isPnpmInstalled() {
     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 { createLogger as createLogger4 } from "@revealui/setup/utils";
 import { execa as execa2 } from "execa";
+var logger4 = createLogger4({ prefix: "Git" });
 async function initializeGitRepo(projectPath) {
   try {
     await execa2("git", ["init"], { cwd: projectPath });
-    logger3.success("Initialized git repository");
+    logger4.success("Initialized git repository");
   } catch (error) {
-    logger3.warn("Failed to initialize git repository");
+    logger4.warn("Failed to initialize git repository");
     throw error;
   }
 }
@@ -384,9 +679,9 @@ 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");
+    logger4.success("Created initial commit");
   } catch (error) {
-    logger3.warn("Failed to create initial commit");
+    logger4.warn("Failed to create initial commit");
     throw error;
   }
 }
@@ -398,22 +693,12 @@ async function isGitInstalled() {
     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";
+var logger5 = createLogger5({ prefix: "Create" });
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path5.dirname(__filename2);
+var TEMPLATES_DIR = path5.resolve(__dirname2, "../../templates");
 function buildEnvLocal(cfg) {
   const lines = [
     "# Generated by @revealui/cli \u2014 fill in the remaining placeholders before running `pnpm dev`",
@@ -457,20 +742,28 @@ function buildEnvLocal(cfg) {
 function generateSecret() {
   return crypto.randomBytes(24).toString("hex");
 }
+async function listAvailableTemplates() {
+  try {
+    const entries = await fs5.readdir(TEMPLATES_DIR, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
 async function copyTemplate(templateName, targetPath) {
   const templatePath = path5.join(TEMPLATES_DIR, templateName);
   try {
-    await fs4.access(templatePath);
+    await fs5.access(templatePath);
   } catch {
-    throw new Error(
-      `Template "${templateName}" not found at ${templatePath}. Available templates: minimal, basic-blog, e-commerce, portfolio`
-    );
+    const available = await listAvailableTemplates();
+    const listing = available.length > 0 ? `Available templates: ${available.join(", ")}` : `No templates found in ${TEMPLATES_DIR}`;
+    throw new Error(`Template "${templateName}" not found at ${templatePath}. ${listing}`);
   }
   await copyDir(templatePath, targetPath);
 }
 async function copyDir(src, dest) {
-  await fs4.mkdir(dest, { recursive: true });
-  const entries = await fs4.readdir(src, { withFileTypes: true });
+  await fs5.mkdir(dest, { recursive: true });
+  const entries = await fs5.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
     const srcPath = path5.join(src, entry.name);
     const destName = entry.name === "_gitignore" ? ".gitignore" : entry.name;
@@ -478,17 +771,17 @@ async function copyDir(src, dest) {
     if (entry.isDirectory()) {
       await copyDir(srcPath, destPath);
     } else {
-      await fs4.copyFile(srcPath, destPath);
+      await fs5.copyFile(srcPath, destPath);
     }
   }
 }
 function resolveTemplateName(template) {
   const map = {
-    "basic-blog": "minimal",
-    "e-commerce": "minimal",
-    portfolio: "minimal"
+    "basic-blog": "basic-blog",
+    "e-commerce": "e-commerce",
+    portfolio: "portfolio"
   };
-  return map[template] ?? "minimal";
+  return map[template] ?? "starter";
 }
 async function createProject(cfg) {
   const { project, skipGit = false, skipInstall = false } = cfg;
@@ -503,437 +796,57 @@ async function createProject(cfg) {
   }
   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");
+    const raw = await fs5.readFile(pkgJsonPath, "utf-8");
+    await fs5.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");
+    await fs5.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");
+  logger5.success("README.md generated");
   if (cfg.devenv.createDevContainer) {
     await generateDevContainer(projectPath);
-    logger4.success(".devcontainer/ generated");
+    logger5.success(".devcontainer/ generated");
   }
   if (cfg.devenv.createDevbox) {
     await generateDevbox(projectPath);
-    logger4.success("devbox.json generated");
+    logger5.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.");
+      logger5.warn(
+        "pnpm not found \u2014 skipping dependency installation. Run `pnpm install` manually."
+      );
     } else {
       await installDependencies(projectPath);
     }
   } else {
-    logger4.info("Skipping dependency installation (--skip-install)");
+    logger5.info("Skipping dependency installation (--skip-install)");
   }
   if (!skipGit) {
     const gitOk = await isGitInstalled();
     if (!gitOk) {
-      logger4.warn("git not found \u2014 skipping repository initialisation.");
+      logger5.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();
+    logger5.info("Skipping git initialisation (--skip-git)");
   }
-});
+}
 
-// 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() {
+// src/commands/create-flow.ts
+var logger6 = createLogger6({ prefix: "@revealui/cli" });
+var PRO_TEMPLATES = /* @__PURE__ */ new Set([]);
+async function checkProLicense() {
   let key = process.env.REVEALUI_LICENSE_KEY;
   if (!key) {
     try {
@@ -944,132 +857,945 @@ function checkProLicense() {
     }
   }
   if (!key) return false;
+  const publicKeyPem = process.env.REVEALUI_LICENSE_PUBLIC_KEY;
+  if (publicKeyPem) {
+    try {
+      const publicKey = await importSPKI(publicKeyPem, "RS256");
+      const { payload } = await jwtVerify(key, publicKey);
+      const tier = payload.tier ?? "free";
+      return tier === "pro" || tier === "enterprise";
+    } catch {
+      return false;
+    }
+  }
   try {
     const parts = key.split(".");
-    if (parts.length < 2) return false;
-    const payload = JSON.parse(Buffer.from(parts[1] ?? "", "base64").toString("utf8"));
+    if (parts.length < 3) return false;
+    const payload = JSON.parse(Buffer.from(parts[1] ?? "", "base64url").toString("utf8"));
+    if (payload.exp !== void 0 && payload.exp < Math.floor(Date.now() / 1e3)) {
+      return false;
+    }
     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);
+async function runCreateFlow(projectName, options) {
+  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, options.template);
+  logger6.success(`Project: ${projectConfig.projectName}`);
+  logger6.success(`Template: ${projectConfig.template}`);
+  if (PRO_TEMPLATES.has(projectConfig.template)) {
+    if (!await 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(`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");
+  }
+  const nonInteractive = options.yes === true;
+  logger6.info("[3/8] Configure database");
+  const databaseConfig = nonInteractive ? { provider: "skip" } : 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 = nonInteractive ? { provider: "skip" } : 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 = nonInteractive ? { enabled: false } : await promptPaymentConfig();
+  if (paymentConfig.enabled) {
+    logger6.success("Stripe configured");
+  } else {
+    logger6.info("Payments disabled");
+  }
+  logger6.info("[6/8] Configure development environment");
+  const devEnvConfig = nonInteractive ? { createDevContainer: false, createDevbox: false } : 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(`Project ${projectConfig.projectName} created successfully`);
+}
+
+// src/commands/db.ts
+import fs8 from "fs/promises";
+import path8 from "path";
+import { createLogger as createLogger7 } from "@revealui/setup/utils";
+import { execa as execa4 } from "execa";
+
+// src/utils/command.ts
+import net from "net";
+import { execa as execa3 } from "execa";
+async function commandExists(command) {
+  try {
+    await execa3("bash", ["-lc", `command -v ${command}`], {
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isTcpReachable(host, port, timeoutMs = 1500) {
+  return await new Promise((resolve) => {
+    const socket = new net.Socket();
+    const finalize = (value) => {
+      socket.removeAllListeners();
+      socket.destroy();
+      resolve(value);
+    };
+    socket.setTimeout(timeoutMs);
+    socket.once("connect", () => finalize(true));
+    socket.once("timeout", () => finalize(false));
+    socket.once("error", () => finalize(false));
+    socket.connect(port, host);
+  });
+}
+
+// src/utils/db.ts
+import fs6 from "fs/promises";
+import path6 from "path";
+function resolveLocalDbConfig(cwd = process.cwd(), env = process.env) {
+  const pgdata = env.PGDATA || path6.join(cwd, ".pgdata");
+  const pghost = env.PGHOST || pgdata;
+  const pgdatabase = env.PGDATABASE || "postgres";
+  const pguser = env.PGUSER || "postgres";
+  const postgresUrl = env.POSTGRES_URL || "postgresql://postgres@localhost:5432/postgres";
+  const databaseUrl = env.DATABASE_URL || postgresUrl;
+  return {
+    pgdata,
+    pghost,
+    pgdatabase,
+    pguser,
+    postgresUrl,
+    databaseUrl
+  };
+}
+function isLocalDbUrl(url) {
+  if (!url) return false;
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+  } catch {
+    return false;
+  }
+}
+function detectDbTarget(url) {
+  if (!url) return "missing";
+  return isLocalDbUrl(url) ? "local" : "remote";
+}
+function buildPostgresConfig(pgdata) {
+  return `
+# RevealUI Development Settings
+listen_addresses = 'localhost'
+port = 5432
+max_connections = 100
+shared_buffers = 128MB
+unix_socket_directories = '${pgdata}'
+`.trimStart();
+}
+function buildPgHbaConfig() {
+  return `
+# TYPE  DATABASE        USER            ADDRESS                 METHOD
+local   all             all                                     trust
+host    all             all             127.0.0.1/32            trust
+host    all             all             ::1/128                 trust
+`.trimStart();
+}
+async function writeLocalDbConfigs(pgdata) {
+  await fs6.appendFile(path6.join(pgdata, "postgresql.conf"), buildPostgresConfig(pgdata), "utf8");
+  await fs6.writeFile(path6.join(pgdata, "pg_hba.conf"), buildPgHbaConfig(), "utf8");
+}
+
+// src/utils/workspace.ts
+import fs7 from "fs";
+import path7 from "path";
+function findWorkspaceRoot(startDir = process.cwd()) {
+  let current = path7.resolve(startDir);
+  while (true) {
+    const packageJsonPath = path7.join(current, "package.json");
+    if (fs7.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(fs7.readFileSync(packageJsonPath, "utf8"));
+        if (pkg.name === "revealui" && pkg.private === true) {
+          return current;
+        }
+      } catch {
       }
-      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");
+    const parent = path7.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+// src/commands/db.ts
+var logger7 = createLogger7({ prefix: "DB" });
+function isPgCtlNotRunningError(error) {
+  return typeof error === "object" && error !== null && "exitCode" in error && error.exitCode === 3;
+}
+function getWorkspaceRootOrThrow() {
+  const root = findWorkspaceRoot();
+  if (!root) {
+    throw new Error("RevealUI workspace root not found");
+  }
+  return root;
+}
+function buildDbEnv(root) {
+  const config = resolveLocalDbConfig(root, process.env);
+  return {
+    ...process.env,
+    PGDATA: config.pgdata,
+    PGHOST: config.pghost,
+    PGDATABASE: config.pgdatabase,
+    PGUSER: config.pguser,
+    POSTGRES_URL: config.postgresUrl,
+    DATABASE_URL: config.databaseUrl
+  };
+}
+function getPgDataOrThrow(env) {
+  const pgdata = env.PGDATA;
+  if (!pgdata) {
+    throw new Error("PGDATA is not configured for the local RevealUI database");
+  }
+  return pgdata;
+}
+async function requireCommand(command) {
+  if (!await commandExists(command)) {
+    throw new Error(`${command} is not available in PATH`);
+  }
+}
+async function runDbInitCommand(options = {}) {
+  const root = getWorkspaceRootOrThrow();
+  const env = buildDbEnv(root);
+  const pgdata = getPgDataOrThrow(env);
+  await requireCommand("initdb");
+  try {
+    await fs8.access(pgdata);
+    if (!options.force) {
+      throw new Error(`PostgreSQL is already initialized at ${pgdata}. Use --force to reset it.`);
+    }
+    await fs8.rm(pgdata, { recursive: true, force: true });
+  } catch (error) {
+    if (error instanceof Error && !error.message.includes("already initialized")) {
+    } else if (error instanceof Error) {
+      throw error;
+    }
+  }
+  await execa4(
+    "initdb",
+    ["--locale=C.UTF-8", "--encoding=UTF8", "-D", pgdata, "--username=postgres"],
+    {
+      env,
+      stdio: "inherit"
+    }
+  );
+  await writeLocalDbConfigs(pgdata);
+  logger7.success(`PostgreSQL initialized at ${pgdata}`);
+}
+async function runDbStartCommand() {
+  const root = getWorkspaceRootOrThrow();
+  const env = buildDbEnv(root);
+  const pgdata = getPgDataOrThrow(env);
+  await requireCommand("pg_ctl");
+  await fs8.access(pgdata);
+  await execa4(
+    "pg_ctl",
+    ["start", "-D", pgdata, "-l", path8.join(pgdata, "logfile"), "-o", `-k ${pgdata}`],
+    {
+      env,
+      stdio: "inherit"
+    }
+  );
+}
+async function runDbStopCommand() {
+  const root = getWorkspaceRootOrThrow();
+  const env = buildDbEnv(root);
+  const pgdata = getPgDataOrThrow(env);
+  await requireCommand("pg_ctl");
+  await execa4("pg_ctl", ["stop", "-D", pgdata], {
+    env,
+    stdio: "inherit"
+  });
+}
+async function runDbStatusCommand() {
+  const root = getWorkspaceRootOrThrow();
+  const env = buildDbEnv(root);
+  const pgdata = getPgDataOrThrow(env);
+  await requireCommand("pg_ctl");
+  try {
+    await execa4("pg_ctl", ["status", "-D", pgdata], {
+      env,
+      stdio: "inherit"
+    });
+  } catch (error) {
+    if (isPgCtlNotRunningError(error)) {
+      logger7.warn(`PostgreSQL is not running (PGDATA: ${pgdata})`);
+      return;
+    }
+    throw error;
+  }
+}
+async function runDbResetCommand(options = {}) {
+  if (!options.force) {
+    throw new Error("db reset is destructive. Re-run with --force.");
+  }
+  const root = getWorkspaceRootOrThrow();
+  const env = buildDbEnv(root);
+  const pgdata = getPgDataOrThrow(env);
+  if (await commandExists("pg_ctl")) {
+    try {
+      await execa4("pg_ctl", ["stop", "-D", pgdata], { env, stdio: "pipe" });
+    } catch {
     }
-    logger6.info("[4/8] Configure storage");
-    const storageConfig = await promptStorageConfig();
-    if (storageConfig.provider !== "skip") {
-      logger6.success(`Storage: ${storageConfig.provider}`);
+  }
+  await fs8.rm(pgdata, { recursive: true, force: true });
+  await runDbInitCommand({ force: false });
+}
+async function runDbMigrateCommand() {
+  const root = getWorkspaceRootOrThrow();
+  const env = buildDbEnv(root);
+  await execa4("pnpm", ["--filter", "@revealui/db", "db:migrate"], {
+    cwd: root,
+    env,
+    stdio: "inherit"
+  });
+}
+async function runDbCleanupCommand(options = {}) {
+  const root = getWorkspaceRootOrThrow();
+  const env = { ...process.env };
+  if (options.dryRun) env.DRY_RUN = "true";
+  if (options.tables) env.TABLES = options.tables;
+  await execa4("pnpm", ["--filter", "@revealui/db", "db:cleanup"], {
+    cwd: root,
+    env,
+    stdio: "inherit"
+  });
+}
+
+// src/commands/dev.ts
+import { createLogger as createLogger10 } from "@revealui/setup/utils";
+import { execa as execa6 } from "execa";
+
+// src/runtime/doctor.ts
+function getMcpDetail(env) {
+  const configuredKeys = [
+    env.VERCEL_API_KEY ? "vercel" : null,
+    env.STRIPE_SECRET_KEY ? "stripe" : null
+  ].filter((value) => value !== null);
+  if (configuredKeys.length === 0) {
+    return {
+      ok: false,
+      detail: "mcp credentials missing (set VERCEL_API_KEY and/or STRIPE_SECRET_KEY)"
+    };
+  }
+  return {
+    ok: true,
+    detail: `mcp credentials configured for ${configuredKeys.join(", ")}`
+  };
+}
+async function gatherDoctorReport(cwd = process.cwd(), env = process.env) {
+  const workspaceRoot = findWorkspaceRoot(cwd);
+  const dbConfig = resolveLocalDbConfig(workspaceRoot ?? cwd, env);
+  const dbTarget = detectDbTarget(env.POSTGRES_URL || env.DATABASE_URL);
+  const nodeOk = validateNodeVersion();
+  const pnpmOk = await commandExists("pnpm");
+  const nixOk = await commandExists("nix");
+  const direnvActive = Boolean(env.DIRENV_FILE || env.DIRENV_DIR);
+  const pgCtlOk = await commandExists("pg_ctl");
+  const initdbOk = await commandExists("initdb");
+  const dockerOk = await commandExists("docker");
+  const postgresReachable = dbTarget === "local" ? await isTcpReachable("127.0.0.1", 5432, 1e3) : false;
+  const mcp = getMcpDetail(env);
+  return {
+    workspaceRoot,
+    dbTarget,
+    checks: [
+      {
+        id: "workspace",
+        ok: workspaceRoot !== null,
+        detail: workspaceRoot ?? "RevealUI workspace root not found"
+      },
+      {
+        id: "node",
+        ok: nodeOk,
+        detail: process.version
+      },
+      {
+        id: "pnpm",
+        ok: pnpmOk,
+        detail: pnpmOk ? "pnpm available" : "pnpm not found"
+      },
+      {
+        id: "nix",
+        ok: nixOk,
+        detail: nixOk ? "nix available" : "nix not found"
+      },
+      {
+        id: "direnv",
+        ok: direnvActive,
+        detail: direnvActive ? "direnv active" : "direnv not active"
+      },
+      {
+        id: "db-target",
+        ok: dbTarget !== "missing",
+        detail: dbTarget === "missing" ? "No POSTGRES_URL or DATABASE_URL configured" : `${dbTarget} database target (${dbConfig.postgresUrl})`
+      },
+      {
+        id: "pg_ctl",
+        ok: pgCtlOk,
+        detail: pgCtlOk ? "pg_ctl available" : "pg_ctl not found"
+      },
+      {
+        id: "initdb",
+        ok: initdbOk,
+        detail: initdbOk ? "initdb available" : "initdb not found"
+      },
+      {
+        id: "postgres",
+        ok: dbTarget === "local" ? postgresReachable : true,
+        detail: dbTarget === "local" ? postgresReachable ? "local postgres reachable on 127.0.0.1:5432" : "local postgres not reachable on 127.0.0.1:5432" : "postgres reachability skipped for non-local target"
+      },
+      {
+        id: "docker",
+        ok: dockerOk,
+        detail: dockerOk ? "docker available" : "docker not found"
+      },
+      {
+        id: "mcp",
+        ok: mcp.ok,
+        detail: mcp.detail
+      }
+    ]
+  };
+}
+function formatDoctorReport(report) {
+  const lines = ["", `RevealUI  \xB7  ${report.workspaceRoot ?? "workspace not found"}`, ""];
+  for (const check of report.checks) {
+    lines.push(`${check.ok ? "OK" : "NO"}  ${check.id.padEnd(10)} ${check.detail}`);
+  }
+  return lines.join("\n");
+}
+
+// src/utils/dev-config.ts
+import fs9 from "fs";
+import path9 from "path";
+function getDevConfigPath(startDir = process.cwd()) {
+  const workspaceRoot = findWorkspaceRoot(startDir);
+  if (!workspaceRoot) {
+    return null;
+  }
+  return path9.join(workspaceRoot, ".revealui", "dev.json");
+}
+function readDevConfig(startDir = process.cwd()) {
+  const configPath = getDevConfigPath(startDir);
+  if (!(configPath && fs9.existsSync(configPath))) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs9.readFileSync(configPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeDevConfig(config, startDir = process.cwd()) {
+  const configPath = getDevConfigPath(startDir);
+  if (!configPath) {
+    throw new Error("RevealUI workspace root not found");
+  }
+  fs9.mkdirSync(path9.dirname(configPath), { recursive: true });
+  fs9.writeFileSync(`${configPath}`, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return configPath;
+}
+
+// src/commands/doctor.ts
+import { createLogger as createLogger8 } from "@revealui/setup/utils";
+var logger8 = createLogger8({ prefix: "Doctor" });
+function getDoctorFixPlan(report) {
+  const attempted = [];
+  const skipped = [];
+  const postgresCheck = report.checks.find((check) => check.id === "postgres");
+  const initdbCheck = report.checks.find((check) => check.id === "initdb");
+  const pgCtlCheck = report.checks.find((check) => check.id === "pg_ctl");
+  const mcpCheck = report.checks.find((check) => check.id === "mcp");
+  if (report.dbTarget === "local" && postgresCheck && !postgresCheck.ok) {
+    if (initdbCheck?.ok && pgCtlCheck?.ok) {
+      attempted.push("initialize/start local postgres");
     } else {
-      logger6.info("Storage configuration skipped");
+      skipped.push("local postgres repair requires both initdb and pg_ctl in PATH");
+    }
+  }
+  if (mcpCheck && !mcpCheck.ok) {
+    skipped.push("MCP readiness requires credentials and cannot be auto-fixed safely");
+  }
+  if (attempted.length === 0 && skipped.length === 0) {
+    skipped.push("no safe automatic fixes available");
+  }
+  return { attempted, skipped };
+}
+async function applyDoctorFixes(report) {
+  const plan = getDoctorFixPlan(report);
+  if (plan.attempted.includes("initialize/start local postgres")) {
+    try {
+      await runDbInitCommand();
+    } catch {
     }
-    logger6.info("[5/8] Configure payments");
-    const paymentConfig = await promptPaymentConfig();
-    if (paymentConfig.enabled) {
-      logger6.success("Stripe configured");
+    await runDbStartCommand();
+  }
+  return plan;
+}
+function formatDoctorFixPlan(plan) {
+  const lines = ["", "RevealUI Doctor Fix Plan", ""];
+  for (const action of plan.attempted) {
+    lines.push(`fix      ${action}`);
+  }
+  for (const action of plan.skipped) {
+    lines.push(`skip     ${action}`);
+  }
+  return lines.join("\n");
+}
+async function runDoctorCommand(options = {}) {
+  let report = await gatherDoctorReport();
+  const fixPlan = getDoctorFixPlan(report);
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify({ report, fixPlan }, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`${formatDoctorReport(report)}
+`);
+  process.stdout.write(`${formatDoctorFixPlan(fixPlan)}
+`);
+  if (options.fix) {
+    if (fixPlan.attempted.length === 0) {
+      logger8.warn("No safe automatic fixes available");
     } else {
-      logger6.info("Payments disabled");
+      await applyDoctorFixes(report);
+      report = await gatherDoctorReport();
+      process.stdout.write(`${formatDoctorReport(report)}
+`);
+    }
+  }
+  if (report.checks.some((check) => !check.ok)) {
+    logger8.warn("Some checks failed");
+    if (options.strict || options.json || process.env.CI) {
+      process.exitCode = 1;
+    }
+  }
+}
+
+// src/commands/shell.ts
+import { createLogger as createLogger9 } from "@revealui/setup/utils";
+import { execa as execa5 } from "execa";
+var logger9 = createLogger9({ prefix: "Shell" });
+async function runShellCommand(options = {}) {
+  if (!(options.inside || process.env.IN_NIX_SHELL) && await commandExists("nix")) {
+    const workspaceRoot = findWorkspaceRoot();
+    if (workspaceRoot) {
+      const reentryArgs = options.ensure ? ["dev", "up"] : ["dev", "status"];
+      await execa5(
+        "nix",
+        [
+          "develop",
+          "-c",
+          "node",
+          "packages/cli/bin/revealui.js",
+          ...reentryArgs,
+          ...options.forwardArgs ?? [],
+          "--inside",
+          ...options.json ? ["--json"] : []
+        ],
+        {
+          cwd: workspaceRoot,
+          stdio: "inherit"
+        }
+      );
+      return true;
     }
-    logger6.info("[6/8] Configure development environment");
-    const devEnvConfig = await promptDevEnvConfig();
-    logger6.success(
-      `Dev Container: ${devEnvConfig.createDevContainer ? "Yes" : "No"}, Devbox: ${devEnvConfig.createDevbox ? "Yes" : "No"}`
+  }
+  const report = await gatherDoctorReport();
+  if (options.ensure && report.dbTarget === "local" && await commandExists("pg_ctl")) {
+    const postgresCheck = report.checks.find((check) => check.id === "postgres");
+    if (postgresCheck && !postgresCheck.ok) {
+      try {
+        await runDbInitCommand();
+      } catch {
+      }
+      await runDbStartCommand();
+    }
+  }
+  const freshReport = await gatherDoctorReport();
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify(freshReport, null, 2)}
+`);
+    return false;
+  }
+  process.stdout.write(`${formatDoctorReport(freshReport)}
+`);
+  logger9.info("Use `revealui doctor --json` for machine-readable status.");
+  return false;
+}
+
+// src/commands/dev.ts
+var logger10 = createLogger10({ prefix: "Dev" });
+var DEV_PROFILES = {
+  local: {},
+  agent: {
+    include: ["mcp"]
+  },
+  cms: {
+    script: "dev:cms"
+  },
+  fullstack: {
+    include: ["mcp"],
+    script: "dev"
+  }
+};
+function getConfiguredProfile() {
+  const configured = readDevConfig().defaultProfile;
+  if (configured && configured in DEV_PROFILES) {
+    return configured;
+  }
+  return void 0;
+}
+function resolveDevUpOptions(options = {}) {
+  const selectedProfile = options.profile ?? getConfiguredProfile();
+  const profile = selectedProfile ? DEV_PROFILES[selectedProfile] : void 0;
+  if (selectedProfile && !profile) {
+    throw new Error(
+      `Unknown dev profile "${selectedProfile}". Use one of: ${Object.keys(DEV_PROFILES).join(", ")}`
     );
-    logger6.info("[7/8] Creating project...");
-    await createProject({
-      project: projectConfig,
-      database: databaseConfig,
-      storage: storageConfig,
-      payment: paymentConfig,
-      devenv: devEnvConfig,
-      skipGit: _options.skipGit,
-      skipInstall: _options.skipInstall
+  }
+  const include = Array.from(
+    /* @__PURE__ */ new Set([...profile?.include ?? [], ...options.include ?? []])
+  );
+  return {
+    ensure: options.ensure ?? true,
+    json: options.json ?? false,
+    inside: options.inside ?? false,
+    profile: selectedProfile,
+    script: options.script ?? profile?.script,
+    include
+  };
+}
+function getDevPlan(options = {}) {
+  const resolved = resolveDevUpOptions(options);
+  return {
+    profile: resolved.profile ?? (options.include?.length || options.script ? "custom" : "local"),
+    ensure: resolved.ensure,
+    include: resolved.include,
+    script: resolved.script,
+    dryRun: options.dryRun ?? false
+  };
+}
+function formatDevPlan(plan) {
+  const lines = ["", "RevealUI Dev Plan", ""];
+  lines.push(`profile   ${plan.profile}`);
+  lines.push(`ensure    ${plan.ensure ? "yes" : "no"}`);
+  lines.push(`dry-run   ${plan.dryRun ? "yes" : "no"}`);
+  lines.push(`include   ${plan.include.length > 0 ? plan.include.join(", ") : "none"}`);
+  lines.push(`script    ${plan.script ?? "none"}`);
+  return lines.join("\n");
+}
+function getDevActions(plan) {
+  const actions = [];
+  if (plan.ensure) {
+    actions.push("ensure local shell and database prerequisites");
+  } else {
+    actions.push("skip automatic shell/database ensure");
+  }
+  actions.push("run database migrations");
+  if (shouldIncludeMcp(plan.include)) {
+    actions.push("validate MCP credentials via `pnpm setup:mcp`");
+  }
+  if (plan.script) {
+    actions.push(`start pnpm script \`${plan.script}\``);
+  }
+  return actions;
+}
+function formatDevActions(plan) {
+  const actions = getDevActions(plan);
+  const lines = ["", "RevealUI Dev Actions", ""];
+  for (const action of actions) {
+    lines.push(`- ${action}`);
+  }
+  return lines.join("\n");
+}
+function shouldIncludeMcp(include) {
+  return include.includes("mcp");
+}
+async function runDevUpCommand(options = {}) {
+  const resolved = resolveDevUpOptions(options);
+  const plan = getDevPlan(options);
+  const forwardArgs = [];
+  if (options.dryRun) {
+    forwardArgs.push("--dry-run");
+  }
+  if (options.fix) {
+    forwardArgs.push("--fix");
+  }
+  if (options.profile) {
+    forwardArgs.push("--profile", options.profile);
+  }
+  for (const service of options.include ?? []) {
+    forwardArgs.push("--include", service);
+  }
+  if (options.script) {
+    forwardArgs.push("--script", options.script);
+  }
+  if (options.ensure === false) {
+    forwardArgs.push("--no-ensure");
+  }
+  const reentered = await runShellCommand({
+    ensure: resolved.ensure,
+    json: resolved.json,
+    inside: resolved.inside,
+    forwardArgs
+  });
+  if (reentered) {
+    return;
+  }
+  if (resolved.json) {
+    return;
+  }
+  process.stdout.write(`${formatDevPlan(plan)}
+`);
+  process.stdout.write(`${formatDevActions(plan)}
+`);
+  if (plan.dryRun) {
+    logger10.info("Dry run only; no migrations or services were started.");
+    return;
+  }
+  if (options.fix) {
+    await runDoctorCommand({ fix: true });
+  }
+  await runDbMigrateCommand();
+  logger10.success("Database migration complete");
+  if (shouldIncludeMcp(resolved.include)) {
+    const workspaceRoot = findWorkspaceRoot();
+    if (!workspaceRoot) {
+      throw new Error("RevealUI workspace root not found");
+    }
+    logger10.info("Validating MCP setup");
+    await execa6("pnpm", ["setup:mcp"], {
+      cwd: workspaceRoot,
+      stdio: "inherit"
     });
-    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");
+  }
+  if (resolved.script) {
+    const workspaceRoot = findWorkspaceRoot();
+    if (!workspaceRoot) {
+      throw new Error("RevealUI workspace root not found");
     }
-    process.exit(1);
+    logger10.info(`Starting dev script: ${resolved.script}`);
+    await execa6("pnpm", [resolved.script], {
+      cwd: workspaceRoot,
+      stdio: "inherit"
+    });
   }
 }
-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);
+async function runDevStatusCommand(options = {}) {
+  const plan = getDevPlan(options);
+  const forwardArgs = [];
+  if (options.profile) {
+    forwardArgs.push("--profile", options.profile);
+  }
+  for (const service of options.include ?? []) {
+    forwardArgs.push("--include", service);
+  }
+  if (options.script) {
+    forwardArgs.push("--script", options.script);
+  }
+  if (options.ensure === false) {
+    forwardArgs.push("--no-ensure");
+  }
+  if (!(options.inside || process.env.IN_NIX_SHELL) && await commandExists("nix")) {
+    const reentered = await runShellCommand({
+      ensure: false,
+      json: options.json,
+      inside: options.inside,
+      forwardArgs
+    });
+    if (reentered) {
+      return;
     }
   }
-});
+  const report = await gatherDoctorReport();
+  if (options.json) {
+    process.stdout.write(
+      `${JSON.stringify({ report, plan, actions: getDevActions(plan) }, null, 2)}
+`
+    );
+    return;
+  }
+  process.stdout.write(`${formatDoctorReport(report)}
+`);
+  process.stdout.write(`${formatDevPlan(plan)}
+`);
+  process.stdout.write(`${formatDevActions(plan)}
+`);
+}
+async function runDevDownCommand() {
+  await runDbStopCommand();
+}
+async function runDevProfileSetCommand(profile) {
+  if (!(profile in DEV_PROFILES)) {
+    throw new Error(
+      `Unknown dev profile "${profile}". Use one of: ${Object.keys(DEV_PROFILES).join(", ")}`
+    );
+  }
+  const configPath = writeDevConfig({ defaultProfile: profile });
+  logger10.success(`Default dev profile set to "${profile}" in ${configPath}`);
+}
+async function runDevProfileShowCommand(options = {}) {
+  const configuredProfile = getConfiguredProfile() ?? null;
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify({ defaultProfile: configuredProfile }, null, 2)}
+`);
+    return;
+  }
+  process.stdout.write(`Default dev profile: ${configuredProfile ?? "not set"}
+`);
+}
 
 // src/cli.ts
-import { createLogger as createLogger7 } from "@revealui/setup/utils";
-import { Command } from "commander";
+var logger11 = createLogger11({ prefix: "CLI" });
+function configureCreateCommand(command, legacyName) {
+  command.description("Create a new RevealUI project").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).option("-y, --yes", "Skip all prompts and use defaults", false).action(async (projectName, options) => {
+    logger11.header(legacyName ? "Create RevealUI Project" : "RevealUI Create");
+    await runCreateFlow(projectName, options);
+  });
+  return command;
+}
 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);
+  program.name("revealui").description("RevealUI operational CLI").version("0.2.0");
+  configureCreateCommand(program.command("create"), void 0);
+  program.command("doctor").description("Check RevealUI workspace and developer environment health").option("--json", "Output machine-readable JSON", false).option("--fix", "Apply safe automatic fixes when possible", false).option("--strict", "Exit nonzero when checks fail", false).action(async (options) => {
+    await runDoctorCommand(options);
+  });
+  const db = program.command("db").description("Manage the local RevealUI database");
+  db.command("init").description("Initialize the local PostgreSQL data directory").option("--force", "Delete and recreate the local data directory", false).action(async (options) => {
+    await runDbInitCommand(options);
+  });
+  db.command("start").description("Start the local PostgreSQL server").action(async () => {
+    await runDbStartCommand();
+  });
+  db.command("stop").description("Stop the local PostgreSQL server").action(async () => {
+    await runDbStopCommand();
+  });
+  db.command("status").description("Show local PostgreSQL status").action(async () => {
+    await runDbStatusCommand();
+  });
+  db.command("reset").description("Reset the local PostgreSQL data directory").option("--force", "Confirm the destructive reset", false).action(async (options) => {
+    await runDbResetCommand(options);
+  });
+  db.command("migrate").description("Run Drizzle migrations using the local RevealUI database environment").action(async () => {
+    await runDbMigrateCommand();
+  });
+  db.command("cleanup").description(
+    "Delete expired sessions, rate-limit rows, password-reset tokens, magic links, and publish due scheduled pages. Uses DATABASE_URL / POSTGRES_URL from the environment."
+  ).option("--dry-run", "Count stale rows without deleting them", false).option(
+    "--tables <names>",
+    "Comma-separated subset: sessions,rateLimits,passwordResetTokens,magicLinks,scheduledPages"
+  ).action(async (options) => {
+    await runDbCleanupCommand(options);
+  });
+  const dev = program.command("dev").description("Prepare and manage the RevealUI development workspace");
+  dev.command("up").description(
+    "Ensure the local dev environment is ready, migrate the DB, optionally validate MCP, and start a dev script"
+  ).option("--json", "Output machine-readable JSON", false).option("--dry-run", "Print the effective plan and actions without executing them", false).option("--fix", "Apply safe automatic fixes before bootstrapping when possible", false).option("--no-ensure", "Skip automatic local DB initialization/start").option("--profile <name>", "Named dev profile: local, agent, cms, fullstack").option(
+    "--include <service...>",
+    "Additional development services to prepare (currently supports: mcp)"
+  ).option("--script <name>", "Optional pnpm script to run after environment bootstrap").option("--inside", "Internal flag used after re-entering nix develop", false).action(
+    async (options) => {
+      await runDevUpCommand(options);
+    }
+  );
+  dev.command("status").description("Show current RevealUI development environment status").option("--json", "Output machine-readable JSON", false).option("--profile <name>", "Named dev profile: local, agent, cms, fullstack").option(
+    "--include <service...>",
+    "Additional development services to preview in the effective plan"
+  ).option("--script <name>", "Optional pnpm script to preview in the effective plan").option("--inside", "Internal flag used after re-entering nix develop", false).action(
+    async (options) => {
+      await runDevStatusCommand(options);
+    }
+  );
+  dev.command("down").description("Stop local RevealUI development services that are managed by the CLI").action(async () => {
+    await runDevDownCommand();
+  });
+  dev.command("shell").description("Alias for `revealui dev up` without starting an app script").option("--json", "Output machine-readable JSON", false).option("--dry-run", "Print the effective plan and actions without executing them", false).option("--fix", "Apply safe automatic fixes before bootstrapping when possible", false).option("--no-ensure", "Skip automatic local DB initialization/start").option("--profile <name>", "Named dev profile: local, agent, cms, fullstack").option(
+    "--include <service...>",
+    "Additional development services to prepare (currently supports: mcp)"
+  ).option("--inside", "Internal flag used after re-entering nix develop", false).action(
+    async (options) => {
+      await runDevUpCommand({
+        ensure: options.ensure,
+        json: options.json,
+        dryRun: options.dryRun,
+        fix: options.fix,
+        profile: options.profile,
+        include: options.include,
+        inside: options.inside
+      });
+    }
+  );
+  const devProfile = dev.command("profile").description("Persist or inspect the default dev profile");
+  devProfile.command("set").description("Set the default profile used by `revealui dev up` and `revealui dev status`").argument("<name>", "Profile name: local, agent, cms, fullstack").action(async (name) => {
+    await runDevProfileSetCommand(name);
+  });
+  devProfile.command("show").description("Show the configured default dev profile").option("--json", "Output machine-readable JSON", false).action(async (options) => {
+    await runDevProfileShowCommand(options);
+  });
+  program.command("shell").description("Deprecated alias for `revealui dev shell`").option("--ensure", "Initialize/start the local DB when possible", false).option("--json", "Output machine-readable JSON", false).option("--inside", "Internal flag used after re-entering nix develop", false).action(async (options) => {
+    await runDevUpCommand({
+      ensure: options.ensure,
+      json: options.json,
+      inside: options.inside
+    });
   });
   return program;
 }
-var logger7;
-var init_cli = __esm({
-  "src/cli.ts"() {
-    init_esm_shims();
-    logger7 = createLogger7({ prefix: "CLI" });
-  }
-});
-init_cli();
+function createLegacyCreateCli() {
+  const program = new Command();
+  program.name("create-revealui").version("0.2.0");
+  configureCreateCommand(program, "create-revealui");
+  return program;
+}
 export {
-  createCli
+  createCli,
+  createLegacyCreateCli
 };
 //# sourceMappingURL=cli.js.map