scaffoldry 1.0.1

package/dist/chunk-XIP7YNKZ.js

@@ -0,0 +1,1216 @@
+import {
+  getInstallInstructions,
+  openBrowser
+} from "./chunk-WOS3F5LR.js";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  info: (message) => {
+    console.log(chalk.blue("info"), message);
+  },
+  success: (message) => {
+    console.log(chalk.green("success"), message);
+  },
+  warn: (message) => {
+    console.log(chalk.yellow("warn"), message);
+  },
+  error: (message) => {
+    console.log(chalk.red("error"), message);
+  },
+  log: (message) => {
+    console.log(message);
+  },
+  newLine: () => {
+    console.log();
+  }
+};
+
+// src/utils/template.ts
+function createTemplateContext(config) {
+  return {
+    projectName: config.name,
+    projectDescription: config.description,
+    features: config.features,
+    databaseProvider: config.database,
+    packageManager: config.packageManager,
+    hasAuth: config.features.includes("auth"),
+    hasBilling: config.features.includes("billing"),
+    hasEmail: config.features.includes("email"),
+    hasStorage: config.features.includes("storage"),
+    hasJobs: config.features.includes("jobs"),
+    hasWebhooks: config.features.includes("webhooks"),
+    hasAdmin: config.features.includes("admin")
+  };
+}
+function toKebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function toPascalCase(str) {
+  return str.split(/[-_\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function replaceTemplateVars(content, context) {
+  return content.replace(/\{\{projectName\}\}/g, context.projectName).replace(/\{\{projectDescription\}\}/g, context.projectDescription).replace(/\{\{pascalName\}\}/g, toPascalCase(context.projectName)).replace(/\{\{camelName\}\}/g, toCamelCase(context.projectName)).replace(/\{\{kebabName\}\}/g, toKebabCase(context.projectName));
+}
+
+// src/utils/license.ts
+import fs from "fs-extra";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".scaffoldry");
+var LICENSE_FILE = path.join(CONFIG_DIR, "license.json");
+var API_BASE_URL = process.env.SCAFFOLDRY_API_URL || "https://scaffoldry.com";
+async function getStoredLicense() {
+  try {
+    if (await fs.pathExists(LICENSE_FILE)) {
+      const config = await fs.readJson(LICENSE_FILE);
+      return config;
+    }
+  } catch {
+  }
+  return null;
+}
+async function storeLicense(config) {
+  await fs.ensureDir(CONFIG_DIR);
+  await fs.writeJson(LICENSE_FILE, config, { spaces: 2 });
+}
+async function clearLicense() {
+  try {
+    await fs.remove(LICENSE_FILE);
+  } catch {
+  }
+}
+function isValidLicenseKeyFormat(key) {
+  const pattern = /^SCAF-[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4}$/;
+  return pattern.test(key.toUpperCase());
+}
+async function validateLicense(licenseKey) {
+  const machineId = await getMachineId();
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/license/validate`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "scaffoldry-cli/1.0.0"
+      },
+      body: JSON.stringify({
+        licenseKey,
+        machineId
+      })
+    });
+    const data = await response.json();
+    return data;
+  } catch {
+    const stored = await getStoredLicense();
+    if (stored && stored.key === licenseKey) {
+      return {
+        valid: true,
+        email: stored.email
+      };
+    }
+    return {
+      valid: false,
+      email: void 0,
+      error: "Unable to validate license. Please check your internet connection."
+    };
+  }
+}
+async function getMachineId() {
+  const hostname = os.hostname();
+  const username = os.userInfo().username;
+  const platform = os.platform();
+  const str = `${hostname}:${username}:${platform}`;
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return `machine-${Math.abs(hash).toString(16)}`;
+}
+
+// src/utils/env.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+function parseEnvFile(content) {
+  const env = {};
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (match && match[1] && match[2] !== void 0) {
+      const key = match[1];
+      let value = match[2];
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      env[key] = value;
+    }
+  }
+  return env;
+}
+function serializeEnvFile(env, originalContent) {
+  if (!originalContent) {
+    return Object.entries(env).map(([key, value]) => {
+      if (value.includes(" ") || value.includes("#") || value.includes("=")) {
+        return `${key}="${value}"`;
+      }
+      return `${key}=${value}`;
+    }).join("\n") + "\n";
+  }
+  const lines = originalContent.split("\n");
+  const result = [];
+  const writtenKeys = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      result.push(line);
+      continue;
+    }
+    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=/);
+    if (match && match[1]) {
+      const key = match[1];
+      const value = env[key];
+      if (value !== void 0) {
+        if (value.includes(" ") || value.includes("#") || value.includes("=")) {
+          result.push(`${key}="${value}"`);
+        } else {
+          result.push(`${key}=${value}`);
+        }
+        writtenKeys.add(key);
+      } else {
+        result.push(line);
+      }
+    } else {
+      result.push(line);
+    }
+  }
+  for (const [key, value] of Object.entries(env)) {
+    if (!writtenKeys.has(key)) {
+      if (value.includes(" ") || value.includes("#") || value.includes("=")) {
+        result.push(`${key}="${value}"`);
+      } else {
+        result.push(`${key}=${value}`);
+      }
+    }
+  }
+  return result.join("\n");
+}
+async function readEnvLocal(projectDir) {
+  const envPath = path2.join(projectDir, ".env.local");
+  if (!await fs2.pathExists(envPath)) {
+    return {};
+  }
+  const content = await fs2.readFile(envPath, "utf-8");
+  return parseEnvFile(content);
+}
+async function writeEnvLocal(projectDir, updates) {
+  const envPath = path2.join(projectDir, ".env.local");
+  let originalContent;
+  if (await fs2.pathExists(envPath)) {
+    originalContent = await fs2.readFile(envPath, "utf-8");
+    const existing = parseEnvFile(originalContent);
+    updates = { ...existing, ...updates };
+  }
+  const newContent = serializeEnvFile(updates, originalContent);
+  await fs2.writeFile(envPath, newContent);
+}
+
+// src/utils/config.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+import os2 from "os";
+var CONFIG_DIR2 = path3.join(os2.homedir(), ".scaffoldry");
+var CONFIG_FILE = path3.join(CONFIG_DIR2, "config.json");
+async function getUserConfig() {
+  try {
+    if (await fs3.pathExists(CONFIG_FILE)) {
+      const content = await fs3.readFile(CONFIG_FILE, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return {};
+}
+async function setUserConfig(config) {
+  await fs3.ensureDir(CONFIG_DIR2);
+  await fs3.writeJson(CONFIG_FILE, config, { spaces: 2 });
+}
+async function updateUserConfig(updates) {
+  const current = await getUserConfig();
+  await setUserConfig({ ...current, ...updates });
+}
+async function getConfigValue(key) {
+  const config = await getUserConfig();
+  return config[key];
+}
+async function setConfigValue(key, value) {
+  await updateUserConfig({ [key]: value });
+}
+function getProjectDataDir(projectName) {
+  return path3.join(CONFIG_DIR2, "projects", projectName);
+}
+async function saveProjectData(projectName, filename, data) {
+  const projectDir = getProjectDataDir(projectName);
+  await fs3.ensureDir(projectDir);
+  await fs3.writeFile(path3.join(projectDir, filename), data);
+}
+
+// src/utils/diagnostics.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import fs4 from "fs-extra";
+import path4 from "path";
+var execAsync = promisify(exec);
+async function checkNodeVersion() {
+  try {
+    const { stdout } = await execAsync("node --version");
+    const version = stdout.trim().replace("v", "");
+    const major = parseInt(version.split(".")[0] || "0", 10);
+    if (major >= 20) {
+      return { status: "pass", label: `Node.js ${version}` };
+    }
+    if (major >= 18) {
+      return {
+        status: "warn",
+        label: `Node.js ${version}`,
+        message: "Node.js 20+ recommended",
+        fix: getInstallInstructions("node")
+      };
+    }
+    return {
+      status: "fail",
+      label: `Node.js ${version}`,
+      message: "Node.js 18+ required",
+      fix: getInstallInstructions("node")
+    };
+  } catch {
+    return {
+      status: "fail",
+      label: "Node.js",
+      message: "Not installed",
+      fix: getInstallInstructions("node")
+    };
+  }
+}
+async function checkPnpmVersion() {
+  try {
+    const { stdout } = await execAsync("pnpm --version");
+    const version = stdout.trim();
+    const major = parseInt(version.split(".")[0] || "0", 10);
+    if (major >= 9) {
+      return { status: "pass", label: `pnpm ${version}` };
+    }
+    if (major >= 8) {
+      return {
+        status: "warn",
+        label: `pnpm ${version}`,
+        message: "pnpm 9+ recommended",
+        fix: getInstallInstructions("pnpm")
+      };
+    }
+    return {
+      status: "fail",
+      label: `pnpm ${version}`,
+      message: "pnpm 8+ required",
+      fix: getInstallInstructions("pnpm")
+    };
+  } catch {
+    return {
+      status: "fail",
+      label: "pnpm",
+      message: "Not installed",
+      fix: getInstallInstructions("pnpm")
+    };
+  }
+}
+async function checkGitInstalled() {
+  try {
+    const { stdout } = await execAsync("git --version");
+    const match = stdout.match(/git version ([\d.]+)/);
+    const version = match ? match[1] : "unknown";
+    return { status: "pass", label: `Git ${version}` };
+  } catch {
+    return {
+      status: "fail",
+      label: "Git",
+      message: "Not installed",
+      fix: getInstallInstructions("git")
+    };
+  }
+}
+async function checkStripeCli() {
+  try {
+    const { stdout } = await execAsync("stripe --version");
+    const match = stdout.match(/stripe version ([\d.]+)/i) || stdout.match(/([\d.]+)/);
+    const version = match ? match[1] : "unknown";
+    return { status: "pass", label: `Stripe CLI ${version}` };
+  } catch {
+    return {
+      status: "warn",
+      label: "Stripe CLI",
+      message: "Not installed (required for local webhook testing)",
+      fix: getInstallInstructions("stripe-cli")
+    };
+  }
+}
+async function checkEnvVar(projectDir, key, options) {
+  const env = await readEnvLocal(projectDir);
+  const value = env[key];
+  if (!value) {
+    if (options?.required === false) {
+      return { status: "pass", label: key, message: "Not configured (optional)" };
+    }
+    return {
+      status: "fail",
+      label: key,
+      message: "Not configured",
+      fix: `Run: scaffoldry setup ${getSetupCommandForEnvVar(key)}`
+    };
+  }
+  if (options?.pattern && !options.pattern.test(value)) {
+    return {
+      status: "warn",
+      label: key,
+      message: "Invalid format",
+      fix: `Run: scaffoldry setup ${getSetupCommandForEnvVar(key)}`
+    };
+  }
+  const masked = value.length > 8 ? `${value.slice(0, 4)}${"\u2022".repeat(Math.min(12, value.length - 8))}${value.slice(-4)}` : "\u2022\u2022\u2022\u2022\u2022\u2022\u2022\u2022";
+  return { status: "pass", label: key, message: masked };
+}
+function getSetupCommandForEnvVar(key) {
+  if (key.includes("STRIPE")) return "stripe";
+  if (key.includes("DATABASE") || key.includes("DB_")) return "database";
+  if (key.includes("RESEND") || key.includes("EMAIL")) return "email";
+  if (key.includes("S3") || key.includes("AWS") || key.includes("STORAGE")) return "storage";
+  return "all";
+}
+async function checkDatabaseConnection(projectDir) {
+  const env = await readEnvLocal(projectDir);
+  const dbUrl = env.DATABASE_URL;
+  if (!dbUrl) {
+    return {
+      status: "fail",
+      label: "Database connection",
+      message: "DATABASE_URL not configured",
+      fix: "Run: scaffoldry setup database"
+    };
+  }
+  try {
+    const { neon } = await import("@neondatabase/serverless");
+    const sql = neon(dbUrl);
+    await sql`SELECT 1`;
+    return { status: "pass", label: "Database connection" };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Connection failed";
+    return {
+      status: "fail",
+      label: "Database connection",
+      message: message.slice(0, 50),
+      fix: "Check your DATABASE_URL and network connection"
+    };
+  }
+}
+async function checkStripeApiKey(projectDir) {
+  const env = await readEnvLocal(projectDir);
+  const apiKey = env.STRIPE_SECRET_KEY;
+  if (!apiKey) {
+    return {
+      status: "fail",
+      label: "Stripe API",
+      message: "STRIPE_SECRET_KEY not configured",
+      fix: "Run: scaffoldry setup stripe"
+    };
+  }
+  try {
+    const response = await fetch("https://api.stripe.com/v1/balance", {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (response.ok) {
+      return { status: "pass", label: "Stripe API" };
+    }
+    const data = await response.json();
+    return {
+      status: "fail",
+      label: "Stripe API",
+      message: data.error?.message || "Invalid API key",
+      fix: "Run: scaffoldry setup stripe"
+    };
+  } catch {
+    return {
+      status: "warn",
+      label: "Stripe API",
+      message: "Could not verify (network error)"
+    };
+  }
+}
+async function checkResendApiKey(projectDir) {
+  const env = await readEnvLocal(projectDir);
+  const apiKey = env.RESEND_API_KEY;
+  if (!apiKey) {
+    return {
+      status: "fail",
+      label: "Resend API",
+      message: "RESEND_API_KEY not configured",
+      fix: "Run: scaffoldry setup email"
+    };
+  }
+  try {
+    const response = await fetch("https://api.resend.com/domains", {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (response.ok) {
+      return { status: "pass", label: "Resend API" };
+    }
+    if (response.status === 401) {
+      return {
+        status: "fail",
+        label: "Resend API",
+        message: "Invalid API key (401 Unauthorized)",
+        fix: "Run: scaffoldry setup email"
+      };
+    }
+    return {
+      status: "warn",
+      label: "Resend API",
+      message: `API returned ${response.status}`
+    };
+  } catch {
+    return {
+      status: "warn",
+      label: "Resend API",
+      message: "Could not verify (network error)"
+    };
+  }
+}
+async function checkEnvLocalExists(projectDir) {
+  const envPath = path4.join(projectDir, ".env.local");
+  if (await fs4.pathExists(envPath)) {
+    return { status: "pass", label: ".env.local file" };
+  }
+  return {
+    status: "fail",
+    label: ".env.local file",
+    message: "Not found",
+    fix: "Run: scaffoldry setup all"
+  };
+}
+async function runEnvironmentChecks() {
+  const results = await Promise.all([
+    checkNodeVersion(),
+    checkPnpmVersion(),
+    checkGitInstalled(),
+    checkStripeCli()
+  ]);
+  return results;
+}
+async function runConfigurationChecks(projectDir) {
+  const results = [];
+  results.push(await checkEnvLocalExists(projectDir));
+  results.push(await checkEnvVar(projectDir, "DATABASE_URL"));
+  results.push(await checkEnvVar(projectDir, "STRIPE_SECRET_KEY"));
+  results.push(await checkEnvVar(projectDir, "STRIPE_WEBHOOK_SECRET"));
+  results.push(await checkEnvVar(projectDir, "RESEND_API_KEY"));
+  results.push(await checkEnvVar(projectDir, "AUTH_SECRET"));
+  return results;
+}
+async function runServiceChecks(projectDir) {
+  const results = await Promise.all([
+    checkDatabaseConnection(projectDir),
+    checkStripeApiKey(projectDir),
+    checkResendApiKey(projectDir)
+  ]);
+  return results;
+}
+
+// src/wizards/stripe.ts
+import ora from "ora";
+
+// src/wizards/base.ts
+import prompts from "prompts";
+import chalk2 from "chalk";
+function printBox(title, content) {
+  const width = 61;
+  const topBorder = "\u250C" + "\u2500".repeat(width) + "\u2510";
+  const bottomBorder = "\u2514" + "\u2500".repeat(width) + "\u2518";
+  console.log(chalk2.cyan(topBorder));
+  console.log(chalk2.cyan("\u2502") + " ".repeat(width) + chalk2.cyan("\u2502"));
+  console.log(chalk2.cyan("\u2502") + "   " + chalk2.bold(title).padEnd(width - 3) + chalk2.cyan("\u2502"));
+  console.log(chalk2.cyan("\u2502") + " ".repeat(width) + chalk2.cyan("\u2502"));
+  for (const line of content) {
+    const paddedLine = "   " + line;
+    console.log(chalk2.cyan("\u2502") + paddedLine.padEnd(width) + chalk2.cyan("\u2502"));
+  }
+  console.log(chalk2.cyan("\u2502") + " ".repeat(width) + chalk2.cyan("\u2502"));
+  console.log(chalk2.cyan(bottomBorder));
+}
+function printStep(stepNumber, title) {
+  console.log();
+  console.log(chalk2.bold(`  STEP ${stepNumber}: ${title}`));
+  console.log("  " + "\u2500".repeat(53));
+}
+function printSuccess(message) {
+  console.log(chalk2.green("  \u2713 " + message));
+}
+function printInfo(message) {
+  console.log(chalk2.blue("  \u2192 " + message));
+}
+function printWarning(message) {
+  console.log(chalk2.yellow("  \u26A0 " + message));
+}
+function printError(message) {
+  console.log(chalk2.red("  \u2717 " + message));
+}
+async function maybeOpenBrowser(url, description) {
+  const autoOpen = await getConfigValue("openBrowserAutomatically");
+  if (autoOpen === true) {
+    await openBrowser(url);
+    printInfo(`Opened: ${url}`);
+    return;
+  }
+  if (autoOpen === false) {
+    printInfo(`URL: ${url}`);
+    return;
+  }
+  const { openIt, remember } = await prompts([
+    {
+      type: "confirm",
+      name: "openIt",
+      message: `Open ${description} in browser?`,
+      initial: true
+    },
+    {
+      type: "confirm",
+      name: "remember",
+      message: "Remember this preference?",
+      initial: true
+    }
+  ]);
+  if (remember) {
+    await setConfigValue("openBrowserAutomatically", openIt);
+  }
+  if (openIt) {
+    await openBrowser(url);
+    printInfo(`Opened: ${url}`);
+  } else {
+    printInfo(`URL: ${url}`);
+  }
+}
+async function promptSecret(message) {
+  const { value } = await prompts({
+    type: "password",
+    name: "value",
+    message
+  });
+  return value;
+}
+async function promptText(message, options) {
+  const { value } = await prompts({
+    type: "text",
+    name: "value",
+    message,
+    initial: options?.initial,
+    validate: options?.validate
+  });
+  return value;
+}
+async function promptConfirm(message, initial = true) {
+  const { value } = await prompts({
+    type: "confirm",
+    name: "value",
+    message,
+    initial
+  });
+  return value ?? false;
+}
+async function saveWizardResults(projectDir, envVars) {
+  await writeEnvLocal(projectDir, envVars);
+  logger.newLine();
+  printSuccess("Environment variables saved to .env.local");
+}
+
+// src/wizards/stripe.ts
+var STRIPE_DASHBOARD_URL = "https://dashboard.stripe.com/apikeys";
+var STRIPE_WEBHOOK_URL = "https://dashboard.stripe.com/webhooks";
+async function verifyStripeKey(apiKey) {
+  try {
+    const response = await fetch("https://api.stripe.com/v1/account", {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      const account = { id: data.id };
+      if (data.business_profile?.name) {
+        account.businessName = data.business_profile.name;
+      }
+      if (data.email) {
+        account.email = data.email;
+      }
+      return { valid: true, account };
+    }
+    const errorData = await response.json();
+    return {
+      valid: false,
+      error: errorData.error?.message || `API returned ${response.status}`
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Network error"
+    };
+  }
+}
+function isValidStripeSecretKey(key) {
+  return /^sk_(test|live)_[A-Za-z0-9]+$/.test(key);
+}
+function isValidWebhookSecret(secret) {
+  return /^whsec_[A-Za-z0-9]+$/.test(secret);
+}
+async function stripeWizard(projectDir) {
+  console.log();
+  printBox("Stripe Setup", [
+    "Let's configure Stripe for your billing system.",
+    "",
+    "You'll need:",
+    "\u2022 Stripe Secret Key (sk_test_... or sk_live_...)",
+    "\u2022 Webhook Signing Secret (whsec_...)"
+  ]);
+  printStep(1, "Get your API keys");
+  console.log("  1. Go to: https://dashboard.stripe.com/apikeys");
+  console.log('  2. Copy your "Secret key" (starts with sk_test_ or sk_)');
+  console.log();
+  await maybeOpenBrowser(STRIPE_DASHBOARD_URL, "Stripe dashboard");
+  console.log();
+  const secretKey = await promptSecret("Paste your Stripe Secret Key:");
+  if (!secretKey) {
+    printError("Stripe secret key is required");
+    return { success: false, message: "Cancelled" };
+  }
+  if (!isValidStripeSecretKey(secretKey)) {
+    printError("Invalid key format. Expected: sk_test_... or sk_live_...");
+    return { success: false, message: "Invalid key format" };
+  }
+  const spinner = ora("Verifying with Stripe API...").start();
+  printInfo("Calling stripe.account.retrieve()...");
+  const verification = await verifyStripeKey(secretKey);
+  if (!verification.valid) {
+    spinner.fail("Key verification failed");
+    printError(verification.error || "Unknown error");
+    return { success: false, message: verification.error || "Verification failed" };
+  }
+  const accountName = verification.account?.businessName || verification.account?.email || verification.account?.id;
+  spinner.succeed(`Key verified! Account: ${accountName}`);
+  printStep(2, "Webhook endpoint");
+  console.log("  For local development, we'll use Stripe CLI.");
+  console.log("  For production, add: https://your-domain.com/api/webhooks/stripe");
+  console.log();
+  console.log("  To get your webhook signing secret:");
+  console.log("  \u2022 Local dev: Run `stripe listen` to get whsec_...");
+  console.log("  \u2022 Production: Copy from Stripe Dashboard > Webhooks");
+  console.log();
+  const { setupWebhook } = { setupWebhook: await promptConfirm("Do you have a webhook signing secret?", false) };
+  let webhookSecret;
+  if (setupWebhook) {
+    await maybeOpenBrowser(STRIPE_WEBHOOK_URL, "Stripe webhooks");
+    console.log();
+    webhookSecret = await promptSecret("Paste your Webhook Signing Secret:");
+    if (webhookSecret && !isValidWebhookSecret(webhookSecret)) {
+      printError("Invalid webhook secret format. Expected: whsec_...");
+      webhookSecret = void 0;
+    }
+  }
+  if (!webhookSecret) {
+    printInfo("Skipping webhook secret for now.");
+    printInfo("For local dev, run: stripe listen --forward-to localhost:3000/api/webhooks/stripe");
+    webhookSecret = "whsec_PLACEHOLDER_RUN_STRIPE_LISTEN";
+  }
+  const envVars = {
+    STRIPE_SECRET_KEY: secretKey,
+    STRIPE_WEBHOOK_SECRET: webhookSecret
+  };
+  const isTestMode = secretKey.startsWith("sk_test_");
+  if (isTestMode) {
+    console.log();
+    printInfo("Tip: Also add your publishable key for client-side Stripe.js");
+    const publishableKey = await promptSecret("Paste your Stripe Publishable Key (optional):");
+    if (publishableKey && publishableKey.startsWith("pk_test_")) {
+      envVars.NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY = publishableKey;
+    }
+  }
+  await saveWizardResults(projectDir, envVars);
+  console.log();
+  printSuccess("Stripe setup complete!");
+  if (webhookSecret === "whsec_PLACEHOLDER_RUN_STRIPE_LISTEN") {
+    console.log();
+    printInfo("Next: Run `scaffoldry dev` to start with Stripe webhook forwarding");
+  }
+  return {
+    success: true,
+    envVars
+  };
+}
+
+// src/wizards/database.ts
+import ora2 from "ora";
+var NEON_DASHBOARD_URL = "https://console.neon.tech";
+async function verifyDatabaseConnection(connectionString) {
+  try {
+    const { neon } = await import("@neondatabase/serverless");
+    const sql = neon(connectionString);
+    await sql`SELECT 1 as test`;
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Connection failed"
+    };
+  }
+}
+function isValidConnectionString(url) {
+  try {
+    const parsed = new URL(url);
+    return (parsed.protocol === "postgres:" || parsed.protocol === "postgresql:") && parsed.hostname.length > 0;
+  } catch {
+    return false;
+  }
+}
+function extractHost(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.hostname;
+  } catch {
+    return "unknown";
+  }
+}
+async function databaseWizard(projectDir) {
+  console.log();
+  printBox("Database Setup", [
+    "Let's configure your Neon PostgreSQL database.",
+    "",
+    "Scaffoldry uses Neon for serverless PostgreSQL.",
+    "It's free to start and scales automatically."
+  ]);
+  printStep(1, "Get your Neon connection string");
+  console.log("  1. Sign in at: https://console.neon.tech");
+  console.log("  2. Create a project (or select existing)");
+  console.log("  3. Copy the connection string from the Dashboard");
+  console.log("     (Format: postgresql://user:pass@host/dbname)");
+  console.log();
+  await maybeOpenBrowser(NEON_DASHBOARD_URL, "Neon console");
+  console.log();
+  const connectionString = await promptSecret("Paste your DATABASE_URL:");
+  if (!connectionString) {
+    printError("Database connection string is required");
+    return { success: false, message: "Cancelled" };
+  }
+  if (!isValidConnectionString(connectionString)) {
+    printError("Invalid connection string format");
+    printInfo("Expected: postgresql://user:password@host/database");
+    return { success: false, message: "Invalid format" };
+  }
+  const spinner = ora2("Verifying database connection...").start();
+  printInfo("Executing: SELECT 1");
+  const verification = await verifyDatabaseConnection(connectionString);
+  if (!verification.valid) {
+    spinner.fail("Connection failed");
+    printError(verification.error || "Unknown error");
+    console.log();
+    printInfo("Troubleshooting tips:");
+    console.log("  \u2022 Check that your connection string is correct");
+    console.log("  \u2022 Ensure your IP is allowed (Neon > Settings > IP Allow)");
+    console.log("  \u2022 For Neon, make sure SSL is enabled (add ?sslmode=require)");
+    return { success: false, message: verification.error || "Connection failed" };
+  }
+  const host = extractHost(connectionString);
+  spinner.succeed(`Connected to ${host}!`);
+  const envVars = {
+    DATABASE_URL: connectionString
+  };
+  await saveWizardResults(projectDir, envVars);
+  console.log();
+  printSuccess("Database setup complete!");
+  console.log();
+  printInfo("Next: Run `scaffoldry migrate` to apply database migrations");
+  return {
+    success: true,
+    envVars
+  };
+}
+
+// src/wizards/email.ts
+import ora3 from "ora";
+var RESEND_DASHBOARD_URL = "https://resend.com/api-keys";
+async function verifyResendKey(apiKey) {
+  try {
+    const response = await fetch("https://api.resend.com/domains", {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return {
+        valid: true,
+        domains: data.data || []
+      };
+    }
+    if (response.status === 401) {
+      return {
+        valid: false,
+        error: "Invalid API key (401 Unauthorized)"
+      };
+    }
+    return {
+      valid: false,
+      error: `API returned ${response.status}`
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Network error"
+    };
+  }
+}
+function isValidResendKey(key) {
+  return /^re_[A-Za-z0-9]+$/.test(key);
+}
+async function emailWizard(projectDir) {
+  console.log();
+  printBox("Email Setup", [
+    "Let's configure Resend for transactional emails.",
+    "",
+    "Resend handles:",
+    "\u2022 Password reset emails",
+    "\u2022 Magic link authentication",
+    "\u2022 Welcome emails and notifications"
+  ]);
+  printStep(1, "Get your Resend API key");
+  console.log("  1. Sign in at: https://resend.com");
+  console.log("  2. Go to API Keys in the dashboard");
+  console.log("  3. Create a new API key (or use existing)");
+  console.log("     (Format: re_...)");
+  console.log();
+  await maybeOpenBrowser(RESEND_DASHBOARD_URL, "Resend dashboard");
+  console.log();
+  const apiKey = await promptSecret("Paste your Resend API Key:");
+  if (!apiKey) {
+    printError("Resend API key is required");
+    return { success: false, message: "Cancelled" };
+  }
+  if (!isValidResendKey(apiKey)) {
+    printError("Invalid API key format. Expected: re_...");
+    return { success: false, message: "Invalid format" };
+  }
+  const spinner = ora3("Verifying with Resend API...").start();
+  printInfo("Calling resend.domains.list()...");
+  const verification = await verifyResendKey(apiKey);
+  if (!verification.valid) {
+    spinner.fail("API key verification failed");
+    printError(verification.error || "Unknown error");
+    return { success: false, message: verification.error || "Verification failed" };
+  }
+  spinner.succeed("API key verified!");
+  if (verification.domains && verification.domains.length > 0) {
+    console.log();
+    printInfo("Verified domains:");
+    for (const domain of verification.domains) {
+      const status = domain.status === "verified" ? "\u2713" : "\u26A0";
+      console.log(`    ${status} ${domain.name} (${domain.status})`);
+    }
+  } else {
+    console.log();
+    printInfo("No domains configured yet.");
+    printInfo("For production, add your domain at https://resend.com/domains");
+  }
+  printStep(2, "Configure sender address");
+  console.log("  For testing, you can use: onboarding@resend.dev");
+  console.log("  For production, use: noreply@your-verified-domain.com");
+  console.log();
+  let defaultFrom = "onboarding@resend.dev";
+  if (verification.domains && verification.domains.length > 0) {
+    const verifiedDomain = verification.domains.find((d) => d.status === "verified");
+    if (verifiedDomain) {
+      defaultFrom = `noreply@${verifiedDomain.name}`;
+    }
+  }
+  const emailFrom = await promptText("Default sender email:", { initial: defaultFrom });
+  const envVars = {
+    RESEND_API_KEY: apiKey
+  };
+  if (emailFrom) {
+    envVars.EMAIL_FROM = emailFrom;
+  }
+  await saveWizardResults(projectDir, envVars);
+  console.log();
+  printSuccess("Email setup complete!");
+  if (!verification.domains || verification.domains.length === 0) {
+    console.log();
+    printInfo("Important: Add a verified domain for production use");
+    printInfo("Visit: https://resend.com/domains");
+  }
+  return {
+    success: true,
+    envVars
+  };
+}
+
+// src/wizards/storage.ts
+import ora4 from "ora";
+var AWS_CONSOLE_URL = "https://console.aws.amazon.com/s3";
+var AWS_IAM_URL = "https://console.aws.amazon.com/iam";
+async function verifyS3Access(bucket, region, accessKeyId, secretAccessKey) {
+  try {
+    if (!bucket || !region || !accessKeyId || !secretAccessKey) {
+      return { valid: false, error: "Missing required configuration" };
+    }
+    if (!/^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/.test(bucket)) {
+      return { valid: false, error: "Invalid bucket name format" };
+    }
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Verification failed"
+    };
+  }
+}
+async function storageWizard(projectDir) {
+  console.log();
+  printBox("Storage Setup (AWS S3)", [
+    "Let's configure AWS S3 for file storage.",
+    "",
+    "S3 is used for:",
+    "\u2022 User file uploads",
+    "\u2022 Profile images and avatars",
+    "\u2022 Document storage",
+    "",
+    "Note: This feature is optional."
+  ]);
+  const proceed = await promptConfirm("Do you want to configure S3 storage?", true);
+  if (!proceed) {
+    printInfo("Skipping S3 storage setup.");
+    return { success: true, message: "Skipped" };
+  }
+  printStep(1, "Create or select an S3 bucket");
+  console.log("  1. Sign in to AWS Console");
+  console.log("  2. Go to S3 and create a bucket (or use existing)");
+  console.log("  3. Note the bucket name and region");
+  console.log();
+  console.log("  Recommended settings:");
+  console.log("    \u2022 Block all public access: ON");
+  console.log("    \u2022 Versioning: Optional");
+  console.log("    \u2022 Default encryption: Enabled");
+  console.log();
+  await maybeOpenBrowser(AWS_CONSOLE_URL, "AWS S3 console");
+  console.log();
+  const bucketName = await promptText("S3 Bucket name:", {
+    validate: (value) => {
+      if (!value) return "Bucket name is required";
+      if (!/^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/.test(value)) {
+        return "Invalid bucket name format";
+      }
+      return true;
+    }
+  });
+  if (!bucketName) {
+    printError("Bucket name is required");
+    return { success: false, message: "Cancelled" };
+  }
+  const region = await promptText("AWS Region:", {
+    initial: "us-east-1"
+  });
+  if (!region) {
+    printError("Region is required");
+    return { success: false, message: "Cancelled" };
+  }
+  printStep(2, "Create IAM credentials");
+  console.log("  1. Go to IAM in AWS Console");
+  console.log("  2. Create a new user or use existing");
+  console.log("  3. Attach S3 access policy (or use AmazonS3FullAccess)");
+  console.log("  4. Create Access Key and copy credentials");
+  console.log();
+  await maybeOpenBrowser(AWS_IAM_URL, "AWS IAM console");
+  console.log();
+  const accessKeyId = await promptText("AWS Access Key ID:");
+  if (!accessKeyId) {
+    printError("Access Key ID is required");
+    return { success: false, message: "Cancelled" };
+  }
+  const secretAccessKey = await promptSecret("AWS Secret Access Key:");
+  if (!secretAccessKey) {
+    printError("Secret Access Key is required");
+    return { success: false, message: "Cancelled" };
+  }
+  const spinner = ora4("Validating S3 configuration...").start();
+  const verification = await verifyS3Access(bucketName, region, accessKeyId, secretAccessKey);
+  if (!verification.valid) {
+    spinner.fail("Configuration validation failed");
+    printError(verification.error || "Unknown error");
+    const continueAnyway = await promptConfirm("Save configuration anyway?", false);
+    if (!continueAnyway) {
+      return { success: false, message: verification.error || "Verification failed" };
+    }
+    printWarning("Saving unverified configuration");
+  } else {
+    spinner.succeed("Configuration validated!");
+  }
+  const envVars = {
+    S3_BUCKET_NAME: bucketName,
+    S3_REGION: region,
+    AWS_ACCESS_KEY_ID: accessKeyId,
+    AWS_SECRET_ACCESS_KEY: secretAccessKey
+  };
+  await saveWizardResults(projectDir, envVars);
+  console.log();
+  printSuccess("Storage setup complete!");
+  console.log();
+  printInfo("Your files will be stored in:");
+  console.log(`    s3://${bucketName} (${region})`);
+  return {
+    success: true,
+    envVars
+  };
+}
+
+// src/commands/setup.ts
+function getProjectDir() {
+  return process.cwd();
+}
+async function runWizard(service, projectDir) {
+  switch (service) {
+    case "stripe":
+      return stripeWizard(projectDir);
+    case "database":
+      return databaseWizard(projectDir);
+    case "email":
+      return emailWizard(projectDir);
+    case "storage":
+      return storageWizard(projectDir);
+  }
+}
+async function setupCommand(options) {
+  const projectDir = getProjectDir();
+  if (options.service === "all") {
+    logger.newLine();
+    printBox("Scaffoldry Setup", [
+      "Let's configure all your services.",
+      "",
+      "We'll set up:",
+      "\u2022 Database (Neon PostgreSQL)",
+      "\u2022 Stripe (Payments)",
+      "\u2022 Email (Resend)",
+      "\u2022 Storage (AWS S3) - optional"
+    ]);
+    const services = ["database", "stripe", "email", "storage"];
+    const results = [];
+    for (const service of services) {
+      const result = await runWizard(service, projectDir);
+      results.push({ service, success: result.success });
+      if (!result.success && result.message !== "Skipped") {
+        logger.newLine();
+        printError(`${service} setup failed: ${result.message}`);
+        const { continueSetup } = await import("prompts").then(
+          (m) => m.default({
+            type: "confirm",
+            name: "continueSetup",
+            message: "Continue with other services?",
+            initial: true
+          })
+        );
+        if (!continueSetup) {
+          break;
+        }
+      }
+    }
+    logger.newLine();
+    printBox("Setup Complete", [
+      "Here's a summary of your configuration:",
+      "",
+      ...results.map(
+        ({ service, success }) => `${success ? "\u2713" : "\u2717"} ${service.charAt(0).toUpperCase() + service.slice(1)}`
+      )
+    ]);
+    const successCount = results.filter((r) => r.success).length;
+    if (successCount === results.length) {
+      logger.newLine();
+      printSuccess("All services configured!");
+      printInfo("Run `scaffoldry doctor` to verify your configuration");
+      printInfo("Run `scaffoldry dev` to start development");
+    } else {
+      logger.newLine();
+      printInfo(`${successCount}/${results.length} services configured`);
+      printInfo("Run `scaffoldry setup <service>` to configure remaining services");
+    }
+  } else {
+    const result = await runWizard(options.service, projectDir);
+    if (result.success) {
+      logger.newLine();
+      printInfo("Run `scaffoldry doctor` to verify your full configuration");
+    }
+  }
+}
+async function setupStripeCommand() {
+  await setupCommand({ service: "stripe" });
+}
+async function setupDatabaseCommand() {
+  await setupCommand({ service: "database" });
+}
+async function setupEmailCommand() {
+  await setupCommand({ service: "email" });
+}
+async function setupStorageCommand() {
+  await setupCommand({ service: "storage" });
+}
+async function setupAllCommand() {
+  await setupCommand({ service: "all" });
+}
+
+export {
+  logger,
+  createTemplateContext,
+  toKebabCase,
+  toPascalCase,
+  toCamelCase,
+  replaceTemplateVars,
+  getStoredLicense,
+  storeLicense,
+  clearLicense,
+  isValidLicenseKeyFormat,
+  validateLicense,
+  readEnvLocal,
+  writeEnvLocal,
+  saveProjectData,
+  checkNodeVersion,
+  checkPnpmVersion,
+  checkStripeCli,
+  checkEnvVar,
+  runEnvironmentChecks,
+  runConfigurationChecks,
+  runServiceChecks,
+  printBox,
+  printSuccess,
+  printInfo,
+  printWarning,
+  printError,
+  setupCommand,
+  setupStripeCommand,
+  setupDatabaseCommand,
+  setupEmailCommand,
+  setupStorageCommand,
+  setupAllCommand
+};
+//# sourceMappingURL=chunk-XIP7YNKZ.js.map