@revealui/cli 0.0.1-pre.1 → 0.3.0

package/dist/cli.js

@@ -0,0 +1,1801 @@
+// src/cli.ts
+import { createLogger as createLogger11 } from "@revealui/setup/utils";
+import { Command } from "commander";
+
+// 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/prompts/database.ts
+import inquirer from "inquirer";
+
+// src/validators/credentials.ts
+import { createLogger } from "@revealui/setup/utils";
+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 { 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")) {
+      logger.warn("URL does not appear to be a Supabase URL");
+    }
+    return { valid: true };
+  } catch {
+    return {
+      valid: false,
+      message: "Invalid Supabase URL format"
+    };
+  }
+}
+
+// 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"
+        }
+      ],
+      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 };
+}
+
+// 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;
+}
+
+// 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
+  };
+}
+
+// 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:
+    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 fs3.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 fs3.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.13.0
+- pnpm package manager
+- PostgreSQL 16 with pgvector
+- VS Code extensions:
+  - 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 fs3.writeFile(path3.join(devcontainerDir, "README.md"), readme, "utf-8");
+}
+
+// src/generators/readme.ts
+import fs4 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.13.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 fs4.writeFile(path4.join(projectPath, "README.md"), readme, "utf-8");
+}
+
+// src/installers/dependencies.ts
+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 {
+    await execa("pnpm", ["install"], {
+      cwd: projectPath,
+      stdio: "pipe"
+    });
+    spinner.succeed("Dependencies installed successfully");
+  } catch (error) {
+    spinner.fail("Failed to install dependencies");
+    logger3.error('Please run "pnpm install" manually');
+    throw error;
+  }
+}
+async function isPnpmInstalled() {
+  try {
+    await execa("pnpm", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/git.ts
+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 });
+    logger4.success("Initialized git repository");
+  } catch (error) {
+    logger4.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 });
+    logger4.success("Created initial commit");
+  } catch (error) {
+    logger4.warn("Failed to create initial commit");
+    throw error;
+  }
+}
+async function isGitInstalled() {
+  try {
+    await execa2("git", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/create.ts
+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`",
+    "",
+    "# 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 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 fs5.access(templatePath);
+  } catch {
+    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 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;
+    const destPath = path5.join(dest, destName);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs5.copyFile(srcPath, destPath);
+    }
+  }
+}
+function resolveTemplateName(template) {
+  const map = {
+    "basic-blog": "basic-blog",
+    "e-commerce": "e-commerce",
+    portfolio: "portfolio"
+  };
+  return map[template] ?? "starter";
+}
+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 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 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);
+  logger5.success("README.md generated");
+  if (cfg.devenv.createDevContainer) {
+    await generateDevContainer(projectPath);
+    logger5.success(".devcontainer/ generated");
+  }
+  if (cfg.devenv.createDevbox) {
+    await generateDevbox(projectPath);
+    logger5.success("devbox.json generated");
+  }
+  if (!skipInstall) {
+    const pnpmOk = await isPnpmInstalled();
+    if (!pnpmOk) {
+      logger5.warn(
+        "pnpm not found \u2014 skipping dependency installation. Run `pnpm install` manually."
+      );
+    } else {
+      await installDependencies(projectPath);
+    }
+  } else {
+    logger5.info("Skipping dependency installation (--skip-install)");
+  }
+  if (!skipGit) {
+    const gitOk = await isGitInstalled();
+    if (!gitOk) {
+      logger5.warn("git not found \u2014 skipping repository initialisation.");
+    } else {
+      await initializeGitRepo(projectPath);
+      await createInitialCommit(projectPath);
+    }
+  } else {
+    logger5.info("Skipping git initialisation (--skip-git)");
+  }
+}
+
+// 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 {
+      const licenseFile = join(homedir(), ".revealui", "license.json");
+      const parsed = JSON.parse(readFileSync(licenseFile, "utf8"));
+      key = parsed.key;
+    } catch {
+    }
+  }
+  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 < 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 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("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 {
+      }
+    }
+    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 {
+    }
+  }
+  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 {
+      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 {
+    }
+    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 {
+      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;
+    }
+  }
+  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(", ")}`
+    );
+  }
+  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"
+    });
+  }
+  if (resolved.script) {
+    const workspaceRoot = findWorkspaceRoot();
+    if (!workspaceRoot) {
+      throw new Error("RevealUI workspace root not found");
+    }
+    logger10.info(`Starting dev script: ${resolved.script}`);
+    await execa6("pnpm", [resolved.script], {
+      cwd: workspaceRoot,
+      stdio: "inherit"
+    });
+  }
+}
+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
+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("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;
+}
+function createLegacyCreateCli() {
+  const program = new Command();
+  program.name("create-revealui").version("0.2.0");
+  configureCreateCommand(program, "create-revealui");
+  return program;
+}
+export {
+  createCli,
+  createLegacyCreateCli
+};
+//# sourceMappingURL=cli.js.map