create-scaffauth 0.1.0

package/dist/index.js

@@ -0,0 +1,1050 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/commands/init.ts
+import path4 from "path";
+import * as p5 from "@clack/prompts";
+
+// src/cli/prompts.ts
+import * as p from "@clack/prompts";
+
+// src/utils/validators.ts
+function validateProjectName(name) {
+  if (!name || name.trim().length === 0) {
+    return "Project name is required";
+  }
+  if (!/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/.test(name)) {
+    return "Project name must be lowercase alphanumeric with hyphens (e.g. my-auth-api)";
+  }
+  if (name.length > 100) {
+    return "Project name must be 100 characters or less";
+  }
+  if (name.includes("--")) {
+    return "Project name cannot contain consecutive hyphens";
+  }
+  return void 0;
+}
+var VALID_FRAMEWORKS = ["hono", "fastify", "express"];
+var VALID_ORMS = ["drizzle", "prisma", "kysely"];
+var VALID_DATABASES = ["postgres", "mysql", "sqlite"];
+function parseTemplateOption(template) {
+  const value = template.trim().toLowerCase();
+  const [frameworkPart, ormDatabasePart] = value.split("/");
+  if (!frameworkPart || !ormDatabasePart || value.split("/").length !== 2) {
+    throw new Error(
+      `Invalid template "${template}". Expected format: framework/orm-database (e.g. hono/drizzle-postgres).`
+    );
+  }
+  const [ormPart, databasePart] = ormDatabasePart.split("-");
+  if (!ormPart || !databasePart || ormDatabasePart.split("-").length !== 2) {
+    throw new Error(
+      `Invalid template "${template}". Expected format: framework/orm-database (e.g. hono/drizzle-postgres).`
+    );
+  }
+  if (!VALID_FRAMEWORKS.includes(frameworkPart)) {
+    throw new Error(
+      `Unknown framework "${frameworkPart}". Supported: ${VALID_FRAMEWORKS.join(", ")}.`
+    );
+  }
+  if (!VALID_ORMS.includes(ormPart)) {
+    throw new Error(`Unknown ORM "${ormPart}". Supported: ${VALID_ORMS.join(", ")}.`);
+  }
+  if (!VALID_DATABASES.includes(databasePart)) {
+    throw new Error(
+      `Unknown database "${databasePart}". Supported: ${VALID_DATABASES.join(", ")}.`
+    );
+  }
+  return {
+    framework: frameworkPart,
+    orm: ormPart,
+    database: databasePart
+  };
+}
+
+// src/cli/prompts.ts
+function parsePositiveInteger(value) {
+  return Number.parseInt(value.trim(), 10);
+}
+async function gatherConfig() {
+  p.intro("Welcome to Scaffauth!");
+  const projectName = await p.text({
+    message: "What is your project name?",
+    placeholder: "my-auth-backend",
+    validate: validateProjectName
+  });
+  if (p.isCancel(projectName)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const framework = await p.select({
+    message: "Which backend framework?",
+    options: [
+      {
+        value: "hono",
+        label: "Hono",
+        hint: "Modern, fast, edge-compatible (recommended)"
+      },
+      {
+        value: "fastify",
+        label: "Fastify",
+        hint: "Battle-tested, huge ecosystem"
+      },
+      {
+        value: "express",
+        label: "Express",
+        hint: "Most familiar, largest community"
+      }
+    ]
+  });
+  if (p.isCancel(framework)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const database = await p.select({
+    message: "Which database?",
+    options: [
+      {
+        value: "postgres",
+        label: "PostgreSQL",
+        hint: "Production-grade (recommended)"
+      },
+      {
+        value: "mysql",
+        label: "MySQL",
+        hint: "Popular alternative"
+      },
+      {
+        value: "sqlite",
+        label: "SQLite",
+        hint: "Quick local development"
+      }
+    ]
+  });
+  if (p.isCancel(database)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const orm = await p.select({
+    message: "Which ORM / query builder?",
+    options: [
+      {
+        value: "drizzle",
+        label: "Drizzle",
+        hint: "Best TypeScript DX (recommended)"
+      },
+      {
+        value: "prisma",
+        label: "Prisma",
+        hint: "Most popular, great tooling"
+      },
+      {
+        value: "kysely",
+        label: "Kysely",
+        hint: "Type-safe SQL query builder"
+      }
+    ]
+  });
+  if (p.isCancel(orm)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const providers = await p.multiselect({
+    message: "Which OAuth providers? (Space to select, Enter to confirm)",
+    options: [
+      { value: "github", label: "GitHub" },
+      { value: "google", label: "Google" },
+      { value: "discord", label: "Discord" },
+      { value: "twitter", label: "Twitter/X" },
+      { value: "apple", label: "Apple" },
+      { value: "microsoft", label: "Microsoft" }
+    ],
+    required: false
+  });
+  if (p.isCancel(providers)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const twoFactor = await p.confirm({
+    message: "Enable two-factor authentication (2FA)?",
+    initialValue: false
+  });
+  if (p.isCancel(twoFactor)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const useEmail = await p.confirm({
+    message: "Set up email verification & password reset?",
+    initialValue: false
+  });
+  if (p.isCancel(useEmail)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  let emailProvider;
+  if (useEmail) {
+    const provider = await p.select({
+      message: "Which email provider?",
+      options: [
+        {
+          value: "resend",
+          label: "Resend",
+          hint: "Modern email API (recommended)"
+        },
+        {
+          value: "sendgrid",
+          label: "SendGrid",
+          hint: "Enterprise-grade email"
+        },
+        {
+          value: "smtp",
+          label: "SMTP",
+          hint: "Any SMTP server"
+        }
+      ]
+    });
+    if (p.isCancel(provider)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    emailProvider = provider;
+  }
+  const rbac = await p.confirm({
+    message: "Enable role-based access control (RBAC)?",
+    initialValue: false
+  });
+  if (p.isCancel(rbac)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const sessionStrategy = await p.select({
+    message: "Session strategy?",
+    options: [
+      {
+        value: "database",
+        label: "Database sessions",
+        hint: "Store and validate sessions via database (recommended)"
+      },
+      {
+        value: "database-cookie-cache",
+        label: "Database + cookie cache",
+        hint: "Add short-lived cookie cache for fewer DB reads"
+      }
+    ]
+  });
+  if (p.isCancel(sessionStrategy)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const sessionLifetimeDays = await p.text({
+    message: "Session lifetime (days)",
+    placeholder: "7",
+    initialValue: "7",
+    validate: (value) => {
+      const parsed = parsePositiveInteger(value);
+      if (!Number.isInteger(parsed) || parsed <= 0) {
+        return "Enter a positive integer number of days.";
+      }
+    }
+  });
+  if (p.isCancel(sessionLifetimeDays)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const sessionRefreshHours = await p.text({
+    message: "Session refresh/update age (hours)",
+    placeholder: "24",
+    initialValue: "24",
+    validate: (value) => {
+      const parsed = parsePositiveInteger(value);
+      if (!Number.isInteger(parsed) || parsed <= 0) {
+        return "Enter a positive integer number of hours.";
+      }
+    }
+  });
+  if (p.isCancel(sessionRefreshHours)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  let cookieCacheMaxAgeSeconds = 300;
+  if (sessionStrategy === "database-cookie-cache") {
+    const cookieCacheMaxAge = await p.text({
+      message: "Cookie cache max age (seconds)",
+      placeholder: "300",
+      initialValue: "300",
+      validate: (value) => {
+        const parsed = parsePositiveInteger(value);
+        if (!Number.isInteger(parsed) || parsed <= 0) {
+          return "Enter a positive integer number of seconds.";
+        }
+      }
+    });
+    if (p.isCancel(cookieCacheMaxAge)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    cookieCacheMaxAgeSeconds = parsePositiveInteger(cookieCacheMaxAge);
+  }
+  const createGitHubRepo = await p.confirm({
+    message: "Create a GitHub repository?",
+    initialValue: false
+  });
+  if (p.isCancel(createGitHubRepo)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  let githubConfig;
+  if (createGitHubRepo) {
+    const repoPrivate = await p.confirm({
+      message: "Make the repository private?",
+      initialValue: false
+    });
+    if (p.isCancel(repoPrivate)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    githubConfig = {
+      createRepo: true,
+      repoName: projectName,
+      private: repoPrivate
+    };
+  }
+  const deploy = await p.confirm({
+    message: "Deploy now?",
+    initialValue: false
+  });
+  if (p.isCancel(deploy)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  let deploymentConfig;
+  if (deploy) {
+    const platform = await p.select({
+      message: "Which platform?",
+      options: [
+        {
+          value: "vercel",
+          label: "Vercel",
+          hint: "Serverless, edge-optimized"
+        },
+        {
+          value: "railway",
+          label: "Railway",
+          hint: "Full-stack platform"
+        }
+      ]
+    });
+    if (p.isCancel(platform)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    deploymentConfig = {
+      platform,
+      environmentVars: {}
+    };
+  }
+  return {
+    projectName,
+    framework,
+    database,
+    orm,
+    authConfig: {
+      emailPassword: true,
+      providers,
+      twoFactor,
+      emailProvider,
+      rbac,
+      session: {
+        strategy: sessionStrategy,
+        expiresIn: parsePositiveInteger(sessionLifetimeDays) * 24 * 60 * 60,
+        updateAge: parsePositiveInteger(sessionRefreshHours) * 60 * 60,
+        cookieCacheEnabled: sessionStrategy === "database-cookie-cache",
+        cookieCacheMaxAge: cookieCacheMaxAgeSeconds
+      }
+    },
+    deployment: deploymentConfig,
+    github: githubConfig
+  };
+}
+function getDefaultConfig(projectName = "scaffauth-project") {
+  return {
+    projectName,
+    framework: "hono",
+    database: "postgres",
+    orm: "drizzle",
+    authConfig: {
+      emailPassword: true,
+      providers: ["github"],
+      twoFactor: false,
+      rbac: false,
+      session: {
+        strategy: "database",
+        expiresIn: 7 * 24 * 60 * 60,
+        updateAge: 24 * 60 * 60,
+        cookieCacheEnabled: false,
+        cookieCacheMaxAge: 300
+      }
+    }
+  };
+}
+
+// src/generators/template.ts
+import path2 from "path";
+import { fileURLToPath } from "url";
+import crypto from "crypto";
+import Handlebars2 from "handlebars";
+
+// src/utils/fileOperations.ts
+import fs from "fs-extra";
+import path from "path";
+import Handlebars from "handlebars";
+async function copyTemplate(templateDir, targetDir, context) {
+  await fs.ensureDir(targetDir);
+  const entries = await fs.readdir(templateDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(templateDir, entry.name);
+    let destName = entry.name;
+    if (destName.endsWith(".hbs")) {
+      destName = destName.slice(0, -4);
+    }
+    const destPath = path.join(targetDir, destName);
+    if (entry.isDirectory()) {
+      await copyTemplate(srcPath, destPath, context);
+    } else if (entry.name.endsWith(".hbs")) {
+      const content = await fs.readFile(srcPath, "utf-8");
+      const template = Handlebars.compile(content);
+      const rendered = template(context);
+      await fs.writeFile(destPath, rendered, "utf-8");
+    } else {
+      await fs.copy(srcPath, destPath);
+    }
+  }
+}
+async function directoryExists(dir) {
+  try {
+    const stat = await fs.stat(dir);
+    if (!stat.isDirectory()) return false;
+    const files = await fs.readdir(dir);
+    return files.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  info(message) {
+    console.log(chalk.blue("i"), message);
+  },
+  success(message) {
+    console.log(chalk.green("\u2713"), message);
+  },
+  warning(message) {
+    console.log(chalk.yellow("\u26A0"), message);
+  },
+  error(message) {
+    console.log(chalk.red("\u2717"), message);
+  },
+  step(message) {
+    console.log(chalk.cyan("\u2192"), message);
+  },
+  debug(message) {
+    if (process.env.SCAFFAUTH_DEBUG) {
+      console.log(chalk.gray("[debug]"), message);
+    }
+  },
+  blank() {
+    console.log();
+  },
+  box(title, content) {
+    console.log();
+    console.log(chalk.bold(title));
+    console.log(content);
+    console.log();
+  }
+};
+
+// src/generators/template.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
+Handlebars2.registerHelper("uppercase", (str) => str.toUpperCase());
+Handlebars2.registerHelper(
+  "eq",
+  (a, b) => a === b
+);
+Handlebars2.registerHelper(
+  "or",
+  (...args) => {
+    const values = args.slice(0, -1);
+    return values.some(Boolean);
+  }
+);
+function getTemplatePath(config) {
+  const { framework, orm, database } = config;
+  const templateName = `${orm}-${database}`;
+  const templateDir = path2.resolve(__dirname, "templates", framework, templateName);
+  logger.debug(`Template path: ${templateDir}`);
+  return templateDir;
+}
+function buildTemplateContext(config) {
+  return {
+    projectName: config.projectName,
+    framework: config.framework,
+    database: config.database,
+    orm: config.orm,
+    providers: config.authConfig.providers,
+    twoFactor: config.authConfig.twoFactor,
+    rbac: config.authConfig.rbac,
+    emailProvider: config.authConfig.emailProvider,
+    sessionExpiresIn: config.authConfig.session.expiresIn,
+    sessionUpdateAge: config.authConfig.session.updateAge,
+    sessionCookieCacheEnabled: config.authConfig.session.cookieCacheEnabled,
+    sessionCookieCacheMaxAge: config.authConfig.session.cookieCacheMaxAge,
+    // Generate a random auth secret for the .env.example
+    authSecret: crypto.randomBytes(32).toString("hex")
+  };
+}
+async function generateProject(config, targetDir) {
+  const templatePath = getTemplatePath(config);
+  const context = buildTemplateContext(config);
+  logger.debug(`Generating project at: ${targetDir}`);
+  logger.debug(`Using template: ${templatePath}`);
+  await copyTemplate(templatePath, targetDir, context);
+  logger.debug("Project generation complete");
+}
+
+// src/generators/install.ts
+import { execa } from "execa";
+
+// src/utils/packageManager.ts
+function detectPackageManager() {
+  const userAgent = process.env.npm_config_user_agent;
+  if (userAgent) {
+    if (userAgent.startsWith("pnpm")) return "pnpm";
+    if (userAgent.startsWith("yarn")) return "yarn";
+    if (userAgent.startsWith("bun")) return "bun";
+  }
+  return "npm";
+}
+function getInstallCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return "pnpm install";
+    case "yarn":
+      return "yarn";
+    case "bun":
+      return "bun install";
+    default:
+      return "npm install";
+  }
+}
+function getRunCommand(pm, script) {
+  switch (pm) {
+    case "pnpm":
+      return `pnpm ${script}`;
+    case "yarn":
+      return `yarn ${script}`;
+    case "bun":
+      return `bun run ${script}`;
+    default:
+      return `npm run ${script}`;
+  }
+}
+
+// src/generators/install.ts
+async function installDependencies(projectDir, pm) {
+  const command = getInstallCommand(pm);
+  const [cmd, ...args] = command.split(" ");
+  logger.debug(`Running: ${command} in ${projectDir}`);
+  await execa(cmd, args, {
+    cwd: projectDir,
+    stdio: "pipe"
+  });
+}
+
+// src/utils/gitOperations.ts
+import { execa as execa2 } from "execa";
+async function isGitInstalled() {
+  try {
+    await execa2("git", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function initGitRepo(projectDir) {
+  logger.debug(`Initializing git repo in ${projectDir}`);
+  await execa2("git", ["init"], { cwd: projectDir });
+  await execa2("git", ["add", "-A"], { cwd: projectDir });
+  await execa2("git", ["commit", "-m", "Initial commit from Scaffauth"], {
+    cwd: projectDir
+  });
+}
+async function pushToRemote(projectDir, remoteUrl) {
+  logger.debug(`Adding remote: ${remoteUrl}`);
+  await execa2("git", ["remote", "add", "origin", remoteUrl], {
+    cwd: projectDir
+  });
+  await execa2("git", ["branch", "-M", "main"], { cwd: projectDir });
+  await execa2("git", ["push", "-u", "origin", "main"], { cwd: projectDir });
+}
+
+// src/utils/github.ts
+import { Octokit } from "@octokit/rest";
+import { execa as execa3 } from "execa";
+import * as p2 from "@clack/prompts";
+async function getGitHubToken() {
+  try {
+    const { stdout } = await execa3("gh", ["auth", "token"]);
+    const token2 = stdout.trim();
+    if (token2) {
+      logger.debug("Using token from gh CLI");
+      return token2;
+    }
+  } catch {
+    logger.debug("gh CLI not available or not authenticated");
+  }
+  const token = await p2.password({
+    message: "Enter your GitHub personal access token:",
+    validate: (value) => {
+      if (!value || value.trim().length === 0) {
+        return "Token is required";
+      }
+    }
+  });
+  if (p2.isCancel(token)) {
+    throw new Error("GitHub authentication cancelled");
+  }
+  return token;
+}
+async function setupGitHub(config, projectDir) {
+  const spinner5 = p2.spinner();
+  spinner5.start("Authenticating with GitHub");
+  const token = await getGitHubToken();
+  const octokit = new Octokit({ auth: token });
+  let username;
+  try {
+    const { data: user } = await octokit.users.getAuthenticated();
+    username = user.login;
+    spinner5.stop(`Authenticated as ${username}`);
+  } catch {
+    spinner5.stop("GitHub authentication failed");
+    throw new Error(
+      "Invalid GitHub token. Make sure it has the 'repo' scope."
+    );
+  }
+  spinner5.start("Creating GitHub repository");
+  let repoUrl;
+  let cloneUrl;
+  try {
+    const { data: repo } = await octokit.repos.createForAuthenticatedUser({
+      name: config.repoName,
+      private: config.private,
+      description: config.description || "Auth backend powered by Better Auth",
+      auto_init: false
+    });
+    repoUrl = repo.html_url;
+    cloneUrl = repo.clone_url;
+    spinner5.stop(`Repository created: ${repoUrl}`);
+  } catch (err) {
+    spinner5.stop("Failed to create repository");
+    if (err instanceof Error && err.message.includes("name already exists")) {
+      throw new Error(
+        `Repository "${config.repoName}" already exists on GitHub.`
+      );
+    }
+    throw err;
+  }
+  spinner5.start("Pushing code to GitHub");
+  try {
+    await initGitRepo(projectDir);
+    await pushToRemote(projectDir, cloneUrl);
+    spinner5.stop("Code pushed to GitHub");
+  } catch (err) {
+    spinner5.stop("Failed to push to GitHub");
+    logger.debug(err instanceof Error ? err.message : String(err));
+    throw new Error(
+      "Failed to push to GitHub. Make sure git is installed and configured."
+    );
+  }
+  return { repoUrl, cloneUrl };
+}
+
+// src/deployers/vercel.ts
+import path3 from "path";
+import { execa as execa4 } from "execa";
+import * as p3 from "@clack/prompts";
+import fs2 from "fs-extra";
+async function checkVercelCLI() {
+  try {
+    await execa4("vercel", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function generateVercelConfig(_config) {
+  return {
+    version: 2,
+    builds: [
+      {
+        src: "src/index.ts",
+        use: "@vercel/node"
+      }
+    ],
+    routes: [
+      {
+        src: "/(.*)",
+        dest: "src/index.ts"
+      }
+    ]
+  };
+}
+async function deployToVercel(config, projectDir) {
+  const spinner5 = p3.spinner();
+  spinner5.start("Checking Vercel CLI");
+  const hasVercel = await checkVercelCLI();
+  if (!hasVercel) {
+    spinner5.stop("Vercel CLI not found");
+    p3.note("Install with: npm i -g vercel", "Missing dependency");
+    throw new Error(
+      "Vercel CLI is not installed. Run 'npm i -g vercel' and try again."
+    );
+  }
+  spinner5.stop("Vercel CLI found");
+  spinner5.start("Configuring Vercel project");
+  const vercelConfig = generateVercelConfig(config);
+  await fs2.writeFile(
+    path3.join(projectDir, "vercel.json"),
+    JSON.stringify(vercelConfig, null, 2) + "\n"
+  );
+  spinner5.stop("Vercel configuration written");
+  spinner5.start("Deploying to Vercel");
+  try {
+    const { stdout } = await execa4("vercel", ["--prod", "--yes"], {
+      cwd: projectDir,
+      // Vercel CLI may need terminal interaction for first-time login
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    const urlMatch = stdout.match(/https:\/\/[^\s]+/);
+    const deploymentUrl = urlMatch ? urlMatch[0] : "deployment URL unavailable";
+    spinner5.stop(`Deployed to Vercel: ${deploymentUrl}`);
+    return { url: deploymentUrl, platform: "vercel" };
+  } catch (err) {
+    spinner5.stop("Vercel deployment failed");
+    logger.debug(err instanceof Error ? err.message : String(err));
+    throw new Error(
+      "Vercel deployment failed. Run 'vercel login' first, then try 'vercel --prod' in the project directory."
+    );
+  }
+}
+
+// src/deployers/railway.ts
+import { execa as execa5 } from "execa";
+import * as p4 from "@clack/prompts";
+async function checkRailwayCLI() {
+  try {
+    await execa5("railway", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function deployToRailway(config, projectDir) {
+  const spinner5 = p4.spinner();
+  spinner5.start("Checking Railway CLI");
+  const hasRailway = await checkRailwayCLI();
+  if (!hasRailway) {
+    spinner5.stop("Railway CLI not found");
+    p4.note("Install with: npm i -g @railway/cli", "Missing dependency");
+    throw new Error(
+      "Railway CLI is not installed. Run 'npm i -g @railway/cli' and try again."
+    );
+  }
+  spinner5.stop("Railway CLI found");
+  spinner5.start("Creating Railway project");
+  try {
+    await execa5("railway", ["init"], {
+      cwd: projectDir,
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    spinner5.stop("Railway project created");
+  } catch (err) {
+    spinner5.stop("Failed to create Railway project");
+    logger.debug(err instanceof Error ? err.message : String(err));
+    throw new Error(
+      "Failed to initialize Railway project. Run 'railway login' first."
+    );
+  }
+  if (config.database === "postgres") {
+    spinner5.start("Provisioning PostgreSQL database");
+    try {
+      await execa5("railway", ["add", "--plugin", "postgresql"], {
+        cwd: projectDir,
+        stdio: ["inherit", "pipe", "pipe"]
+      });
+      spinner5.stop("PostgreSQL database provisioned");
+    } catch (err) {
+      spinner5.stop("Failed to provision database");
+      logger.warning(
+        "You may need to add a database manually in the Railway dashboard."
+      );
+      logger.debug(err instanceof Error ? err.message : String(err));
+    }
+  }
+  spinner5.start("Deploying to Railway");
+  try {
+    await execa5("railway", ["up", "--detach"], {
+      cwd: projectDir,
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    spinner5.stop("Deployed to Railway");
+  } catch (err) {
+    spinner5.stop("Railway deployment failed");
+    logger.debug(err instanceof Error ? err.message : String(err));
+    throw new Error(
+      "Railway deployment failed. Try running 'railway up' in the project directory."
+    );
+  }
+  let deploymentUrl = "check Railway dashboard for URL";
+  try {
+    const { stdout } = await execa5("railway", ["domain"], {
+      cwd: projectDir
+    });
+    if (stdout.trim()) {
+      deploymentUrl = stdout.trim();
+    }
+  } catch {
+    logger.debug("Could not retrieve Railway domain automatically");
+  }
+  return { url: deploymentUrl, platform: "railway" };
+}
+
+// src/cli/commands/init.ts
+function getErrorMessage(err) {
+  if (err instanceof Error && err.message.trim().length > 0) {
+    return err.message;
+  }
+  return "Unknown error occurred";
+}
+function logRecoverySuggestion(context, err) {
+  const message = getErrorMessage(err).toLowerCase();
+  if (context === "config") {
+    if (message.includes("tty")) {
+      logger.info("Run in an interactive terminal, or use --yes / --template.");
+      return;
+    }
+    if (message.includes("template")) {
+      logger.info(
+        "Use --template in this format: framework/orm-database (e.g. hono/drizzle-postgres)."
+      );
+      return;
+    }
+  }
+  if (context === "generation") {
+    if (message.includes("enoent") || message.includes("no such file") || message.includes("template")) {
+      logger.info(
+        "Template files were not found. Run npm run build, then try again."
+      );
+      return;
+    }
+    if (message.includes("eacces") || message.includes("permission")) {
+      logger.info(
+        "Check write permissions for the target directory and retry."
+      );
+      return;
+    }
+  }
+  if (context === "install") {
+    logger.info(
+      "You can continue setup manually by installing dependencies in the generated project."
+    );
+    return;
+  }
+  if (context === "github") {
+    logger.info(
+      "You can continue locally and connect GitHub later with git init/add/commit/remote/push."
+    );
+    return;
+  }
+  if (context === "deployment") {
+    logger.info(
+      "You can deploy manually later from the generated project directory."
+    );
+  }
+}
+async function resolveConfig(options) {
+  if (!process.stdin.isTTY && !options.yes && !options.template) {
+    throw new Error(
+      "Interactive prompts require a TTY, but none was detected in this environment."
+    );
+  }
+  if (options.template) {
+    const parsedTemplate = parseTemplateOption(options.template);
+    const config = getDefaultConfig();
+    config.framework = parsedTemplate.framework;
+    config.orm = parsedTemplate.orm;
+    config.database = parsedTemplate.database;
+    logger.info(
+      `Using template ${parsedTemplate.framework}/${parsedTemplate.orm}-${parsedTemplate.database}`
+    );
+    logger.info(
+      `Skipping prompts. Using default project name "${config.projectName}".`
+    );
+    return config;
+  }
+  if (options.yes) {
+    const config = getDefaultConfig();
+    logger.info("Using default configuration (Hono + Drizzle + PostgreSQL)");
+    return config;
+  }
+  return gatherConfig();
+}
+async function runInit(options) {
+  if (options.debug) {
+    process.env.SCAFFAUTH_DEBUG = "1";
+  }
+  let config;
+  try {
+    config = await resolveConfig(options);
+  } catch (err) {
+    logger.error(getErrorMessage(err));
+    logRecoverySuggestion("config", err);
+    process.exit(1);
+  }
+  const targetDir = path4.resolve(process.cwd(), config.projectName);
+  logger.step(
+    `Stack: ${config.framework} + ${config.orm} + ${config.database}`
+  );
+  logger.step(`Target: ${targetDir}`);
+  if (await directoryExists(targetDir)) {
+    if (!process.stdin.isTTY) {
+      logger.error(
+        `Directory "${config.projectName}" already exists and cannot be confirmed in non-interactive mode.`
+      );
+      logger.info(
+        "Use a different working directory or remove the existing directory before rerunning."
+      );
+      process.exit(1);
+    }
+    const overwrite = await p5.confirm({
+      message: `Directory "${config.projectName}" already exists. Overwrite?`,
+      initialValue: false
+    });
+    if (p5.isCancel(overwrite) || !overwrite) {
+      p5.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+  }
+  const spinner5 = p5.spinner();
+  spinner5.start("Generating project files");
+  try {
+    await generateProject(config, targetDir);
+    spinner5.stop("Project files generated");
+  } catch (err) {
+    spinner5.stop("Failed to generate project files");
+    logger.error(getErrorMessage(err));
+    logRecoverySuggestion("generation", err);
+    process.exit(1);
+  }
+  if (options.install !== false) {
+    const pm2 = detectPackageManager();
+    spinner5.start(`Installing dependencies with ${pm2}`);
+    try {
+      await installDependencies(targetDir, pm2);
+      spinner5.stop("Dependencies installed");
+    } catch (err) {
+      spinner5.stop("Failed to install dependencies");
+      logger.warning("Dependency installation failed.");
+      logger.info(`Manual command: ${getInstallCommand(pm2)}`);
+      logRecoverySuggestion("install", err);
+      logger.debug(getErrorMessage(err));
+    }
+  }
+  let githubResult;
+  const shouldGit = options.git !== false;
+  if (shouldGit && config.github?.createRepo) {
+    try {
+      githubResult = await setupGitHub(config.github, targetDir);
+    } catch (err) {
+      logger.error(getErrorMessage(err));
+      logRecoverySuggestion("github", err);
+    }
+  } else if (shouldGit) {
+    const gitAvailable = await isGitInstalled();
+    if (gitAvailable) {
+      spinner5.start("Initializing git repository");
+      try {
+        await initGitRepo(targetDir);
+        spinner5.stop("Git repository initialized");
+      } catch (err) {
+        spinner5.stop("Failed to initialize git");
+        logger.warning("Git initialization failed. Skipping git setup.");
+        logger.debug(getErrorMessage(err));
+      }
+    } else {
+      logger.warning("Git is not installed. Skipping git initialization.");
+      logger.info('Install git and run: git init && git add -A && git commit -m "Initial commit"');
+    }
+  }
+  let deployResult;
+  if (config.deployment) {
+    try {
+      if (config.deployment.platform === "vercel") {
+        deployResult = await deployToVercel(config, targetDir);
+      } else if (config.deployment.platform === "railway") {
+        deployResult = await deployToRailway(config, targetDir);
+      }
+    } catch (err) {
+      logger.error(getErrorMessage(err));
+      logRecoverySuggestion("deployment", err);
+    }
+  }
+  const pm = detectPackageManager();
+  logger.blank();
+  p5.outro("Your auth backend is ready!");
+  logger.blank();
+  logger.success(`Project created at ./${config.projectName}`);
+  logger.info(
+    `Configuration: ${config.framework}/${config.orm}-${config.database}`
+  );
+  if (githubResult) {
+    logger.success(`GitHub repository: ${githubResult.repoUrl}`);
+  }
+  if (deployResult) {
+    logger.success(`Deployed to ${deployResult.platform}: ${deployResult.url}`);
+  }
+  logger.blank();
+  if (deployResult) {
+    logger.box(
+      "Next steps:",
+      [
+        `  1. Configure OAuth credentials in your ${deployResult.platform} dashboard`,
+        `  2. Test auth endpoints at ${deployResult.url}/api/auth`,
+        `  3. Integrate with your frontend`
+      ].join("\n")
+    );
+  } else {
+    logger.box(
+      "Next steps:",
+      [
+        `  1. cd ${config.projectName}`,
+        `  2. cp .env.example .env`,
+        `  3. Update DATABASE_URL in .env`,
+        `  4. ${getRunCommand(pm, "db:push")}`,
+        `  5. ${getRunCommand(pm, "dev")}`,
+        "",
+        `  Your auth backend will be running at http://localhost:3000`
+      ].join("\n")
+    );
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("create-scaffauth").description("Scaffold production-ready Better Auth backends").version("0.1.0");
+program.command("init", { isDefault: true }).description("Initialize a new auth backend project").option("-y, --yes", "Skip prompts and use defaults").option("--no-install", "Skip package installation").option("--no-git", "Skip git initialization").option("-t, --template <template>", "Use a specific template").option("-d, --debug", "Enable debug mode").action(runInit);
+program.parse();
+//# sourceMappingURL=index.js.map