@spfn/cli 0.0.9 → 0.1.0-alpha.1

package/dist/index.js

@@ -0,0 +1,829 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import prompts from "prompts";
+import ora from "ora";
+import { execa } from "execa";
+import fse from "fs-extra";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import chalk2 from "chalk";
+
+// src/utils/logger.ts
+import chalk from "chalk";
+var logger = {
+  info: (message) => {
+    console.log(chalk.blue("\u2139"), message);
+  },
+  success: (message) => {
+    console.log(chalk.green("\u2713"), message);
+  },
+  warn: (message) => {
+    console.log(chalk.yellow("\u26A0"), message);
+  },
+  error: (message) => {
+    console.log(chalk.red("\u2717"), message);
+  },
+  step: (message) => {
+    console.log(chalk.cyan("\u25B8"), message);
+  }
+};
+
+// src/utils/package-manager.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function detectPackageManager(cwd) {
+  if (existsSync(join(cwd, "bun.lockb"))) {
+    return "bun";
+  }
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(join(cwd, "yarn.lock"))) {
+    return "yarn";
+  }
+  let currentDir = cwd;
+  let depth = 0;
+  const maxDepth = 5;
+  while (depth < maxDepth) {
+    const parentDir = join(currentDir, "..");
+    if (parentDir === currentDir) {
+      break;
+    }
+    if (existsSync(join(parentDir, "pnpm-lock.yaml"))) {
+      return "pnpm";
+    }
+    if (existsSync(join(parentDir, "yarn.lock"))) {
+      return "yarn";
+    }
+    if (existsSync(join(parentDir, "bun.lockb"))) {
+      return "bun";
+    }
+    currentDir = parentDir;
+    depth++;
+  }
+  return "npm";
+}
+
+// src/commands/init.ts
+var { copySync, ensureDirSync, writeFileSync } = fse;
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function findTemplatesPath() {
+  const npmPath = join2(__dirname, "templates");
+  if (existsSync2(npmPath)) {
+    return npmPath;
+  }
+  const devPath = join2(__dirname, "..", "templates");
+  if (existsSync2(devPath)) {
+    return devPath;
+  }
+  throw new Error("Templates directory not found. Please rebuild the package.");
+}
+var initCommand = new Command("init").description("Initialize SPFN in your Next.js project").option("-y, --yes", "Skip prompts and use defaults").action(async (options) => {
+  const cwd = process.cwd();
+  const packageJsonPath = join2(cwd, "package.json");
+  if (!existsSync2(packageJsonPath)) {
+    logger.error("No package.json found. Please run this in a Next.js project.");
+    process.exit(1);
+  }
+  const packageJson = JSON.parse(await import("fs").then(
+    (fs) => fs.promises.readFile(packageJsonPath, "utf-8")
+  ));
+  const hasNext = packageJson.dependencies?.next || packageJson.devDependencies?.next;
+  if (!hasNext) {
+    logger.warn("Next.js not detected in dependencies.");
+    if (!options.yes) {
+      const { proceed } = await prompts(
+        {
+          type: "confirm",
+          name: "proceed",
+          message: "Continue anyway?",
+          initial: false
+        }
+      );
+      if (!proceed) {
+        process.exit(0);
+      }
+    }
+  }
+  logger.info("Initializing SPFN in your Next.js project...\n");
+  if (existsSync2(join2(cwd, "src", "server"))) {
+    logger.warn("src/server directory already exists.");
+    if (!options.yes) {
+      const { overwrite } = await prompts(
+        {
+          type: "confirm",
+          name: "overwrite",
+          message: "Overwrite existing files?",
+          initial: false
+        }
+      );
+      if (!overwrite) {
+        logger.info("Cancelled.");
+        process.exit(0);
+      }
+    }
+  }
+  const pm = detectPackageManager(cwd);
+  logger.step(`Detected package manager: ${pm}`);
+  const spinner = ora("Installing @spfn/core...").start();
+  try {
+    const devPackages = ["tsx", "drizzle-kit", "concurrently", "dotenv"];
+    const corePackagePath = join2(cwd, "node_modules", "@spfn", "core", "package.json");
+    const isCoreInstalled = existsSync2(corePackagePath);
+    if (!isCoreInstalled) {
+      spinner.text = "Installing @spfn/core...";
+      await execa(
+        pm,
+        pm === "npm" ? ["install", "--legacy-peer-deps", "@spfn/core"] : ["add", "@spfn/core"],
+        {
+          cwd
+        }
+      );
+    } else {
+      spinner.text = "@spfn/core already installed, skipping...";
+    }
+    await execa(
+      pm,
+      pm === "npm" ? ["install", "--save-dev", ...devPackages] : ["add", "-D", ...devPackages],
+      {
+        cwd
+      }
+    );
+    spinner.succeed("Dependencies installed");
+  } catch (error) {
+    spinner.fail("Failed to install dependencies");
+    logger.error(String(error));
+    process.exit(1);
+  }
+  spinner.start("Setting up server structure...");
+  try {
+    const templatesDir = findTemplatesPath();
+    const serverTemplateDir = join2(templatesDir, "server");
+    const targetDir = join2(cwd, "src", "server");
+    if (!existsSync2(serverTemplateDir)) {
+      throw new Error(`Server templates not found at: ${serverTemplateDir}`);
+    }
+    ensureDirSync(targetDir);
+    copySync(serverTemplateDir, targetDir);
+    spinner.succeed("Server structure created");
+  } catch (error) {
+    spinner.fail("Failed to create server structure");
+    logger.error(String(error));
+    process.exit(1);
+  }
+  spinner.start("Updating package.json scripts...");
+  packageJson.scripts = packageJson.scripts || {};
+  packageJson.scripts["spfn:dev"] = "spfn dev";
+  packageJson.scripts["spfn:server"] = "spfn dev --server-only";
+  packageJson.scripts["spfn:next"] = "next dev --turbo --port 3790";
+  packageJson.scripts["spfn:start"] = "spfn start";
+  writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+  spinner.succeed("package.json updated");
+  const envExamplePath = join2(cwd, ".env.local.example");
+  if (!existsSync2(envExamplePath)) {
+    writeFileSync(envExamplePath, `# Database
+DATABASE_URL=postgresql://user:password@localhost:5432/mydb
+
+# API URL (for frontend)
+NEXT_PUBLIC_API_URL=http://localhost:8790
+`);
+    logger.success("Created .env.local.example");
+  }
+  console.log("\n" + chalk2.green.bold("\u2713 SPFN initialized successfully!\n"));
+  console.log("Next steps:");
+  console.log("  1. Copy .env.local.example to .env.local and configure your database");
+  console.log("  2. Run: " + chalk2.cyan(pm === "npm" ? "npm run spfn:dev" : `${pm} run spfn:dev`));
+  console.log("  3. Visit:");
+  console.log("     - Next.js: " + chalk2.cyan("http://localhost:3790"));
+  console.log("     - API:     " + chalk2.cyan("http://localhost:8790/health"));
+  console.log("\nAvailable scripts:");
+  console.log("  \u2022 " + chalk2.cyan("spfn:dev") + "     - Start SPFN server (8790) + Next.js (3790)");
+  console.log("  \u2022 " + chalk2.cyan("spfn:server") + "  - Start SPFN server only (8790)");
+  console.log("  \u2022 " + chalk2.cyan("spfn:next") + "    - Start Next.js only (3790)");
+});
+
+// src/commands/dev.ts
+import { Command as Command2 } from "commander";
+import { existsSync as existsSync3, readFileSync, writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { join as join3 } from "path";
+import { execa as execa2 } from "execa";
+var devCommand = new Command2("dev").description("Start SPFN development server (detects and runs Next.js + Hono)").option("-p, --port <port>", "Server port", "8790").option("-h, --host <host>", "Server host", "localhost").option("--routes <path>", "Routes directory path").option("--server-only", "Run only Hono server (skip Next.js)").option("--no-watch", "Disable hot reload (watch mode)").action(async (options) => {
+  const cwd = process.cwd();
+  const serverDir = join3(cwd, "src", "server");
+  if (!existsSync3(serverDir)) {
+    logger.error("src/server directory not found.");
+    logger.info('Run "spfn init" first to initialize SPFN in your project.');
+    process.exit(1);
+  }
+  const packageJsonPath = join3(cwd, "package.json");
+  let hasNext = false;
+  if (existsSync3(packageJsonPath)) {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    hasNext = !!(packageJson.dependencies?.next || packageJson.devDependencies?.next);
+  }
+  const tempDir = join3(cwd, "node_modules", ".spfn");
+  const serverEntry = join3(tempDir, "server.mjs");
+  const watcherEntry = join3(tempDir, "watcher.mjs");
+  mkdirSync(tempDir, { recursive: true });
+  writeFileSync2(serverEntry, `
+import { config } from 'dotenv';
+import { startServer } from '@spfn/core/server';
+
+// Load .env.local
+config({ path: '.env.local' });
+
+await startServer({
+    port: ${options.port},
+    host: '${options.host}',
+    routesPath: ${options.routes ? `'${options.routes}'` : "undefined"},
+    debug: true
+});
+`);
+  writeFileSync2(watcherEntry, `
+import { watchAndGenerate } from '@spfn/core/codegen';
+
+await watchAndGenerate({
+    routesDir: ${options.routes ? `'${options.routes}'` : "undefined"},
+    debug: true
+});
+`);
+  const pm = detectPackageManager(cwd);
+  if (options.serverOnly || !hasNext) {
+    const watchMode2 = options.watch !== false;
+    logger.info(`Starting SPFN Server on http://${options.host}:${options.port}${watchMode2 ? " (watch mode)" : ""}
+`);
+    try {
+      const tsxCmd2 = watchMode2 ? "tsx --watch" : "tsx";
+      const serverCmd2 = pm === "npm" ? `npx ${tsxCmd2} ${serverEntry}` : `${pm} exec ${tsxCmd2} ${serverEntry}`;
+      const watcherCmd2 = pm === "npm" ? `npx ${tsxCmd2} ${watcherEntry}` : `${pm} exec ${tsxCmd2} ${watcherEntry}`;
+      await execa2(
+        pm === "npm" ? "npx" : pm,
+        pm === "npm" ? ["concurrently", "--raw", "--kill-others", `"${serverCmd2}"`, `"${watcherCmd2}"`] : ["exec", "concurrently", "--raw", "--kill-others", `"${serverCmd2}"`, `"${watcherCmd2}"`],
+        {
+          stdio: "inherit",
+          cwd,
+          shell: true
+        }
+      );
+    } catch (error) {
+      if (error.exitCode === 130) {
+        process.exit(0);
+      }
+      logger.error(`Failed to start server: ${error}`);
+      process.exit(1);
+    }
+    return;
+  }
+  const watchMode = options.watch !== false;
+  const nextCmd = pm === "npm" ? "npm run spfn:next" : `${pm} run spfn:next`;
+  const tsxCmd = watchMode ? "tsx --watch" : "tsx";
+  const serverCmd = pm === "npm" ? `npx ${tsxCmd} ${serverEntry}` : `${pm} exec ${tsxCmd} ${serverEntry}`;
+  const watcherCmd = pm === "npm" ? `npx ${tsxCmd} ${watcherEntry}` : `${pm} exec ${tsxCmd} ${watcherEntry}`;
+  logger.info(`Starting SPFN server + Next.js (Turbopack)${watchMode ? " (watch mode)" : ""}...
+`);
+  try {
+    await execa2(
+      pm === "npm" ? "npx" : pm,
+      pm === "npm" ? ["concurrently", "--raw", "--kill-others", `"${nextCmd}"`, `"${serverCmd}"`, `"${watcherCmd}"`] : ["exec", "concurrently", "--raw", "--kill-others", `"${nextCmd}"`, `"${serverCmd}"`, `"${watcherCmd}"`],
+      {
+        stdio: "inherit",
+        cwd,
+        shell: true
+      }
+    );
+  } catch (error) {
+    if (error.exitCode === 130) {
+      process.exit(0);
+    }
+    logger.error(`Failed to start development servers: ${error}`);
+    process.exit(1);
+  }
+});
+
+// src/commands/start.ts
+import { Command as Command3 } from "commander";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+var startCommand = new Command3("start").description("Start SPFN production server").option("-p, --port <port>", "Server port", "4000").option("-h, --host <host>", "Server host", "0.0.0.0").action(async (options) => {
+  const cwd = process.cwd();
+  const serverDir = join4(cwd, "src", "server");
+  if (!existsSync4(serverDir)) {
+    logger.error("src/server directory not found.");
+    logger.info('Run "spfn init" first to initialize SPFN in your project.');
+    process.exit(1);
+  }
+  try {
+    const { startServer } = await import("@spfn/core");
+    await startServer(
+      {
+        port: parseInt(options.port),
+        host: options.host,
+        debug: false
+      }
+    );
+  } catch (error) {
+    if (error.code === "ERR_MODULE_NOT_FOUND") {
+      logger.error("@spfn/core is not installed.");
+      logger.info('Run "spfn init" first to set up your project.');
+    } else {
+      logger.error(`Failed to start server: ${error}`);
+    }
+    process.exit(1);
+  }
+});
+
+// src/commands/generate.ts
+import { Command as Command4 } from "commander";
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { join as join5, relative } from "path";
+import prompts2 from "prompts";
+import ora2 from "ora";
+import fse2 from "fs-extra";
+import chalk3 from "chalk";
+import { dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var { ensureDirSync: ensureDirSync2, writeFileSync: writeFileSync3 } = fse2;
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+function findScriptTemplatesPath() {
+  const devPath = join5(__dirname2, "..", "..", "core", "dist", "scripts", "templates");
+  if (existsSync5(devPath)) {
+    return devPath;
+  }
+  const npmPath = join5(__dirname2, "..", "..", "..", "core", "dist", "scripts", "templates");
+  if (existsSync5(npmPath)) {
+    return npmPath;
+  }
+  throw new Error("CRUD templates directory not found. Please rebuild the package.");
+}
+function extractEntityName(entityPath) {
+  try {
+    const content = readFileSync2(entityPath, "utf-8");
+    const match = content.match(/export\s+const\s+(\w+)\s*=\s*pgTable\(/);
+    if (match) {
+      return match[1];
+    }
+    return null;
+  } catch (error) {
+    return null;
+  }
+}
+function generateVariables(entityName) {
+  const normalized = entityName.toLowerCase();
+  const singular = normalized.endsWith("s") ? normalized.slice(0, -1) : normalized;
+  const toPascalCase = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+  const pascal = toPascalCase(normalized);
+  const pascalSingular = toPascalCase(singular);
+  const camel = normalized;
+  const camelSingular = singular;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const typeSelect = `Select${pascal}`;
+  const typeInsert = `Insert${pascal}`;
+  return {
+    "ENTITY_NAME": normalized,
+    "ENTITY_NAME_PASCAL": pascal,
+    "ENTITY_NAME_CAMEL": camel,
+    "ENTITY_NAME_SINGULAR": camelSingular,
+    "ENTITY_NAME_PASCAL_SINGULAR": pascalSingular,
+    "TYPE_SELECT": typeSelect,
+    "TYPE_INSERT": typeInsert,
+    "TIMESTAMP": timestamp
+  };
+}
+function renderTemplate(template, variables) {
+  let result = template;
+  for (const [key, value] of Object.entries(variables)) {
+    const regex = new RegExp(`{{${key}}}`, "g");
+    result = result.replace(regex, value);
+  }
+  return result;
+}
+function planFileOperations(cwd, entityName, templatesDir, variables, options, entityExists) {
+  const operations = [];
+  const entityNameNormalized = entityName.toLowerCase();
+  const entitiesBase = join5(cwd, "src", "server", "entities");
+  const routesBase = join5(cwd, "src", "server", "routes", entityNameNormalized);
+  const repositoriesBase = join5(cwd, "src", "server", "repositories");
+  const routesIdBase = join5(routesBase, "[id]");
+  const fileMap = [
+    ["entity.template.txt", join5(entitiesBase, `${entityNameNormalized}.ts`)],
+    ["contract.template.txt", join5(routesBase, "contract.ts")],
+    ["routes-index.template.txt", join5(routesBase, "index.ts")],
+    ["routes-id.template.txt", join5(routesIdBase, "index.ts")],
+    ["repository.template.txt", join5(repositoriesBase, `${entityNameNormalized}.repository.ts`)]
+  ];
+  const onlyFilter = options.only?.split(",").map((f) => f.trim()) || null;
+  for (const [templateName, targetPath] of fileMap) {
+    if (templateName === "entity.template.txt" && entityExists) {
+      continue;
+    }
+    if (onlyFilter) {
+      const fileType = templateName.replace(".template.txt", "").replace("routes-", "");
+      if (!onlyFilter.includes(fileType) && !onlyFilter.includes("routes") && !onlyFilter.includes(fileType.replace("index", "routes"))) {
+        continue;
+      }
+    }
+    const templatePath = join5(templatesDir, templateName);
+    if (!existsSync5(templatePath)) {
+      logger.warn(`Template not found: ${templateName}`);
+      continue;
+    }
+    const templateContent = readFileSync2(templatePath, "utf-8");
+    const renderedContent = renderTemplate(templateContent, variables);
+    operations.push({
+      path: targetPath,
+      content: renderedContent,
+      exists: existsSync5(targetPath)
+    });
+  }
+  return operations;
+}
+async function executeOperations(operations, options) {
+  const { force, interactive, dryRun } = options;
+  const existingFiles = operations.filter((op) => op.exists);
+  if (existingFiles.length > 0 && !force) {
+    logger.warn(`${existingFiles.length} file(s) already exist:`);
+    existingFiles.forEach((op) => {
+      logger.warn(`  - ${op.path}`);
+    });
+    if (interactive) {
+      const { proceed } = await prompts2({
+        type: "confirm",
+        name: "proceed",
+        message: "Overwrite existing files?",
+        initial: false
+      });
+      if (!proceed) {
+        logger.info("Cancelled.");
+        return;
+      }
+    } else {
+      logger.error("\nFiles already exist. Use --force to overwrite or --interactive for prompts.");
+      process.exit(1);
+    }
+  }
+  if (dryRun) {
+    logger.info("\n[DRY RUN] The following files would be created:");
+    operations.forEach((op) => {
+      const status = op.exists ? chalk3.yellow("[OVERWRITE]") : chalk3.green("[CREATE]");
+      logger.info(`  ${status} ${relative(process.cwd(), op.path)}`);
+    });
+    logger.info("\nRun without --dry-run to actually create files.");
+    return;
+  }
+  const spinner = ora2("Generating CRUD files...").start();
+  try {
+    for (const op of operations) {
+      ensureDirSync2(dirname2(op.path));
+      writeFileSync3(op.path, op.content, "utf-8");
+      const status = op.exists ? "Updated" : "Created";
+      spinner.text = `${status}: ${relative(process.cwd(), op.path)}`;
+    }
+    spinner.succeed(`Generated ${operations.length} file(s)`);
+  } catch (error) {
+    spinner.fail("Failed to generate files");
+    throw error;
+  }
+}
+var generateCommand = new Command4("generate").alias("g").description("Generate CRUD routes and repository from entity").argument("<entity>", 'Entity name or path to entity file (e.g., "users" or "src/server/entities/users.ts")').option("-f, --force", "Overwrite existing files without confirmation").option("-i, --interactive", "Prompt before overwriting each file").option("--only <files>", "Only generate specific files (comma-separated: contract,repository,routes)").option("--dry-run", "Show what would be generated without creating files").action(async (entityArg, options) => {
+  const cwd = process.cwd();
+  if (!existsSync5(join5(cwd, "src", "server"))) {
+    logger.error("SPFN not initialized. Run `spfn init` first.");
+    process.exit(1);
+  }
+  let entityName;
+  let entityPath = null;
+  let entityExists = false;
+  if (entityArg.includes("/") || entityArg.endsWith(".ts")) {
+    entityPath = entityArg.startsWith("/") ? entityArg : join5(cwd, entityArg);
+    if (!existsSync5(entityPath)) {
+      logger.error(`Entity file not found: ${entityPath}`);
+      process.exit(1);
+    }
+    const extractedName = extractEntityName(entityPath);
+    if (!extractedName) {
+      logger.error("Could not extract entity name from file. Make sure it exports a pgTable.");
+      process.exit(1);
+    }
+    entityName = extractedName;
+    entityExists = true;
+    logger.info(`Detected entity: ${chalk3.cyan(entityName)}`);
+  } else {
+    entityName = entityArg;
+    const possiblePath = join5(cwd, "src", "server", "entities", `${entityName}.ts`);
+    if (existsSync5(possiblePath)) {
+      entityPath = possiblePath;
+      entityExists = true;
+      logger.info(`Found entity file: ${chalk3.cyan(relative(cwd, entityPath))}`);
+    } else {
+      logger.info(`Creating new entity: ${chalk3.cyan(entityName)}`);
+    }
+  }
+  const variables = generateVariables(entityName);
+  const templatesDir = findScriptTemplatesPath();
+  const operations = planFileOperations(cwd, entityName, templatesDir, variables, options, entityExists);
+  if (operations.length === 0) {
+    logger.warn("No files to generate. Check your --only filter or templates directory.");
+    process.exit(0);
+  }
+  await executeOperations(operations, options);
+  if (!options.dryRun) {
+    console.log("\n" + chalk3.green.bold("\u2713 CRUD boilerplate generated successfully!\n"));
+    console.log("Generated files:");
+    operations.forEach((op) => {
+      console.log("  \u2022 " + chalk3.cyan(relative(cwd, op.path)));
+    });
+    if (!entityExists) {
+      console.log("\n" + chalk3.yellow("\u{1F4DD} Next steps:"));
+      console.log("  1. " + chalk3.cyan(`Edit entities/${entityName}.ts`) + " - Add your custom fields");
+      console.log("  2. " + chalk3.cyan("spfn db generate") + " - Generate database migration");
+      console.log("  3. " + chalk3.cyan("spfn db migrate") + " - Run migration");
+      console.log("  4. Customize routes and test your API");
+    } else {
+      console.log("\n" + chalk3.yellow("\u{1F4DD} Next steps:"));
+      console.log("  1. Review and customize the generated routes");
+      console.log("  2. Update repository with custom query methods if needed");
+      console.log("  3. Test your API endpoints");
+    }
+  }
+});
+
+// src/commands/key.ts
+import { Command as Command5 } from "commander";
+import { randomBytes } from "crypto";
+import chalk4 from "chalk";
+var PRESETS = {
+  "auth-encryption": {
+    bytes: 32,
+    description: "AES-256 encryption key for @spfn/auth",
+    envVar: "SPFN_ENCRYPTION_KEY",
+    usage: "setupAuth({ encryptionKey: ... })"
+  },
+  "nextauth-secret": {
+    bytes: 32,
+    description: "NextAuth.js secret key",
+    envVar: "NEXTAUTH_SECRET",
+    usage: "Used by NextAuth.js for session encryption"
+  },
+  "jwt-secret": {
+    bytes: 64,
+    description: "JWT signing secret (512 bits)",
+    envVar: "JWT_SECRET",
+    usage: "For signing/verifying JWT tokens"
+  },
+  "session-secret": {
+    bytes: 32,
+    description: "Session encryption secret",
+    envVar: "SESSION_SECRET",
+    usage: "For encrypting session data"
+  },
+  "api-key": {
+    bytes: 32,
+    description: "Generic API key",
+    envVar: "API_KEY",
+    usage: "For API authentication"
+  }
+};
+function copyToClipboard(text) {
+  try {
+    const { execSync } = __require("child_process");
+    if (process.platform === "darwin") {
+      execSync("pbcopy", { input: text });
+      return true;
+    } else if (process.platform === "linux") {
+      execSync("xclip -selection clipboard", { input: text });
+      return true;
+    } else if (process.platform === "win32") {
+      execSync("clip", { input: text });
+      return true;
+    }
+    return false;
+  } catch (error) {
+    return false;
+  }
+}
+function generateSecret(bytes, preset, envVarName, copy) {
+  const key = randomBytes(bytes).toString("hex");
+  const config = preset ? PRESETS[preset] : null;
+  console.log("\n" + chalk4.green.bold("\u2713 Generated secret key:"));
+  if (config) {
+    console.log(chalk4.dim(`  ${config.description} (${bytes * 8} bits)`));
+  } else {
+    console.log(chalk4.dim(`  ${bytes * 8}-bit secret`));
+  }
+  console.log("\n" + chalk4.cyan(key) + "\n");
+  const varName = envVarName || config?.envVar || "SECRET_KEY";
+  console.log(chalk4.dim("Add to your .env file:"));
+  console.log(chalk4.yellow(`${varName}=${key}
+`));
+  if (config?.usage) {
+    console.log(chalk4.dim("Usage:"));
+    console.log(chalk4.gray(`  ${config.usage}
+`));
+  }
+  if (copy) {
+    if (copyToClipboard(key)) {
+      console.log(chalk4.green("\u2713 Copied to clipboard!\n"));
+    } else {
+      logger.warn("Could not copy to clipboard");
+    }
+  }
+}
+function listPresets() {
+  console.log("\n" + chalk4.bold("Available presets:"));
+  console.log();
+  Object.entries(PRESETS).forEach(([name, config]) => {
+    console.log(`  ${chalk4.cyan(name.padEnd(20))} ${chalk4.dim(config.description)}`);
+    console.log(`  ${" ".repeat(20)} ${chalk4.gray(`\u2192 ${config.envVar} (${config.bytes * 8} bits)`)}`);
+    console.log();
+  });
+  console.log(chalk4.dim("Usage:"));
+  console.log(chalk4.gray("  spfn key <preset>"));
+  console.log(chalk4.gray("  spfn key auth-encryption --copy"));
+  console.log();
+}
+var generateValueCommand = new Command5("generate").alias("gen").description("Generate random value (simple output, no metadata)").option("-b, --bytes <number>", "Number of random bytes", "32").option("-c, --copy", "Copy to clipboard").action((options) => {
+  const bytes = parseInt(options.bytes, 10);
+  if (isNaN(bytes) || bytes < 1 || bytes > 128) {
+    logger.error("Invalid bytes value. Must be between 1 and 128.");
+    process.exit(1);
+  }
+  const value = randomBytes(bytes).toString("hex");
+  console.log(value);
+  if (options.copy) {
+    if (copyToClipboard(value)) {
+      console.error(chalk4.green("\u2713 Copied to clipboard"));
+    } else {
+      console.error(chalk4.yellow("\u26A0 Could not copy to clipboard"));
+    }
+  }
+});
+var keyCommand = new Command5("key").alias("k").description("Generate secure random keys and secrets").argument("[preset]", `Preset type (use --list to see all)`).option("-l, --list", "List all available presets").option("-b, --bytes <number>", "Number of random bytes to generate", "32").option("-e, --env <name>", "Environment variable name").option("-c, --copy", "Copy to clipboard").action((preset, options) => {
+  if (options.list) {
+    listPresets();
+    return;
+  }
+  const bytes = parseInt(options.bytes, 10);
+  if (isNaN(bytes) || bytes < 1 || bytes > 128) {
+    logger.error("Invalid bytes value. Must be between 1 and 128.");
+    process.exit(1);
+  }
+  if (preset && !(preset in PRESETS)) {
+    logger.error(`Unknown preset: ${preset}`);
+    console.log("\nAvailable presets:");
+    Object.entries(PRESETS).forEach(([name, config]) => {
+      console.log(`  ${chalk4.cyan(name)}: ${config.description}`);
+    });
+    console.log("\nUse " + chalk4.cyan("--list") + " to see detailed information");
+    process.exit(1);
+  }
+  generateSecret(
+    bytes,
+    preset,
+    options.env,
+    options.copy
+  );
+});
+keyCommand.addCommand(generateValueCommand);
+
+// src/commands/db.ts
+import { existsSync as existsSync6, writeFileSync as writeFileSync4, unlinkSync } from "fs";
+import { exec } from "child_process";
+import { promisify } from "util";
+import chalk5 from "chalk";
+import ora3 from "ora";
+var execAsync = promisify(exec);
+async function runDrizzleCommand(command) {
+  const hasUserConfig = existsSync6("./drizzle.config.ts");
+  const tempConfigPath = `./drizzle.config.${process.pid}.${Date.now()}.temp.ts`;
+  try {
+    const configPath = hasUserConfig ? "./drizzle.config.ts" : tempConfigPath;
+    if (!hasUserConfig) {
+      if (!process.env.DATABASE_URL) {
+        console.error(chalk5.red("\u274C DATABASE_URL not found in environment"));
+        console.log(chalk5.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+        process.exit(1);
+      }
+      const { generateDrizzleConfigFile } = await import("@spfn/core");
+      const configContent = generateDrizzleConfigFile();
+      writeFileSync4(tempConfigPath, configContent);
+      console.log(chalk5.dim("Using auto-generated Drizzle config\n"));
+    }
+    const fullCommand = `drizzle-kit ${command} --config=${configPath}`;
+    const { stdout, stderr } = await execAsync(fullCommand);
+    if (stdout) {
+      console.log(stdout);
+    }
+    if (stderr) {
+      console.error(stderr);
+    }
+  } finally {
+    if (!hasUserConfig && existsSync6(tempConfigPath)) {
+      unlinkSync(tempConfigPath);
+    }
+  }
+}
+async function dbGenerate() {
+  const spinner = ora3("Generating database migrations...").start();
+  try {
+    spinner.stop();
+    await runDrizzleCommand("generate");
+    console.log(chalk5.green("\u2705 Migrations generated successfully"));
+  } catch (error) {
+    spinner.fail("Failed to generate migrations");
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function dbPush() {
+  const spinner = ora3("Pushing schema changes to database...").start();
+  try {
+    spinner.stop();
+    await runDrizzleCommand("push");
+    console.log(chalk5.green("\u2705 Schema pushed successfully"));
+  } catch (error) {
+    spinner.fail("Failed to push schema");
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function dbMigrate() {
+  const spinner = ora3("Running database migrations...").start();
+  try {
+    spinner.stop();
+    await runDrizzleCommand("migrate");
+    console.log(chalk5.green("\u2705 Migrations applied successfully"));
+  } catch (error) {
+    spinner.fail("Failed to run migrations");
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function dbStudio(port = 4983) {
+  console.log(chalk5.blue("\u{1F3A8} Opening Drizzle Studio...\n"));
+  try {
+    await runDrizzleCommand(`studio --port ${port}`);
+  } catch (error) {
+    console.error(chalk5.red("\u274C Failed to start Drizzle Studio"));
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function dbDrop() {
+  console.log(chalk5.yellow("\u26A0\uFE0F  WARNING: This will drop all tables in your database!"));
+  const spinner = ora3("Dropping all tables...").start();
+  try {
+    spinner.stop();
+    await runDrizzleCommand("drop");
+    console.log(chalk5.green("\u2705 All tables dropped"));
+  } catch (error) {
+    spinner.fail("Failed to drop tables");
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+async function dbCheck() {
+  const spinner = ora3("Checking database connection...").start();
+  try {
+    await runDrizzleCommand("check");
+    spinner.succeed("Database connection OK");
+  } catch (error) {
+    spinner.fail("Database connection failed");
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command6();
+program.name("spfn").description("SPFN CLI - The Missing Backend for Next.js").version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(devCommand);
+program.addCommand(startCommand);
+program.addCommand(generateCommand);
+program.addCommand(keyCommand);
+var dbCommand = new Command6("db").description("Database management commands (wraps Drizzle Kit)");
+dbCommand.command("generate").alias("g").description("Generate database migrations from schema changes").action(dbGenerate);
+dbCommand.command("push").description("Push schema changes directly to database (no migrations)").action(dbPush);
+dbCommand.command("migrate").alias("m").description("Run pending migrations").action(dbMigrate);
+dbCommand.command("studio").description("Open Drizzle Studio (database GUI)").option("-p, --port <port>", "Studio port", "4983").action((options) => dbStudio(Number(options.port)));
+dbCommand.command("drop").description("Drop all database tables (\u26A0\uFE0F  dangerous!)").action(dbDrop);
+dbCommand.command("check").description("Check database connection").action(dbCheck);
+program.addCommand(dbCommand);
+async function run() {
+  await program.parseAsync(process.argv);
+}
+export {
+  run
+};