@lastshotlabs/bunshot 0.0.27 → 0.0.28

package/dist/cli/commands/init.js

@@ -0,0 +1,690 @@
+#!/usr/bin/env node
+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/cli/commands/init.ts
+import { Args, Command } from "@oclif/core";
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, readSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+function ask(question) {
+  process.stdout.write(question);
+  const buf = Buffer.alloc(1024);
+  const n = readSync(0, buf, 0, buf.length, null);
+  return buf.subarray(0, n).toString().trim().replace(/\r/g, "");
+}
+function choose(question, options, defaultIndex = 0) {
+  let selected = defaultIndex;
+  function render(initial = false) {
+    if (!initial) {
+      process.stdout.write(`\x1B[${options.length}A`);
+    }
+    for (let i = 0; i < options.length; i++) {
+      const active = i === selected;
+      const marker = active ? "\x1B[36m>\x1B[0m" : " ";
+      const label = active ? `\x1B[1m${options[i]}\x1B[0m` : `\x1B[2m${options[i]}\x1B[0m`;
+      process.stdout.write(`\x1B[2K  ${marker} ${label}
+`);
+    }
+  }
+  if (!process.stdin.isTTY) {
+    console.log(question);
+    options.forEach((opt, i) => console.log(`  ${i + 1}) ${opt}`));
+    const raw = ask(`  Choose [${defaultIndex + 1}]: `);
+    if (!raw) return defaultIndex;
+    const num = parseInt(raw);
+    if (num >= 1 && num <= options.length) return num - 1;
+    return defaultIndex;
+  }
+  console.log(question);
+  process.stdout.write("\x1B[?25l");
+  render(true);
+  process.stdin.setRawMode(true);
+  const buf = Buffer.alloc(16);
+  try {
+    while (true) {
+      const n = readSync(0, buf, 0, buf.length, null);
+      const key = buf.subarray(0, n).toString();
+      if (key === "\r" || key === "\n") {
+        break;
+      } else if (key === "\x1B[A" || key === "\x1BOA") {
+        selected = (selected - 1 + options.length) % options.length;
+        render();
+      } else if (key === "\x1B[B" || key === "\x1BOB") {
+        selected = (selected + 1) % options.length;
+        render();
+      } else if (key === "") {
+        process.stdout.write("\x1B[?25h\n");
+        process.stdin.setRawMode(false);
+        process.exit(0);
+      } else {
+        const num = parseInt(key);
+        if (num >= 1 && num <= options.length) {
+          selected = num - 1;
+          render();
+          break;
+        }
+      }
+    }
+  } finally {
+    process.stdin.setRawMode(false);
+    process.stdout.write("\x1B[?25h");
+  }
+  return selected;
+}
+var Init = class _Init extends Command {
+  static description = "Scaffold a new Bunshot application";
+  static examples = [
+    "<%= config.bin %> init my-app",
+    "<%= config.bin %> init my-app ./apps/my-app"
+  ];
+  static args = {
+    name: Args.string({ description: "App name" }),
+    dir: Args.string({ description: "Output directory" })
+  };
+  async run() {
+    const { args } = await this.parse(_Init);
+    const argTitle = args.name;
+    const argDir = args.dir;
+    const appTitle = argTitle || ask("App name: ");
+    if (!appTitle) {
+      console.error("App name is required.");
+      process.exit(1);
+    }
+    const dirDefault = appTitle.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+    const dirName = argDir || (argTitle ? dirDefault : ask(`Directory (${dirDefault}): `)) || dirDefault;
+    let mongoMode = false;
+    let useRedis = false;
+    let authStore = "mongo";
+    let sessionStore = "redis";
+    let cacheStore = "redis";
+    let oauthStateStore = "redis";
+    console.log("");
+    const presetChoice = choose("Database setup:", [
+      "Full stack        (MongoDB + Redis \u2014 production ready)",
+      "SQLite            (single file, no external services)",
+      "Memory            (ephemeral, great for prototyping/tests)",
+      "Custom            (choose each store individually)"
+    ]);
+    if (presetChoice === 0) {
+      const mongoChoice = choose("MongoDB connection mode:", [
+        "Single   (auth + app data share one connection)",
+        "Separate (auth on its own cluster)"
+      ]);
+      mongoMode = mongoChoice === 0 ? "single" : "separate";
+      useRedis = true;
+      authStore = "mongo";
+      sessionStore = "redis";
+      cacheStore = "redis";
+      oauthStateStore = "redis";
+    } else if (presetChoice === 1) {
+      mongoMode = false;
+      useRedis = false;
+      authStore = "sqlite";
+      sessionStore = "sqlite";
+      cacheStore = "sqlite";
+      oauthStateStore = "sqlite";
+    } else if (presetChoice === 2) {
+      mongoMode = false;
+      useRedis = false;
+      authStore = "memory";
+      sessionStore = "memory";
+      cacheStore = "memory";
+      oauthStateStore = "memory";
+    } else {
+      console.log("\n  Configure each store:\n");
+      const mongoChoice = choose("MongoDB:", [
+        "Single   (one connection for auth + app data)",
+        "Separate (auth on its own cluster)",
+        "None     (no MongoDB)"
+      ]);
+      if (mongoChoice === 0) mongoMode = "single";
+      else if (mongoChoice === 1) mongoMode = "separate";
+      else mongoMode = false;
+      const redisChoice = choose("Redis:", ["Yes", "No"]);
+      useRedis = redisChoice === 0;
+      const storeOptions = [];
+      const storeLabels = [];
+      if (useRedis) {
+        storeOptions.push("redis");
+        storeLabels.push("Redis");
+      }
+      if (mongoMode) {
+        storeOptions.push("mongo");
+        storeLabels.push("MongoDB");
+      }
+      storeOptions.push("sqlite", "memory");
+      storeLabels.push("SQLite", "Memory");
+      const authOptions = [];
+      const authLabels = [];
+      if (mongoMode) {
+        authOptions.push("mongo");
+        authLabels.push("MongoDB");
+      }
+      authOptions.push("sqlite", "memory");
+      authLabels.push("SQLite", "Memory");
+      const authChoice = choose("Auth store:", authLabels);
+      authStore = authOptions[authChoice];
+      const sessChoice = choose("Sessions store:", storeLabels);
+      sessionStore = storeOptions[sessChoice];
+      const cacheChoice = choose("Cache store:", storeLabels);
+      cacheStore = storeOptions[cacheChoice];
+      const oauthChoice = choose("OAuth state store:", storeLabels);
+      oauthStateStore = storeOptions[oauthChoice];
+    }
+    const usesSqlite = authStore === "sqlite" || sessionStore === "sqlite" || cacheStore === "sqlite" || oauthStateStore === "sqlite";
+    console.log("");
+    let authPosture = "web-saas";
+    let stepByStep = null;
+    const authConfigMode = choose("How would you like to configure auth?", [
+      "Use a preset     (pick a security posture, get sensible defaults)",
+      "Step by step     (choose features individually)"
+    ]);
+    if (authConfigMode === 0) {
+      const presetIndex = choose("Which best describes your app?", [
+        `Web app / SaaS       (CSRF, refresh tokens, botProtection)`,
+        `Internal / admin     (MFA required, no refresh tokens, tight limits)`,
+        `Mobile / API only    (no CSRF, cors: "*", header auth)`,
+        `Dev / prototype      (permissive \u2014 iterate fast, no rate limits)`
+      ]);
+      const presets = ["web-saas", "internal", "mobile-api", "dev"];
+      authPosture = presets[presetIndex];
+    } else {
+      authPosture = "custom";
+      const pwPolicyIndex = choose("Password policy:", [
+        "Relaxed (8 chars)",
+        "Strong (12+ chars, special required)",
+        "Minimal (dev only)"
+      ]);
+      const passwordPolicy = ["relaxed", "strong", "minimal"][pwPolicyIndex];
+      const emailVerifIndex = choose("Email verification:", ["Yes", "No"]);
+      const emailVerification = emailVerifIndex === 0;
+      const pwResetIndex = choose("Password reset:", ["Yes", "No"]);
+      const passwordReset = pwResetIndex === 0;
+      const refreshIndex = choose("Refresh tokens:", ["Yes", "No"]);
+      const refreshTokens = refreshIndex === 0;
+      const mfaIndex = choose("MFA:", ["None", "Optional (users opt in)", "Required (all users)"]);
+      const mfa = ["none", "optional", "required"][mfaIndex];
+      const csrfIndex = choose("CSRF protection:", ["Yes", "No"]);
+      const csrf = csrfIndex === 0;
+      const oauthProviders = [];
+      const allProviders = ["Google", "GitHub", "Apple", "Microsoft"];
+      while (true) {
+        const remaining = [...allProviders.filter((p) => !oauthProviders.includes(p)), "None (done)"];
+        const pIdx = choose("OAuth providers (select all that apply):", remaining);
+        const picked = remaining[pIdx];
+        if (picked === "None (done)") break;
+        oauthProviders.push(picked);
+      }
+      stepByStep = {
+        passwordPolicy,
+        emailVerification,
+        passwordReset,
+        refreshTokens,
+        mfa,
+        csrf,
+        oauthProviders
+      };
+    }
+    const projectDir = join(process.cwd(), dirName);
+    const srcDir = join(projectDir, "src");
+    const configDir = join(srcDir, "config");
+    const libDir = join(srcDir, "lib");
+    const routesDir = join(srcDir, "routes");
+    const workersDir = join(srcDir, "workers");
+    const queuesDir = join(srcDir, "queues");
+    const wsDir = join(srcDir, "ws");
+    const servicesDir = join(srcDir, "services");
+    const middlewareDir = join(srcDir, "middleware");
+    const modelsDir = join(srcDir, "models");
+    if (existsSync(projectDir)) {
+      console.error(`Directory "${dirName}" already exists.`);
+      process.exit(1);
+    }
+    function buildDbConfig() {
+      const lines = [];
+      if (mongoMode) {
+        lines.push(`  mongo: "${mongoMode}",`);
+      } else {
+        lines.push(`  mongo: false,`);
+      }
+      lines.push(`  redis: ${useRedis},`);
+      lines.push(`  auth: "${authStore}",`);
+      lines.push(`  sessions: "${sessionStore}",`);
+      lines.push(`  oauthState: "${oauthStateStore}",`);
+      lines.push(`  cache: "${cacheStore}",`);
+      if (usesSqlite) {
+        lines.push(`  sqlite: path.join(import.meta.dir, "../../data.db"),`);
+      }
+      return `{
+${lines.join("\n")}
+}`;
+    }
+    function buildAuthSecurityConfig() {
+      if (authPosture === "web-saas") {
+        return `export const auth: AuthConfig = {
+  roles: Object.values(USER_ROLES),
+  defaultRole: USER_ROLES.USER,
+  passwordPolicy: { minLength: 8, requireLetter: true, requireDigit: true },
+  // Uncomment to require email verification before login:
+  // emailVerification: {
+  //   required: true,
+  //   // Listen to auth:delivery.email_verification bus event to send the email
+  // },
+  // Uncomment to enable password reset:
+  // passwordReset: {
+  //   // Listen to auth:delivery.password_reset bus event to send the reset email
+  // },
+  refreshTokens: { accessTokenExpiry: 900, refreshTokenExpiry: 2_592_000 },
+  sessionPolicy: { trackLastActive: true },
+  // Uncomment to enable opt-in MFA (TOTP + email OTP):
+  // mfa: { issuer: APP_NAME },
+};
+
+export const security: SecurityConfig = {
+  cors: ["https://myapp.com"],   // TODO: replace with your domain
+  trustProxy: 1,
+  csrf: { enabled: true },
+  botProtection: { fingerprintRateLimit: true },
+};`;
+      }
+      if (authPosture === "internal") {
+        return `export const auth: AuthConfig = {
+  roles: ["superadmin", "admin", "viewer"],
+  defaultRole: "viewer",
+  passwordPolicy: { minLength: 14, requireLetter: true, requireDigit: true, requireSpecial: true },
+  mfa: { issuer: APP_NAME, required: true },
+  sessionPolicy: {
+    maxSessions: 2,
+    trackLastActive: true,
+    persistSessionMetadata: true,
+    includeInactiveSessions: true,
+  },
+  rateLimit: { login: { windowMs: 15 * 60 * 1000, max: 5 } },
+};
+
+export const security: SecurityConfig = {
+  cors: ["https://admin.myapp.com"],  // TODO: replace with your domain
+  trustProxy: 1,
+  csrf: { enabled: true },
+  rateLimit: { windowMs: 60_000, max: 30 },
+};`;
+      }
+      if (authPosture === "mobile-api") {
+        return `export const auth: AuthConfig = {
+  roles: Object.values(USER_ROLES),
+  defaultRole: USER_ROLES.USER,
+  refreshTokens: { accessTokenExpiry: 900, refreshTokenExpiry: 2_592_000, rotationGraceSeconds: 60 },
+  sessionPolicy: { maxSessions: 5 },
+};
+
+export const security: SecurityConfig = {
+  cors: "*",
+  trustProxy: 1,
+  botProtection: { fingerprintRateLimit: true },
+};`;
+      }
+      if (authPosture === "dev") {
+        return `export const auth: AuthConfig = {
+  roles: Object.values(USER_ROLES),
+  defaultRole: USER_ROLES.USER,
+  passwordPolicy: { minLength: 1, requireLetter: false, requireDigit: false, requireSpecial: false },
+  rateLimit: {
+    login: { windowMs: 60_000, max: 10_000 },
+    register: { windowMs: 60_000, max: 10_000 },
+  },
+};
+
+export const security: SecurityConfig = {
+  cors: "*",
+  bearerAuth: false,
+};`;
+      }
+      const c = stepByStep;
+      const authLines = [
+        `  roles: Object.values(USER_ROLES),`,
+        `  defaultRole: USER_ROLES.USER,`
+      ];
+      if (c.passwordPolicy === "relaxed") {
+        authLines.push(
+          `  passwordPolicy: { minLength: 8, requireLetter: true, requireDigit: true },`
+        );
+      } else if (c.passwordPolicy === "strong") {
+        authLines.push(
+          `  passwordPolicy: { minLength: 12, requireLetter: true, requireDigit: true, requireSpecial: true },`
+        );
+      } else {
+        authLines.push(
+          `  passwordPolicy: { minLength: 1, requireLetter: false, requireDigit: false, requireSpecial: false },`
+        );
+      }
+      if (c.emailVerification) {
+        authLines.push(`  emailVerification: {`);
+        authLines.push(`    required: true,`);
+        authLines.push(
+          `    // Listen to auth:delivery.email_verification bus event to send the email`
+        );
+        authLines.push(`  },`);
+      }
+      if (c.passwordReset) {
+        authLines.push(`  passwordReset: {`);
+        authLines.push(
+          `    // Listen to auth:delivery.password_reset bus event to send the reset email`
+        );
+        authLines.push(`  },`);
+      }
+      if (c.refreshTokens) {
+        authLines.push(
+          `  refreshTokens: { accessTokenExpiry: 900, refreshTokenExpiry: 2_592_000 },`
+        );
+      }
+      if (c.mfa === "optional") {
+        authLines.push(`  mfa: { issuer: APP_NAME },`);
+      } else if (c.mfa === "required") {
+        authLines.push(`  mfa: { issuer: APP_NAME, required: true },`);
+      }
+      authLines.push(`  sessionPolicy: { trackLastActive: true },`);
+      const authBlock = `export const auth: AuthConfig = {
+${authLines.join("\n")}
+};`;
+      const secLines = [`  cors: "*",`];
+      if (c.csrf) {
+        secLines.push(`  csrf: { enabled: true },`);
+      }
+      const secBlock = `export const security: SecurityConfig = {
+${secLines.join("\n")}
+};`;
+      return `${authBlock}
+
+${secBlock}`;
+    }
+    const constantsContent = `export const APP_NAME = "${appTitle}";
+export const APP_VERSION = "1.0.0";
+
+export const USER_ROLES = {
+  ADMIN: "admin",
+  USER: "user",
+};
+`;
+    const configContent = `import path from "path";
+import {
+  type AppMeta,
+  type AuthConfig,
+  type CreateServerConfig,
+  type DbConfig,
+  type SecurityConfig,
+} from "@lastshotlabs/bunshot";
+import { APP_NAME, APP_VERSION, USER_ROLES } from "@shared/constants";
+
+export const app: AppMeta = {
+  name: APP_NAME,
+  version: APP_VERSION,
+};
+
+export const routesDir = path.join(import.meta.dir, "../routes");
+
+export const workersDir = path.join(import.meta.dir, "../workers");
+
+export const port = process.env.PORT ? parseInt(process.env.PORT) : 3000;
+
+export const db: DbConfig = ${buildDbConfig()};
+
+${buildAuthSecurityConfig()}
+
+export const appConfig: CreateServerConfig = {
+  app,
+  routesDir,
+  workersDir,
+  port,
+  db,
+  auth,
+  security,
+};
+`;
+    const indexContent = `import { createServer } from "@lastshotlabs/bunshot";
+import { appConfig } from "@config/index";
+
+await createServer(appConfig);
+`;
+    const readmeContent = `# ${appTitle}
+
+Built with [@lastshotlabs/bunshot](https://github.com/Last-Shot-Labs/bunshot).
+
+## Getting started
+
+\`\`\`bash
+# fill in .env with your values
+bun dev
+\`\`\`
+
+| Endpoint | Description |
+|---|---|
+| \`POST /auth/register\` | Create account |
+| \`POST /auth/login\` | Sign in, returns JWT |
+| \`GET  /docs\` | OpenAPI docs (Scalar) |
+| \`GET  /health\` | Health check |
+
+## Project structure
+
+\`\`\`
+src/
+  index.ts          # server entry point
+  config/index.ts   # centralized app configuration
+  lib/constants.ts  # app name, version, roles
+  routes/           # file-based routing (each file = a router)
+  workers/          # BullMQ workers (auto-imported on start)
+  middleware/       # custom middleware
+  models/           # data models
+  services/         # business logic
+\`\`\`
+
+## Adding routes
+
+Create a file in \`src/routes/\`:
+
+\`\`\`ts
+// src/routes/products.ts
+import { createRouter } from "@lastshotlabs/bunshot";
+import { z } from "zod";
+
+export const router = createRouter();
+
+router.get("/products", (c) => c.json({ products: [] }));
+\`\`\`
+${mongoMode ? `
+## Adding models
+
+\`\`\`ts
+// src/models/Product.ts
+import { getMongooseModule, getMongoFromApp } from "@lastshotlabs/bunshot";
+
+const mongoose = getMongooseModule();
+
+const ProductSchema = new mongoose.Schema({
+  name: { type: String, required: true },
+  price: { type: Number, required: true },
+}, { timestamps: true });
+
+// Use getMongoFromApp(app) to get connections from context
+// export const Product = appConn.model("Product", ProductSchema);
+\`\`\`
+` : ""}
+## Environment variables
+
+See \`.env\` \u2014 fill in the values before running.
+`;
+    function buildEnv() {
+      const sections = [`NODE_ENV=development`, `PORT=3000`];
+      if (mongoMode === "single") {
+        sections.push(`
+# MongoDB
+MONGO_USER=
+MONGO_PASSWORD=
+MONGO_HOST=
+MONGO_DB=`);
+      } else if (mongoMode === "separate") {
+        sections.push(`
+# MongoDB (app data)
+MONGO_USER=
+MONGO_PASSWORD=
+MONGO_HOST=
+MONGO_DB=
+
+# MongoDB (auth \u2014 separate cluster)
+MONGO_AUTH_USER=
+MONGO_AUTH_PASSWORD=
+MONGO_AUTH_HOST=
+MONGO_AUTH_DB=`);
+      }
+      if (useRedis) {
+        sections.push(`
+# Redis
+REDIS_HOST=
+REDIS_USER=
+REDIS_PASSWORD=`);
+      }
+      sections.push(`
+# JWT
+JWT_SECRET=
+
+# Bearer API key
+BEARER_TOKEN=
+
+# OAuth \u2014 Google (optional)
+# GOOGLE_CLIENT_ID=
+# GOOGLE_CLIENT_SECRET=
+# GOOGLE_REDIRECT_URI=
+
+# OAuth \u2014 Apple (optional)
+# APPLE_CLIENT_ID=
+# APPLE_TEAM_ID=
+# APPLE_KEY_ID=
+# APPLE_PRIVATE_KEY=
+# APPLE_REDIRECT_URI=
+
+# OAuth \u2014 GitHub (optional)
+# GITHUB_CLIENT_ID=
+# GITHUB_CLIENT_SECRET=
+# GITHUB_REDIRECT_URI=
+
+# OAuth \u2014 Microsoft (optional)
+# MICROSOFT_TENANT_ID=
+# MICROSOFT_CLIENT_ID=
+# MICROSOFT_CLIENT_SECRET=
+# MICROSOFT_REDIRECT_URI=`);
+      return sections.join("\n") + "\n";
+    }
+    console.log(`
+@lastshotlabs/bunshot \u2014 creating ${dirName}
+`);
+    mkdirSync(projectDir, { recursive: true });
+    console.log("  Running bun init...");
+    spawnSync("bun", ["init", "-y"], { cwd: projectDir, stdio: "inherit" });
+    const rootIndex = join(projectDir, "index.ts");
+    if (existsSync(rootIndex)) rmSync(rootIndex);
+    const pkgPath = join(projectDir, "package.json");
+    const pkg = JSON.parse(__require("fs").readFileSync(pkgPath, "utf-8"));
+    pkg.module = "src/index.ts";
+    pkg.scripts = { dev: "bun --watch src/index.ts", start: "bun src/index.ts" };
+    pkg.dependencies = { ...pkg.dependencies, "@lastshotlabs/bunshot": "*" };
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+    const tsconfigPath = join(projectDir, "tsconfig.json");
+    const tsconfigContent = {
+      compilerOptions: {
+        lib: ["ESNext"],
+        target: "ESNext",
+        module: "Preserve",
+        moduleDetection: "force",
+        jsx: "react-jsx",
+        allowJs: true,
+        moduleResolution: "bundler",
+        allowImportingTsExtensions: true,
+        verbatimModuleSyntax: true,
+        noEmit: true,
+        strict: true,
+        skipLibCheck: true,
+        noFallthroughCasesInSwitch: true,
+        noUncheckedIndexedAccess: true,
+        noImplicitOverride: true,
+        noUnusedLocals: false,
+        noUnusedParameters: false,
+        noPropertyAccessFromIndexSignature: false,
+        paths: {
+          "@lib/*": ["./src/lib/*"],
+          "@middleware/*": ["./src/middleware/*"],
+          "@models/*": ["./src/models/*"],
+          "@queues/*": ["./src/queues/*"],
+          "@routes/*": ["./src/routes/*"],
+          "@scripts/*": ["./src/scripts/*"],
+          "@services/*": ["./src/services/*"],
+          "@workers/*": ["./src/workers/*"],
+          "@service-facades/*": ["./src/service-facades/*"],
+          "@config/*": ["./src/config/*"],
+          "@constants/*": ["./src/lib/constants/*"]
+        }
+      }
+    };
+    writeFileSync(tsconfigPath, JSON.stringify(tsconfigContent, null, 2) + "\n", "utf-8");
+    mkdirSync(configDir, { recursive: true });
+    mkdirSync(libDir, { recursive: true });
+    mkdirSync(routesDir, { recursive: true });
+    mkdirSync(workersDir, { recursive: true });
+    mkdirSync(queuesDir, { recursive: true });
+    mkdirSync(wsDir, { recursive: true });
+    mkdirSync(servicesDir, { recursive: true });
+    mkdirSync(middlewareDir, { recursive: true });
+    mkdirSync(modelsDir, { recursive: true });
+    writeFileSync(join(libDir, "constants.ts"), constantsContent, "utf-8");
+    writeFileSync(join(configDir, "index.ts"), configContent, "utf-8");
+    writeFileSync(join(srcDir, "index.ts"), indexContent, "utf-8");
+    writeFileSync(join(projectDir, ".env"), buildEnv(), "utf-8");
+    writeFileSync(join(projectDir, "README.md"), readmeContent, "utf-8");
+    console.log("  Created:");
+    console.log(`    + ${dirName}/src/index.ts`);
+    console.log(`    + ${dirName}/src/config/index.ts`);
+    console.log(`    + ${dirName}/src/lib/constants.ts`);
+    console.log(`    + ${dirName}/src/routes/`);
+    console.log(`    + ${dirName}/src/workers/`);
+    console.log(`    + ${dirName}/src/queues/`);
+    console.log(`    + ${dirName}/src/ws/`);
+    console.log(`    + ${dirName}/src/services/`);
+    console.log(`    + ${dirName}/src/middleware/`);
+    console.log(`    + ${dirName}/src/models/`);
+    console.log(`    + ${dirName}/.env`);
+    console.log(`    + ${dirName}/README.md`);
+    console.log(`
+  DB config:`);
+    console.log(`    mongo: ${mongoMode || "none"} | redis: ${useRedis}`);
+    console.log(
+      `    auth: ${authStore} | sessions: ${sessionStore} | cache: ${cacheStore} | oauthState: ${oauthStateStore}`
+    );
+    console.log(`
+  Auth config:`);
+    console.log(`    posture: ${authPosture}`);
+    console.log("\n  Initializing git...");
+    const git = spawnSync("git", ["init"], { cwd: projectDir, stdio: "inherit" });
+    if (git.status !== 0) {
+      console.error("  git init failed \u2014 skipping.");
+    }
+    console.log("\n  Installing dependencies...");
+    const install = spawnSync("bun", ["install"], { cwd: projectDir, stdio: "inherit" });
+    if (install.status !== 0) {
+      console.error("\n  bun install failed. Run it manually inside the directory.");
+      process.exit(1);
+    }
+    console.log(`
+Done! Next steps:
+`);
+    console.log(`  cd ${dirName}`);
+    console.log(`  # fill in .env`);
+    console.log(`  bun dev
+`);
+  }
+};
+export {
+  Init as default
+};

package/dist/cli/index.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { flush, run } from "@oclif/core";
+await run(process.argv.slice(2), import.meta.url);
+await flush();