create-kubojs 0.5.1 → 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-DdCJmpnU.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-DdCJmpnU.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-DdCJmpnU.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";
@@ -2477,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));
@@ -2527,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({
@@ -4393,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) {
@@ -4806,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({
@@ -4869,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")}`,
@@ -4877,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({
@@ -4890,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",
@@ -4904,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),
@@ -5006,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",
@@ -5041,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({
@@ -5058,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);
@@ -5067,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);
@@ -5090,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);
@@ -5191,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",
@@ -5208,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),
@@ -5252,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);
@@ -5290,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);
@@ -5315,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);
@@ -5352,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;
@@ -5371,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 = [
@@ -5523,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",
@@ -5558,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({
@@ -5575,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);
@@ -5600,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);
@@ -5609,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}`));
@@ -5623,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, [{
@@ -5710,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({
@@ -5728,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";
@@ -5751,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."));
@@ -5929,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 ?? "",
@@ -5962,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);
@@ -5995,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);
@@ -6006,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);
@@ -6024,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);
@@ -6032,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);
@@ -6041,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);
@@ -6049,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);
@@ -6067,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);
@@ -6095,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);
@@ -6118,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();
@@ -6338,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";
@@ -6731,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",
@@ -6768,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;
@@ -6897,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 }));
@@ -7106,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.1",
+  "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.1",
-    "@kubojs/types": "^0.5.1",
+    "@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",