create-kubojs 0.5.0 → 0.6.0

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { _ as types_exports, g as setTelemetrySource, i as SchemaNameSchema, l as create, m as getSchemaResult, s as add, u as createBtsCli, v as getLatestCLIVersion } from "./src-QAuuh4xm.mjs";
+import { _ as types_exports, g as setTelemetrySource, i as SchemaNameSchema, l as create, m as getSchemaResult, s as add, u as createBtsCli, v as getLatestCLIVersion } from "./src-CYAa_B_y.mjs";
 import z from "zod";
 import { format } from "node:util";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/dist/index.d.mts

@@ -216,6 +216,8 @@ declare const router: _$_trpc_server0.TRPCBuiltRouter<{
           installCli?: boolean | undefined;
         } | undefined;
       } | undefined;
+      layout?: string | undefined;
+      layoutCode?: string | undefined;
     }];
     output: CreateProjectResult | undefined;
     meta: TrpcCliMeta;
@@ -286,6 +288,24 @@ declare const router: _$_trpc_server0.TRPCBuiltRouter<{
       renderTitle?: boolean | undefined;
       disableAnalytics?: boolean | undefined;
       manualDb?: boolean | undefined;
+      layout?: {
+        version?: 1 | undefined;
+        preset?: "server-separated" | "standard" | "libs" | undefined;
+        dirs?: {
+          apps?: string | undefined;
+          packages?: string | undefined;
+        } | undefined;
+        apps?: {
+          web?: string | undefined;
+          server?: string | undefined;
+          native?: string | undefined;
+          desktop?: string | undefined;
+          docs?: string | undefined;
+          api?: string | undefined;
+        } | undefined;
+        packages?: Record<string, string> | undefined;
+      } | undefined;
+      layoutCode?: string | undefined;
     };
     output: CreateProjectResult;
     meta: TrpcCliMeta;

package/dist/index.mjs

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import { C as ProjectCreationError, S as DirectoryConflictError, T as ValidationError, a as TEMPLATE_COUNT, b as CompatibilityError, c as builder, d as createVirtual, f as docs, h as router, i as SchemaNameSchema, l as create, m as getSchemaResult, n as GeneratorError, o as VirtualFileSystem, p as generate, r as Result, s as add, t as EMBEDDED_TEMPLATES, u as createBtsCli, w as UserCancelledError, x as DatabaseSetupError, y as CLIError } from "./src-QAuuh4xm.mjs";
+import { C as ProjectCreationError, S as DirectoryConflictError, T as ValidationError, a as TEMPLATE_COUNT, b as CompatibilityError, c as builder, d as createVirtual, f as docs, h as router, i as SchemaNameSchema, l as create, m as getSchemaResult, n as GeneratorError, o as VirtualFileSystem, p as generate, r as Result, s as add, t as EMBEDDED_TEMPLATES, u as createBtsCli, w as UserCancelledError, x as DatabaseSetupError, y as CLIError } from "./src-CYAa_B_y.mjs";
 export { CLIError, CompatibilityError, DatabaseSetupError, DirectoryConflictError, EMBEDDED_TEMPLATES, GeneratorError, ProjectCreationError, Result, SchemaNameSchema, TEMPLATE_COUNT, UserCancelledError, ValidationError, VirtualFileSystem, add, builder, create, createBtsCli, createVirtual, docs, generate, getSchemaResult, router };

package/dist/{src-QAuuh4xm.mjs → src-CYAa_B_y.mjs}

@@ -12,7 +12,7 @@ import envPaths from "env-paths";
 import fs from "fs-extra";
 import { fileURLToPath } from "node:url";
 import { ADDON_COMPATIBILITY, COMMUNICATION_PRODUCT_NAMES, CONVEX_BETTER_AUTH_INCOMPATIBLE_FRONTENDS, CONVEX_BETTER_AUTH_SUPPORTED_FRONTENDS, FRONTEND_VALUES, KUBO_CLI_TITLE, KUBO_TITLE_COLORS, KuboConfigFileSchema, KubojsConfigFileSchema, WEB_FRONTENDS_REQUIRING_ORPC, backendAllowsAiExample, backendAllowsApi, backendAllowsOnlyNoneApi, evaluate, getCommunicationCompatibilityIssue, getPaymentCompatibilityIssue, isCommunicationProvider, isWebFrontend, normalizeCommunication, normalizeCommunication as normalizeCommunication$2, normalizeLegacyKuboConfig, normalizeObservability, normalizePayments } from "@kubojs/types";
-import { EMBEDDED_TEMPLATES, EMBEDDED_TEMPLATES as EMBEDDED_TEMPLATES$1, GeneratorError, GeneratorError as GeneratorError$1, KUBO_CONFIG_FILE, TEMPLATE_COUNT, VirtualFileSystem, VirtualFileSystem as VirtualFileSystem$1, applyAddonCatalog, dependencyVersionMap, generate, generate as generate$1, generateReproducibleCommand, getWebAppPath, isBinaryFile, processEnvVariables, processPackageConfigs, processTemplateString, resolveLayout, serializeKuboConfigFile } from "@kubojs/template-generator";
+import { EMBEDDED_TEMPLATES, EMBEDDED_TEMPLATES as EMBEDDED_TEMPLATES$1, GeneratorError, GeneratorError as GeneratorError$1, KUBO_CONFIG_FILE, TEMPLATE_COUNT, VirtualFileSystem, VirtualFileSystem as VirtualFileSystem$1, appDir, applyAddonCatalog, createLayoutResolver, dependencyVersionMap, generate, generate as generate$1, generateReproducibleCommand, getWebAppPath, isBinaryFile, pkgDir, processEnvVariables, processPackageConfigs, processTemplateString, relocateLayoutPaths, resolveLayout, serializeKuboConfigFile } from "@kubojs/template-generator";
 import { consola, createConsola } from "consola";
 import { AsyncLocalStorage } from "node:async_hooks";
 import gradient from "gradient-string";
@@ -21,6 +21,7 @@ import { writeSelected, writeTree } from "@kubojs/template-generator/fs-writer";
 import { ConfirmPrompt, GroupMultiSelectPrompt, MultiSelectPrompt, SelectPrompt, TextPrompt, isCancel as isCancel$1, isCancel as isCancel$2 } from "@clack/core";
 import { createJiti } from "jiti";
 import { parse } from "jsonc-parser";
+import { randomUUID } from "node:crypto";
 import os from "node:os";
 import { format } from "oxfmt";
 import { Generator, configSchema } from "@tanstack/router-generator";
@@ -2476,6 +2477,15 @@ async function setupSkills(config) {
 	return Result.ok(void 0);
 }
 //#endregion
+//#region src/utils/layout-paths.ts
+/**
+* App folder that holds the database `.env` (the web app for fullstack `self` backends,
+* otherwise the server app), resolved against the project layout.
+*/
+function getDbEnvTargetApp(config) {
+	return appDir(config, config.backend === "self" ? "web" : "server");
+}
+//#endregion
 //#region src/helpers/addons/tauri-setup.ts
 function getWebFrontend(frontend) {
 	return frontend.find((value) => types_exports.desktopWebFrontends.includes(value));
@@ -2526,7 +2536,7 @@ async function setupTauri(config) {
 	if (shouldSkipExternalCommands()) return Result.ok(void 0);
 	const { packageManager, frontend, projectDir } = config;
 	const s = createSpinner();
-	const clientPackageDir = path.join(projectDir, "apps/web");
+	const clientPackageDir = path.join(projectDir, appDir(config, "web"));
 	if (!await fs.pathExists(clientPackageDir)) return Result.ok(void 0);
 	s.start("Setting up Tauri desktop app support...");
 	const [command, ...args] = buildTauriInitArgs({
@@ -4182,7 +4192,58 @@ async function getProjectName(initialName) {
 	return projectPath;
 }
 //#endregion
+//#region src/utils/telemetry.ts
+const TRUTHY = new Set([
+	"1",
+	"true",
+	"yes"
+]);
+function isTruthy(value) {
+	return value !== void 0 && TRUTHY.has(value.toLowerCase());
+}
+/**
+* Returns true if telemetry/analytics should be enabled, false otherwise.
+*
+* Opt-out, checked in order:
+* - `KUBO_TELEMETRY_DISABLED=1` disables.
+* - `DO_NOT_TRACK=1` disables (https://consoledonottrack.com).
+* - Legacy `BTS_TELEMETRY_DISABLED=1` disables; legacy `BTS_TELEMETRY=0` disables.
+* - Otherwise enabled.
+*/
+function isTelemetryEnabled(env = process.env) {
+	if (isTruthy(env.KUBO_TELEMETRY_DISABLED)) return false;
+	if (isTruthy(env.DO_NOT_TRACK)) return false;
+	if (env.BTS_TELEMETRY_DISABLED !== void 0) return env.BTS_TELEMETRY_DISABLED !== "1";
+	if (env.BTS_TELEMETRY !== void 0) return env.BTS_TELEMETRY === "1";
+	return true;
+}
+/** Coding agents we can recognize from the environment they set for child processes. */
+const AGENT_ENV_MARKERS = [
+	["claude-code", "CLAUDECODE"],
+	["cursor", "CURSOR_AGENT"],
+	["cursor", "CURSOR_TRACE_ID"],
+	["codex", "CODEX_SANDBOX"],
+	["codex", "CODEX_MANAGED_BY_NPM"],
+	["gemini-cli", "GEMINI_CLI"],
+	["opencode", "OPENCODE"],
+	["amp", "AMP_CURRENT_THREAD_ID"],
+	["cline", "CLINE_ACTIVE"],
+	["replit", "REPL_ID"]
+];
+function detectAgent(env = process.env) {
+	const match = AGENT_ENV_MARKERS.find(([, envVar]) => Boolean(env[envVar]));
+	if (match) return match[0];
+	return env.AI_AGENT ? "other" : void 0;
+}
+function isCI(env = process.env) {
+	return isTruthy(env.CI) || Boolean(env.GITHUB_ACTIONS || env.GITLAB_CI || env.BUILDKITE || env.CIRCLECI);
+}
+//#endregion
 //#region src/utils/analytics.ts
+const CONVEX_INGEST_URL = "https://moonlit-seal-677.convex.site/api/analytics/ingest";
+const SEND_TIMEOUT_MS = 2e3;
+const TELEMETRY_FILE = "telemetry.json";
+const TELEMETRY_DOCS_URL = "https://kubojs.dev/docs/analytics";
 let telemetrySource = "cli";
 /** Set once per process by entry points that are not the interactive terminal (e.g. MCP). */
 function setTelemetrySource(source) {
@@ -4192,7 +4253,102 @@ function setTelemetrySource(source) {
 function markProgrammaticTelemetrySource() {
 	if (telemetrySource === "cli") telemetrySource = "api";
 }
-async function trackCreateEvent(event, disableAnalytics = false) {}
+function getTelemetryFilePath() {
+	return path.join(envPaths("kubojs", { suffix: "" }).config, TELEMETRY_FILE);
+}
+function isTelemetryState(value) {
+	return typeof value === "object" && value !== null && "installId" in value && typeof value.installId === "string" && "noticeShown" in value && typeof value.noticeShown === "boolean";
+}
+/**
+* Reads the anonymous install id (a random UUID, not derived from the machine or user),
+* creating it on first use. Returns undefined if the config dir is not writable.
+*/
+async function loadTelemetryState() {
+	const filePath = getTelemetryFilePath();
+	const existing = await Result.tryPromise({
+		try: async () => fs.readJson(filePath),
+		catch: () => void 0
+	});
+	if (existing.isOk() && isTelemetryState(existing.value)) return existing.value;
+	const state = {
+		installId: randomUUID(),
+		noticeShown: false
+	};
+	return (await Result.tryPromise({
+		try: async () => {
+			await fs.ensureDir(path.dirname(filePath));
+			await fs.writeJson(filePath, state, { spaces: 2 });
+		},
+		catch: () => void 0
+	})).isOk() ? state : void 0;
+}
+async function markNoticeShown(state) {
+	await Result.tryPromise({
+		try: () => fs.writeJson(getTelemetryFilePath(), {
+			...state,
+			noticeShown: true
+		}, { spaces: 2 }),
+		catch: () => void 0
+	});
+}
+function showTelemetryNotice() {
+	log.info(pc.dim(`kubojs collects anonymous usage data (stack choices, CLI version, OS) to guide development.
+No project names, paths or personal data. Opt out with KUBO_TELEMETRY_DISABLED=1.
+Details: ${TELEMETRY_DOCS_URL}`));
+}
+async function sendConvexEvent(payload) {
+	await Result.tryPromise({
+		try: () => fetch(CONVEX_INGEST_URL, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(payload),
+			signal: AbortSignal.timeout(SEND_TIMEOUT_MS)
+		}),
+		catch: () => void 0
+	});
+}
+function getStackPayload(config) {
+	return {
+		database: config.database,
+		orm: config.orm,
+		backend: config.backend,
+		runtime: config.runtime,
+		frontend: config.frontend,
+		addons: config.addons,
+		examples: config.examples,
+		auth: config.auth,
+		payments: config.payments,
+		git: config.git,
+		packageManager: config.packageManager,
+		install: config.install,
+		dbSetup: config.dbSetup,
+		api: config.api,
+		webDeploy: config.webDeploy,
+		serverDeploy: config.serverDeploy
+	};
+}
+async function trackCreateEvent(event, disableAnalytics = false) {
+	if (!isTelemetryEnabled() || disableAnalytics) return;
+	const state = await loadTelemetryState();
+	if (state && !state.noticeShown && !isSilent()) {
+		showTelemetryNotice();
+		await markNoticeShown(state);
+	}
+	await sendConvexEvent({
+		...event.config ? getStackPayload(event.config) : {},
+		install_id: state?.installId,
+		source: telemetrySource,
+		mode: event.mode,
+		agent: detectAgent(),
+		ci: isCI(),
+		outcome: event.outcome,
+		error_category: event.errorCategory,
+		duration_ms: event.durationMs,
+		cli_version: getLatestCLIVersion(),
+		node_version: process.version,
+		platform: process.platform
+	});
+}
 //#endregion
 //#region src/utils/display-config.ts
 function displayConfig(config) {
@@ -4246,6 +4402,90 @@ function displayConfig(config) {
 	return configDisplay.join("\n");
 }
 //#endregion
+//#region src/utils/layout-input.ts
+function formatZodIssues(error) {
+	return error.issues.map((issue) => `${issue.path.length > 0 ? issue.path.join(".") : "layout"}: ${issue.message}`).join("; ");
+}
+function isLayoutPreset(value) {
+	return types_exports.LAYOUT_PRESET_IDS.some((preset) => preset === value);
+}
+/**
+* Parses the `--layout` flag: a preset name (`standard`, `libs`) or a JSON layout object,
+* e.g. `--layout '{"preset":"libs","apps":{"web":"web"}}'`.
+*/
+function parseLayoutFlag(value) {
+	const trimmed = value.trim();
+	if (isLayoutPreset(trimmed)) return Result.ok({
+		version: 1,
+		preset: trimmed
+	});
+	if (!trimmed.startsWith("{")) return Result.err(new CLIError({ message: `Invalid --layout "${value}". Use a preset (${types_exports.LAYOUT_PRESET_IDS.join(", ")}) or a JSON layout object.` }));
+	const json = Result.try({
+		try: () => JSON.parse(trimmed),
+		catch: (cause) => new CLIError({
+			message: "Invalid --layout JSON",
+			cause
+		})
+	});
+	if (json.isErr()) return Result.err(json.error);
+	const parsed = types_exports.LayoutConfigSchema.safeParse(json.value);
+	if (!parsed.success) return Result.err(new CLIError({ message: `Invalid --layout: ${formatZodIssues(parsed.error)}` }));
+	return Result.ok(parsed.data);
+}
+/**
+* Validates a layout before anything is written: schema shape plus folder conflicts
+* (collisions, case-only collisions, nested folders).
+*/
+function validateCreateLayout(layout) {
+	if (layout === void 0) return Result.ok(void 0);
+	const parsed = types_exports.LayoutConfigSchema.safeParse(layout);
+	if (!parsed.success) return Result.err(new CLIError({ message: `Invalid layout: ${formatZodIssues(parsed.error)}` }));
+	const resolver = createLayoutResolver(parsed.data);
+	if (resolver.isErr()) return Result.err(new CLIError({
+		message: `Invalid layout: ${resolver.error.message}`,
+		cause: resolver.error
+	}));
+	return Result.ok(parsed.data);
+}
+const DEFAULT_KUBO_API_URL = "https://kubojs.dev";
+const REDEEM_TIMEOUT_MS = 1e4;
+function getRedeemUrl() {
+	return `${process.env.KUBO_API_URL?.replace(/\/$/, "") || DEFAULT_KUBO_API_URL}/api/layout/redeem`;
+}
+/**
+* Exchanges a single-use code from kubojs.dev for the layout saved in the account. The code
+* is consumed on success; it is never logged or sent to telemetry.
+*/
+async function redeemLayoutCode(code) {
+	const response = await Result.tryPromise({
+		try: () => fetch(getRedeemUrl(), {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ code }),
+			signal: AbortSignal.timeout(REDEEM_TIMEOUT_MS)
+		}),
+		catch: (cause) => new CLIError({
+			message: "Could not reach kubojs.dev to redeem the layout code. Check your connection.",
+			cause
+		})
+	});
+	if (response.isErr()) return Result.err(response.error);
+	if (response.value.status === 400 || response.value.status === 404) return Result.err(new CLIError({ message: "This layout code is invalid, expired or was already used. Generate a new one in the Layout tab at kubojs.dev/new." }));
+	if (!response.value.ok) return Result.err(new CLIError({ message: `Layout code redemption failed (HTTP ${response.value.status}).` }));
+	const body = await Result.tryPromise({
+		try: async () => response.value.json(),
+		catch: (cause) => new CLIError({
+			message: "Invalid response while redeeming the layout code",
+			cause
+		})
+	});
+	if (body.isErr()) return Result.err(body.error);
+	const layout = typeof body.value === "object" && body.value !== null && "layout" in body.value ? body.value.layout : void 0;
+	const parsed = types_exports.LayoutConfigSchema.safeParse(layout);
+	if (!parsed.success) return Result.err(new CLIError({ message: "The redeemed layout is not valid." }));
+	return Result.ok(parsed.data);
+}
+//#endregion
 //#region src/utils/project-directory.ts
 async function handleDirectoryConflict(currentPathInput) {
 	while (true) {
@@ -4659,7 +4899,7 @@ async function generateRouteTreeIfNeeded(projectDir, config) {
 	if (!needsRouteTree(config.frontend)) return Result.ok(void 0);
 	const target = resolveRouteTreeTarget(config.frontend);
 	if (!target) return Result.ok(void 0);
-	const webAppDir = path.join(projectDir, "apps/web");
+	const webAppDir = path.join(projectDir, appDir(config, "web"));
 	const routesDir = path.join(webAppDir, "src/routes");
 	if (!await fs.pathExists(routesDir)) return Result.ok(void 0);
 	return Result.tryPromise({
@@ -4722,7 +4962,7 @@ async function setupCloudflareD1(config) {
 	if (!(orm === "prisma" && (serverDeploy === "cloudflare" || backend === "self" && webDeploy === "cloudflare"))) return Result.ok(void 0);
 	return Result.tryPromise({
 		try: async () => {
-			const targetApp = backend === "self" ? "apps/web" : "apps/server";
+			const targetApp = getDbEnvTargetApp(config);
 			await addEnvVariablesToFile(path.join(projectDir, targetApp, ".env"), [{
 				key: "DATABASE_URL",
 				value: `file:${path.join(projectDir, targetApp, "local.db")}`,
@@ -4730,7 +4970,7 @@ async function setupCloudflareD1(config) {
 			}]);
 			await addPackageDependency({
 				dependencies: ["@prisma/adapter-d1"],
-				projectDir: path.join(projectDir, backend === "self" ? "apps/web" : "apps/server")
+				projectDir: path.join(projectDir, getDbEnvTargetApp(config))
 			});
 		},
 		catch: (e) => new DatabaseSetupError({
@@ -4743,11 +4983,11 @@ async function setupCloudflareD1(config) {
 //#endregion
 //#region src/helpers/database-providers/docker-compose-setup.ts
 async function setupDockerCompose(config) {
-	const { database, projectDir, projectName, backend } = config;
+	const { database, projectDir, projectName } = config;
 	if (database === "none" || database === "sqlite") return Result.ok(void 0);
 	const result = await Result.tryPromise({
 		try: async () => {
-			await writeEnvFile$4(projectDir, database, projectName, backend);
+			await writeEnvFile$4(projectDir, database, projectName, config);
 		},
 		catch: (e) => new DatabaseSetupError({
 			provider: "docker-compose",
@@ -4757,8 +4997,8 @@ async function setupDockerCompose(config) {
 	});
 	return result.isErr() ? result : Result.ok(void 0);
 }
-async function writeEnvFile$4(projectDir, database, projectName, backend) {
-	const targetApp = backend === "self" ? "apps/web" : "apps/server";
+async function writeEnvFile$4(projectDir, database, projectName, project) {
+	const targetApp = getDbEnvTargetApp(project);
 	await addEnvVariablesToFile(path.join(projectDir, targetApp, ".env"), [{
 		key: "DATABASE_URL",
 		value: getDatabaseUrl(database, projectName),
@@ -4859,10 +5099,10 @@ async function initMongoDBAtlas(serverDir) {
 	}
 	return Result.ok({ connectionString });
 }
-async function writeEnvFile$3(projectDir, backend, config) {
+async function writeEnvFile$3(projectDir, project, config) {
 	return Result.tryPromise({
 		try: async () => {
-			const targetApp = backend === "self" ? "apps/web" : "apps/server";
+			const targetApp = getDbEnvTargetApp(project);
 			await addEnvVariablesToFile(path.join(projectDir, targetApp, ".env"), [{
 				key: "DATABASE_URL",
 				value: config?.connectionString ?? "mongodb://localhost:27017/mydb",
@@ -4894,12 +5134,12 @@ ${pc.green("MongoDB Atlas Manual Setup Instructions:")}
 `);
 }
 async function setupMongoDBAtlas(config, cliInput) {
-	const { projectDir, backend } = config;
+	const { projectDir } = config;
 	const setupMode = resolveDbSetupMode("mongodb-atlas", {
 		manualDb: cliInput?.manualDb,
 		dbSetupOptions: cliInput?.dbSetupOptions ?? config.dbSetupOptions
 	});
-	const serverDir = path.join(projectDir, "packages/db");
+	const serverDir = path.join(projectDir, pkgDir(config, "db"));
 	const ensureDirResult = await Result.tryPromise({
 		try: () => fs.ensureDir(serverDir),
 		catch: (e) => new DatabaseSetupError({
@@ -4911,7 +5151,7 @@ async function setupMongoDBAtlas(config, cliInput) {
 	if (ensureDirResult.isErr()) return ensureDirResult;
 	if (setupMode === "manual") {
 		cliLog.info("MongoDB Atlas manual setup selected");
-		const envResult = await writeEnvFile$3(projectDir, backend);
+		const envResult = await writeEnvFile$3(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$3();
 		return Result.ok(void 0);
@@ -4920,7 +5160,7 @@ async function setupMongoDBAtlas(config, cliInput) {
 	if (!mode) {
 		if (isSilent()) {
 			cliLog.warn(pc.yellow("MongoDB Atlas automatic setup requires interactive input. Falling back to manual setup."));
-			const envResult = await writeEnvFile$3(projectDir, backend);
+			const envResult = await writeEnvFile$3(projectDir, config);
 			if (envResult.isErr()) return envResult;
 			displayManualSetupInstructions$3();
 			return Result.ok(void 0);
@@ -4943,21 +5183,21 @@ async function setupMongoDBAtlas(config, cliInput) {
 	}
 	if (mode === "manual") {
 		cliLog.info("MongoDB Atlas manual setup selected");
-		const envResult = await writeEnvFile$3(projectDir, backend);
+		const envResult = await writeEnvFile$3(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$3();
 		return Result.ok(void 0);
 	}
 	const mongoConfigResult = await initMongoDBAtlas(serverDir);
 	if (mongoConfigResult.isOk()) {
-		const envResult = await writeEnvFile$3(projectDir, backend, mongoConfigResult.value);
+		const envResult = await writeEnvFile$3(projectDir, config, mongoConfigResult.value);
 		if (envResult.isErr()) return envResult;
 		cliLog.success(pc.green("MongoDB Atlas setup complete! Connection saved to .env file."));
 		return Result.ok(void 0);
 	}
 	if (UserCancelledError.is(mongoConfigResult.error)) return Result.err(mongoConfigResult.error);
 	cliLog.warn(pc.yellow("Falling back to local MongoDB configuration"));
-	const envResult = await writeEnvFile$3(projectDir, backend);
+	const envResult = await writeEnvFile$3(projectDir, config);
 	if (envResult.isErr()) return envResult;
 	displayManualSetupInstructions$3();
 	return Result.ok(void 0);
@@ -5044,10 +5284,10 @@ async function createNeonProject(projectName, regionId, packageManager) {
 	}
 	return databaseSetupError("neon", "Failed to extract connection information from Neon response");
 }
-async function writeEnvFile$2(projectDir, backend, config) {
+async function writeEnvFile$2(projectDir, project, config) {
 	return Result.tryPromise({
 		try: async () => {
-			const targetApp = backend === "self" ? "apps/web" : "apps/server";
+			const targetApp = getDbEnvTargetApp(project);
 			await addEnvVariablesToFile(path.join(projectDir, targetApp, ".env"), [{
 				key: "DATABASE_URL",
 				value: config?.connectionString ?? "postgresql://postgres:postgres@localhost:5432/mydb?schema=public",
@@ -5061,10 +5301,10 @@ async function writeEnvFile$2(projectDir, backend, config) {
 		})
 	});
 }
-async function setupWithNeonDb(projectDir, packageManager, backend) {
+async function setupWithNeonDb(projectDir, packageManager, project) {
 	const s = createSpinner();
 	s.start("Creating Neon database using neon-new...");
-	const targetApp = backend === "self" ? "apps/web" : "apps/server";
+	const targetApp = getDbEnvTargetApp(project);
 	const targetDir = path.join(projectDir, targetApp);
 	const ensureDirResult = await Result.tryPromise({
 		try: () => fs.ensureDir(targetDir),
@@ -5105,20 +5345,20 @@ function displayManualSetupInstructions$2(target) {
 DATABASE_URL="your_connection_string"`);
 }
 async function setupNeonPostgres(config, cliInput) {
-	const { packageManager, projectDir, backend } = config;
+	const { packageManager, projectDir } = config;
 	const setupMode = resolveDbSetupMode("neon", {
 		manualDb: cliInput?.manualDb,
 		dbSetupOptions: cliInput?.dbSetupOptions ?? config.dbSetupOptions
 	});
-	const target = backend === "self" ? "apps/web" : "apps/server";
+	const target = getDbEnvTargetApp(config);
 	if (shouldSkipExternalCommands()) {
-		const envResult = await writeEnvFile$2(projectDir, backend);
+		const envResult = await writeEnvFile$2(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$2(target);
 		return Result.ok(void 0);
 	}
 	if (setupMode === "manual") {
-		const envResult = await writeEnvFile$2(projectDir, backend);
+		const envResult = await writeEnvFile$2(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$2(target);
 		return Result.ok(void 0);
@@ -5143,7 +5383,7 @@ async function setupNeonPostgres(config, cliInput) {
 		selectedMode = promptedMode;
 	}
 	if (selectedMode === "manual") {
-		const envResult = await writeEnvFile$2(projectDir, backend);
+		const envResult = await writeEnvFile$2(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$2(target);
 		return Result.ok(void 0);
@@ -5168,10 +5408,10 @@ async function setupNeonPostgres(config, cliInput) {
 		setupMethod = promptedSetupMethod;
 	}
 	if (setupMethod === "neondb") {
-		const neonDbResult = await setupWithNeonDb(projectDir, packageManager, backend);
+		const neonDbResult = await setupWithNeonDb(projectDir, packageManager, config);
 		if (neonDbResult.isErr()) {
 			cliLog.error(pc.red(neonDbResult.error.message));
-			const envResult = await writeEnvFile$2(projectDir, backend);
+			const envResult = await writeEnvFile$2(projectDir, config);
 			if (envResult.isErr()) return envResult;
 			displayManualSetupInstructions$2(target);
 			return Result.ok(void 0);
@@ -5205,14 +5445,14 @@ async function setupNeonPostgres(config, cliInput) {
 	const neonConfigResult = await createNeonProject(projectName, regionId, packageManager);
 	if (neonConfigResult.isErr()) {
 		cliLog.error(pc.red(neonConfigResult.error.message));
-		const envResult = await writeEnvFile$2(projectDir, backend);
+		const envResult = await writeEnvFile$2(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$2(target);
 		return Result.ok(void 0);
 	}
 	const finalSpinner = createSpinner();
 	finalSpinner.start("Configuring database connection");
-	const envResult = await writeEnvFile$2(projectDir, backend, neonConfigResult.value);
+	const envResult = await writeEnvFile$2(projectDir, config, neonConfigResult.value);
 	if (envResult.isErr()) {
 		finalSpinner.stop(pc.red("Failed to configure database connection"));
 		return envResult;
@@ -5224,11 +5464,11 @@ async function setupNeonPostgres(config, cliInput) {
 //#endregion
 //#region src/helpers/database-providers/planetscale-setup.ts
 async function setupPlanetScale(config) {
-	const { projectDir, database, orm, backend } = config;
+	const { projectDir, database, orm } = config;
 	if (!["mysql", "postgres"].includes(database)) return Result.ok(void 0);
 	return Result.tryPromise({
 		try: async () => {
-			const targetApp = backend === "self" ? "apps/web" : "apps/server";
+			const targetApp = getDbEnvTargetApp(config);
 			const envPath = path.join(projectDir, targetApp, ".env");
 			if (database === "mysql" && orm === "drizzle") {
 				const variables = [
@@ -5376,10 +5616,10 @@ async function setupWithCreateDb(serverDir, packageManager, regionId) {
 		claimUrl: createDbResponse.claimUrl
 	});
 }
-async function writeEnvFile$1(projectDir, backend, config) {
+async function writeEnvFile$1(projectDir, project, config) {
 	return Result.tryPromise({
 		try: async () => {
-			const targetApp = backend === "self" ? "apps/web" : "apps/server";
+			const targetApp = getDbEnvTargetApp(project);
 			const envPath = path.join(projectDir, targetApp, ".env");
 			const variables = [{
 				key: "DATABASE_URL",
@@ -5411,13 +5651,13 @@ function displayManualSetupInstructions$1(target) {
 DATABASE_URL="your_database_url"`);
 }
 async function setupPrismaPostgres(config, cliInput) {
-	const { packageManager, projectDir, backend } = config;
+	const { packageManager, projectDir } = config;
 	const setupMode = resolveDbSetupMode("prisma-postgres", {
 		manualDb: cliInput?.manualDb,
 		dbSetupOptions: cliInput?.dbSetupOptions ?? config.dbSetupOptions
 	});
-	const dbDir = path.join(projectDir, "packages/db");
-	const target = backend === "self" ? "apps/web" : "apps/server";
+	const dbDir = path.join(projectDir, pkgDir(config, "db"));
+	const target = getDbEnvTargetApp(config);
 	const ensureDirResult = await Result.tryPromise({
 		try: () => fs.ensureDir(dbDir),
 		catch: (e) => new DatabaseSetupError({
@@ -5428,7 +5668,7 @@ async function setupPrismaPostgres(config, cliInput) {
 	});
 	if (ensureDirResult.isErr()) return ensureDirResult;
 	if (setupMode === "manual") {
-		const envResult = await writeEnvFile$1(projectDir, backend);
+		const envResult = await writeEnvFile$1(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$1(target);
 		return Result.ok(void 0);
@@ -5453,7 +5693,7 @@ async function setupPrismaPostgres(config, cliInput) {
 		selectedSetupMode = promptedSetupMode;
 	}
 	if (selectedSetupMode === "manual") {
-		const envResult = await writeEnvFile$1(projectDir, backend);
+		const envResult = await writeEnvFile$1(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$1(target);
 		return Result.ok(void 0);
@@ -5462,13 +5702,13 @@ async function setupPrismaPostgres(config, cliInput) {
 	if (prismaConfigResult.isErr()) {
 		if (UserCancelledError.is(prismaConfigResult.error)) return Result.err(prismaConfigResult.error);
 		cliLog.error(pc.red(prismaConfigResult.error.message));
-		const envResult = await writeEnvFile$1(projectDir, backend);
+		const envResult = await writeEnvFile$1(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions$1(target);
 		cliLog.info("Setup completed with manual configuration required.");
 		return Result.ok(void 0);
 	}
-	const envResult = await writeEnvFile$1(projectDir, backend, prismaConfigResult.value);
+	const envResult = await writeEnvFile$1(projectDir, config, prismaConfigResult.value);
 	if (envResult.isErr()) return envResult;
 	cliLog.success(pc.green("Prisma Postgres database configured successfully!"));
 	if (prismaConfigResult.value.claimUrl) cliLog.info(pc.blue(`Claim URL saved to .env: ${prismaConfigResult.value.claimUrl}`));
@@ -5476,10 +5716,10 @@ async function setupPrismaPostgres(config, cliInput) {
 }
 //#endregion
 //#region src/helpers/database-providers/supabase-setup.ts
-async function writeSupabaseEnvFile(projectDir, backend, databaseUrl) {
+async function writeSupabaseEnvFile(projectDir, project, databaseUrl) {
 	return Result.tryPromise({
 		try: async () => {
-			const targetApp = backend === "self" ? "apps/web" : "apps/server";
+			const targetApp = getDbEnvTargetApp(project);
 			const envPath = path.join(projectDir, targetApp, ".env");
 			const dbUrlToUse = databaseUrl || "postgresql://postgres:postgres@127.0.0.1:54322/postgres";
 			await addEnvVariablesToFile(envPath, [{
@@ -5563,13 +5803,13 @@ ${pc.dim(output)}` : ""}
 			${pc.gray("DATABASE_URL=\"your_supabase_db_url\"")}`);
 }
 async function setupSupabase(config, cliInput) {
-	const { projectDir, packageManager, backend } = config;
-	const targetApp = backend === "self" ? "apps/web" : "apps/server";
+	const { projectDir, packageManager } = config;
+	const targetApp = getDbEnvTargetApp(config);
 	const setupMode = resolveDbSetupMode("supabase", {
 		manualDb: cliInput?.manualDb,
 		dbSetupOptions: cliInput?.dbSetupOptions ?? config.dbSetupOptions
 	});
-	const serverDir = path.join(projectDir, "packages", "db");
+	const serverDir = path.join(projectDir, pkgDir(config, "db"));
 	const ensureDirResult = await Result.tryPromise({
 		try: () => fs.ensureDir(serverDir),
 		catch: (e) => new DatabaseSetupError({
@@ -5581,7 +5821,7 @@ async function setupSupabase(config, cliInput) {
 	if (ensureDirResult.isErr()) return ensureDirResult;
 	if (setupMode === "manual") {
 		displayManualSupabaseInstructions(targetApp);
-		return writeSupabaseEnvFile(projectDir, backend, "");
+		return writeSupabaseEnvFile(projectDir, config, "");
 	}
 	let mode = setupMode;
 	if (!mode) if (isSilent()) mode = "manual";
@@ -5604,24 +5844,24 @@ async function setupSupabase(config, cliInput) {
 	}
 	if (mode === "manual") {
 		displayManualSupabaseInstructions(targetApp);
-		return writeSupabaseEnvFile(projectDir, backend, "");
+		return writeSupabaseEnvFile(projectDir, config, "");
 	}
 	const initResult = await initializeSupabase(serverDir, packageManager);
 	if (initResult.isErr()) {
 		cliLog.error(pc.red(initResult.error.message));
 		displayManualSupabaseInstructions(targetApp);
-		return writeSupabaseEnvFile(projectDir, backend, "");
+		return writeSupabaseEnvFile(projectDir, config, "");
 	}
 	const startResult = await startSupabase(serverDir, packageManager);
 	if (startResult.isErr()) {
 		cliLog.error(pc.red(startResult.error.message));
 		displayManualSupabaseInstructions(targetApp);
-		return writeSupabaseEnvFile(projectDir, backend, "");
+		return writeSupabaseEnvFile(projectDir, config, "");
 	}
 	const supabaseOutput = startResult.value;
 	const dbUrl = extractDbUrl(supabaseOutput);
 	if (dbUrl) {
-		const envResult = await writeSupabaseEnvFile(projectDir, backend, dbUrl);
+		const envResult = await writeSupabaseEnvFile(projectDir, config, dbUrl);
 		if (envResult.isOk()) cliLog.success(pc.green("Supabase local development setup ready!"));
 		else {
 			cliLog.error(pc.red("Supabase setup completed, but failed to update .env automatically."));
@@ -5782,10 +6022,10 @@ async function createTursoDatabase(dbName, groupName) {
 		}
 	});
 }
-async function writeEnvFile(projectDir, backend, config) {
+async function writeEnvFile(projectDir, project, config) {
 	return Result.tryPromise({
 		try: async () => {
-			const targetApp = backend === "self" ? "apps/web" : "apps/server";
+			const targetApp = getDbEnvTargetApp(project);
 			await addEnvVariablesToFile(path.join(projectDir, targetApp, ".env"), [{
 				key: "DATABASE_URL",
 				value: config?.dbUrl ?? "",
@@ -5815,15 +6055,15 @@ DATABASE_URL=your_database_url
 DATABASE_AUTH_TOKEN=your_auth_token`);
 }
 async function setupTurso(config, cliInput) {
-	const { projectDir, backend } = config;
-	const targetApp = backend === "self" ? "apps/web" : "apps/server";
+	const { projectDir } = config;
+	const targetApp = getDbEnvTargetApp(config);
 	const setupMode = resolveDbSetupMode("turso", {
 		manualDb: cliInput?.manualDb,
 		dbSetupOptions: cliInput?.dbSetupOptions ?? config.dbSetupOptions
 	});
 	const setupSpinner = createSpinner();
 	if (setupMode === "manual") {
-		const envResult = await writeEnvFile(projectDir, backend);
+		const envResult = await writeEnvFile(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions(targetApp);
 		return Result.ok(void 0);
@@ -5848,7 +6088,7 @@ async function setupTurso(config, cliInput) {
 		mode = promptedMode;
 	}
 	if (mode === "manual") {
-		const envResult = await writeEnvFile(projectDir, backend);
+		const envResult = await writeEnvFile(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions(targetApp);
 		return Result.ok(void 0);
@@ -5859,7 +6099,7 @@ async function setupTurso(config, cliInput) {
 	if (platform === "win32") {
 		setupSpinner.stop(pc.yellow("Turso setup not supported on Windows"));
 		cliLog.warn(pc.yellow("Automatic Turso setup is not supported on Windows."));
-		const envResult = await writeEnvFile(projectDir, backend);
+		const envResult = await writeEnvFile(projectDir, config);
 		if (envResult.isErr()) return envResult;
 		displayManualSetupInstructions(targetApp);
 		return Result.ok(void 0);
@@ -5877,7 +6117,7 @@ async function setupTurso(config, cliInput) {
 			shouldInstall = promptedInstall;
 		}
 		if (!shouldInstall) {
-			const envResult = await writeEnvFile(projectDir, backend);
+			const envResult = await writeEnvFile(projectDir, config);
 			if (envResult.isErr()) return envResult;
 			displayManualSetupInstructions(targetApp);
 			return Result.ok(void 0);
@@ -5885,7 +6125,7 @@ async function setupTurso(config, cliInput) {
 		const installResult = await installTursoCLI(isMac);
 		if (installResult.isErr()) {
 			cliLog.error(pc.red(installResult.error.message));
-			const envResult = await writeEnvFile(projectDir, backend);
+			const envResult = await writeEnvFile(projectDir, config);
 			if (envResult.isErr()) return envResult;
 			displayManualSetupInstructions(targetApp);
 			return Result.ok(void 0);
@@ -5894,7 +6134,7 @@ async function setupTurso(config, cliInput) {
 	if (!await isTursoLoggedIn()) {
 		if (isSilent()) {
 			cliLog.warn(pc.yellow("Turso CLI is not logged in. Falling back to manual setup."));
-			const envResult = await writeEnvFile(projectDir, backend);
+			const envResult = await writeEnvFile(projectDir, config);
 			if (envResult.isErr()) return envResult;
 			displayManualSetupInstructions(targetApp);
 			return Result.ok(void 0);
@@ -5902,7 +6142,7 @@ async function setupTurso(config, cliInput) {
 		const loginResult = await loginToTurso();
 		if (loginResult.isErr()) {
 			cliLog.error(pc.red(loginResult.error.message));
-			const envResult = await writeEnvFile(projectDir, backend);
+			const envResult = await writeEnvFile(projectDir, config);
 			if (envResult.isErr()) return envResult;
 			displayManualSetupInstructions(targetApp);
 			return Result.ok(void 0);
@@ -5920,13 +6160,13 @@ async function setupTurso(config, cliInput) {
 		const createResult = await createTursoDatabase(suggestedName, selectedGroup);
 		if (createResult.isErr()) {
 			cliLog.error(pc.red(createResult.error.message));
-			const envResult = await writeEnvFile(projectDir, backend);
+			const envResult = await writeEnvFile(projectDir, config);
 			if (envResult.isErr()) return envResult;
 			displayManualSetupInstructions(targetApp);
 			cliLog.success("Setup completed with manual configuration required.");
 			return Result.ok(void 0);
 		}
-		const envResult = await writeEnvFile(projectDir, backend, createResult.value);
+		const envResult = await writeEnvFile(projectDir, config, createResult.value);
 		if (envResult.isErr()) return envResult;
 		cliLog.success("Turso database setup completed successfully!");
 		return Result.ok(void 0);
@@ -5948,13 +6188,13 @@ async function setupTurso(config, cliInput) {
 				continue;
 			}
 			cliLog.error(pc.red(createResult.error.message));
-			const envResult = await writeEnvFile(projectDir, backend);
+			const envResult = await writeEnvFile(projectDir, config);
 			if (envResult.isErr()) return envResult;
 			displayManualSetupInstructions(targetApp);
 			cliLog.success("Setup completed with manual configuration required.");
 			return Result.ok(void 0);
 		}
-		const envResult = await writeEnvFile(projectDir, backend, createResult.value);
+		const envResult = await writeEnvFile(projectDir, config, createResult.value);
 		if (envResult.isErr()) return envResult;
 		cliLog.success("Turso database setup completed successfully!");
 		return Result.ok(void 0);
@@ -5971,12 +6211,12 @@ async function setupDatabase(config, cliInput) {
 	const { database, dbSetup, backend, projectDir } = config;
 	if (backend === "convex" || database === "none") {
 		if (backend !== "convex") {
-			const serverDbDir = path.join(projectDir, "apps/server/src/db");
+			const serverDbDir = path.join(projectDir, appDir(config, "server"), "src/db");
 			if (await fs.pathExists(serverDbDir)) await fs.remove(serverDbDir);
 		}
 		return;
 	}
-	const dbPackageDir = path.join(projectDir, "packages/db");
+	const dbPackageDir = path.join(projectDir, pkgDir(config, "db"));
 	if (!await fs.pathExists(dbPackageDir)) return;
 	async function runSetup(setupFn) {
 		const result = await setupFn();
@@ -6191,7 +6431,7 @@ async function displayPostInstallInstructions(config) {
 	if (bunWebNativeWarning) output += `\n${bunWebNativeWarning.trim()}\n`;
 	output += `\n${pc$1.bold("Like kubojs?")} Please consider giving us a star\n   on GitHub:\n`;
 	output += pc$1.cyan("https://github.com/albuquerquesz/kubo");
-	cliConsola.box(output);
+	cliConsola.box(relocateLayoutPaths(output, config));
 }
 function getNativeInstructions(isConvex, isBackendSelf, frontend, runCmd) {
 	const envVar = isConvex ? "EXPO_PUBLIC_CONVEX_URL" : "EXPO_PUBLIC_SERVER_URL";
@@ -6584,6 +6824,13 @@ async function createProjectHandler(input, options = {}) {
 		process.exit(1);
 	});
 }
+/** `--layout` and `--layout-code` are exclusive; a code is redeemed (and consumed) here. */
+async function resolveInputLayout(input) {
+	if (input.layoutCode === void 0) return Result.ok(input.layout);
+	if (input.layout !== void 0) return Result.err(new CLIError({ message: "Use either --layout or --layout-code, not both." }));
+	if (input.dryRun) return Result.err(new CLIError({ message: "--layout-code is single-use and cannot be combined with --dry-run." }));
+	return redeemLayoutCode(input.layoutCode);
+}
 /** Stack-selecting flags; their presence means the user chose the stack via flags, not prompts. */
 const STACK_FLAG_KEYS = [
 	"database",
@@ -6621,6 +6868,7 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 		if (!isSilent() && input.renderTitle !== false) renderTitle();
 		if (!isSilent()) intro(cliColors.bright("Creating a new kubojs project"));
 		if (!isSilent() && input.yolo) cliConsola.fatal("YOLO mode enabled - skipping checks. Things may break!");
+		const layout = yield* validateCreateLayout(yield* Result.await(resolveInputLayout(input)));
 		let currentPathInput;
 		if (isSilent()) currentPathInput = yield* Result.await(resolveProjectNameForSilent(input));
 		else if (input.yes && input.projectName) currentPathInput = input.projectName;
@@ -6750,6 +6998,10 @@ async function createProjectHandlerInternal(input, startTime, timeScaffolded) {
 			...config,
 			dbSetupOptions: effectiveDbSetupOptions
 		};
+		if (layout) config = {
+			...config,
+			layout
+		};
 		if (!input.yolo) {
 			const addonsValidationResult = validateAddonsAgainstFrontends(config.addons, config.frontend, config.auth, config.backend, config.runtime);
 			if (addonsValidationResult.isErr()) return Result.err(new CLIError({ message: addonsValidationResult.error.message }));
@@ -6959,12 +7211,17 @@ const router = t.router({
 		renderTitle: z.boolean().optional(),
 		disableAnalytics: z.boolean().optional().default(false).describe("Disable analytics"),
 		manualDb: z.boolean().optional().default(false).describe("Skip automatic/manual database setup prompt and use manual setup"),
-		dbSetupOptions: types_exports.DbSetupOptionsSchema.optional().describe("Structured database setup options")
+		dbSetupOptions: types_exports.DbSetupOptionsSchema.optional().describe("Structured database setup options"),
+		layout: z.string().optional().describe("Folder layout: a preset (standard, libs) or JSON, e.g. '{\"preset\":\"libs\",\"apps\":{\"web\":\"web\"}}'"),
+		layoutCode: z.string().optional().describe("Single-use code from the Layout tab at kubojs.dev/new (applies your saved layout)")
 	})])).mutation(async ({ input }) => {
 		const [projectName, options] = input;
+		const layoutResult = options.layout === void 0 ? Result.ok(void 0) : parseLayoutFlag(options.layout);
+		if (layoutResult.isErr()) throw layoutResult.error;
 		const result = await createProjectHandler({
 			projectName,
-			...options
+			...options,
+			layout: layoutResult.value
 		});
 		if (options.verbose || options.dryRun) return result;
 	}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-kubojs",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "A modern CLI tool for scaffolding end-to-end type-safe TypeScript projects with best practices and customizable configurations",
   "keywords": [
     "better-auth",
@@ -73,8 +73,8 @@
   "dependencies": {
     "@clack/core": "^1.4.1",
     "@clack/prompts": "^1.5.1",
-    "@kubojs/template-generator": "^0.5.0",
-    "@kubojs/types": "^0.5.0",
+    "@kubojs/template-generator": "^0.6.0",
+    "@kubojs/types": "^0.6.0",
     "@modelcontextprotocol/sdk": "1.29.0",
     "@tanstack/router-generator": "1.167.28",
     "@trpc/server": "^11.17.0",