@agentuity/cli 2.0.11 → 2.0.13

package/src/cmd/project/template-flow.ts

@@ -31,16 +31,14 @@ import * as tui from '../../tui';
 import { createPrompt, note } from '../../tui';
 import type { AuthData, Config } from '../../types';
 import { getGithubBotIdentity } from '../git/api';
-import {
-	ensureAuthDependencies,
-	generateAuthFileContent,
-	generateAuthSchemaSql,
-	printIntegrationExamples,
-	runAuthMigrations,
-} from './auth/shared';
 import { downloadTemplate, initGitRepo, setupProject } from './download';
+import { suggestBucketName, suggestDatabaseName } from './random-name';
 import { fetchTemplates, type TemplateInfo } from './templates';
 
+// Domain validator shared between the multi-select branch and the standalone prompt.
+const DOMAIN_REGEX =
+	/^(?=.{1,253}$)(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[A-Za-z]{2,63}$/;
+
 interface CreateFlowOptions {
 	projectName?: string;
 	dir?: string;
@@ -59,7 +57,6 @@ interface CreateFlowOptions {
 	apiClient?: APIClient;
 	database?: string;
 	storage?: string;
-	enableAuth?: boolean;
 }
 
 export interface CreateFlowResult {
@@ -92,7 +89,6 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		domains,
 		database: databaseOption,
 		storage: storageOption,
-		enableAuth: enableAuthOption,
 	} = options;
 
 	const isHeadless = !process.stdin.isTTY || !process.stdout.isTTY;
@@ -290,7 +286,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		};
 	}
 
-	// Add separator bar if we're going to show resource prompts
+	// Resource provisioning gates
 	const canProvision = auth && apiClient && catalystClient && orgId && region;
 	// Only count as resource flags if actually requesting provisioning (not explicit skip)
 	const hasResourceFlags =
@@ -314,23 +310,63 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		);
 	}
 
-	// Validate that --enable-auth requires authentication and registration
-	if (enableAuthOption && !canProvision) {
-		logger.fatal(
-			'Cannot enable Agentuity Auth without being authenticated and registering the project.\n' +
-				'Remove --no-register or omit --enable-auth flag.',
-			ErrorCode.VALIDATION_FAILED
-		);
-	}
-
 	if (canProvision) {
-		// Fetch resources for selected org and region using Catalyst API (needed for both interactive and CLI flags)
-		let resources: Awaited<ReturnType<typeof listResources>> | undefined;
+		// CLI flags pre-resolve their respective per-resource decision; the multi-select
+		// is only used for resources where the user didn't pass a flag.
+		const dbFlagAction = resolveFlagAction(databaseOption, 'database');
+		const storageFlagAction = resolveFlagAction(storageOption, 'storage');
+		const domainFlagProvided = (domains?.length ?? 0) > 0;
+
+		// Determine which resources should run through the configuration phase.
+		// In interactive mode, ask the user via a single multi-select.
+		// In headless / non-interactive mode, only flagged resources are considered.
+		let wantDb = dbFlagAction !== undefined && dbFlagAction !== 'Skip';
+		let wantStorage = storageFlagAction !== undefined && storageFlagAction !== 'Skip';
+		let wantDomain = domainFlagProvided;
 
+		if (isInteractive) {
+			// Build multi-select options dynamically: only show resources the user hasn't
+			// already decided about via CLI flags. If all three came from flags, skip the prompt.
+			const msOptions: {
+				value: 'database' | 'storage' | 'domain';
+				label: string;
+				hint?: string;
+			}[] = [];
+			if (dbFlagAction === undefined) {
+				msOptions.push({ value: 'database', label: 'SQL Database', hint: 'PostgreSQL' });
+			}
+			if (storageFlagAction === undefined) {
+				msOptions.push({ value: 'storage', label: 'Storage Bucket', hint: 'S3-compatible' });
+			}
+			if (!domainFlagProvided) {
+				msOptions.push({ value: 'domain', label: 'Custom Domain', hint: 'BYO domain' });
+			}
+
+			if (msOptions.length > 0) {
+				const picked = await prompt.multiselect<'database' | 'storage' | 'domain'>({
+					message: 'What would you like to set up? (all optional)',
+					options: msOptions,
+					initial: [],
+				});
+				if (dbFlagAction === undefined) wantDb = picked.includes('database');
+				if (storageFlagAction === undefined) wantStorage = picked.includes('storage');
+				if (!domainFlagProvided) wantDomain = picked.includes('domain');
+			}
+		}
+
+		// Fetch existing resources only if we'll actually need them.
+		// Need them when:
+		//   - user wants db/storage in interactive mode (to offer "use existing")
+		//   - a CLI flag pointed at an existing resource by name
+		let resources: Awaited<ReturnType<typeof listResources>> | undefined;
 		const needResources =
-			isInteractive ||
-			(databaseOption && databaseOption !== 'skip' && databaseOption !== 'new') ||
-			(storageOption && storageOption !== 'skip' && storageOption !== 'new');
+			(isInteractive && (wantDb || wantStorage)) ||
+			(databaseOption !== undefined &&
+				dbFlagAction !== 'Create New' &&
+				dbFlagAction !== 'Skip') ||
+			(storageOption !== undefined &&
+				storageFlagAction !== 'Create New' &&
+				storageFlagAction !== 'Skip');
 
 		if (needResources) {
 			resources = await tui.spinner({
@@ -348,316 +384,173 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 			logger.debug(
 				`Storage buckets: ${resources.s3.map((b) => b.bucket_name).join(', ') || '(none)'}`
 			);
-		}
 
-		// Determine database action: CLI flag > interactive prompt > skip (headless)
-		let db_action: string;
-		if (databaseOption !== undefined) {
-			// CLI flag provided - normalize to expected values
-			if (databaseOption.toLowerCase() === 'new') {
-				db_action = 'Create New';
-			} else if (databaseOption.toLowerCase() === 'skip') {
-				db_action = 'Skip';
-			} else {
-				// Existing database name - validate it exists
-				const existingDb = resources?.db.find((d) => d.name === databaseOption);
-				if (!existingDb) {
-					logger.fatal(
-						`Database '${databaseOption}' not found. Use 'new' to create a new database or 'skip' to skip.`,
-						ErrorCode.RESOURCE_NOT_FOUND
-					);
-				}
-				db_action = databaseOption;
+			// Validate flag-supplied resource names against the fetched list.
+			if (
+				databaseOption !== undefined &&
+				dbFlagAction !== 'Create New' &&
+				dbFlagAction !== 'Skip' &&
+				!resources.db.find((d) => d.name === dbFlagAction)
+			) {
+				logger.fatal(
+					`Database '${databaseOption}' not found. Use 'new' to create a new database or 'skip' to skip.`,
+					ErrorCode.RESOURCE_NOT_FOUND
+				);
 			}
-		} else if (isInteractive) {
-			db_action = await prompt.select({
-				message: 'Create SQL Database?',
-				options: [
-					{ value: 'Skip', label: 'Skip or Setup later' },
-					{ value: 'Create New', label: 'Create a new database' },
-					...resources!.db.map((db) => ({
-						value: db.name,
-						label: `Use database: ${tui.tuiColors.primary(db.name)}`,
-					})),
-				],
-			});
-		} else {
-			// Headless without flag - skip
-			db_action = 'Skip';
-		}
-
-		// Determine storage action: CLI flag > interactive prompt > skip (headless)
-		let s3_action: string;
-		if (storageOption !== undefined) {
-			// CLI flag provided - normalize to expected values
-			if (storageOption.toLowerCase() === 'new') {
-				s3_action = 'Create New';
-			} else if (storageOption.toLowerCase() === 'skip') {
-				s3_action = 'Skip';
-			} else {
-				// Existing bucket name - validate it exists
-				const existingBucket = resources?.s3.find((b) => b.bucket_name === storageOption);
-				if (!existingBucket) {
-					logger.fatal(
-						`Storage bucket '${storageOption}' not found. Use 'new' to create a new bucket or 'skip' to skip.`,
-						ErrorCode.RESOURCE_NOT_FOUND
-					);
-				}
-				s3_action = storageOption;
+			if (
+				storageOption !== undefined &&
+				storageFlagAction !== 'Create New' &&
+				storageFlagAction !== 'Skip' &&
+				!resources.s3.find((b) => b.bucket_name === storageFlagAction)
+			) {
+				logger.fatal(
+					`Storage bucket '${storageOption}' not found. Use 'new' to create a new bucket or 'skip' to skip.`,
+					ErrorCode.RESOURCE_NOT_FOUND
+				);
 			}
-		} else if (isInteractive) {
-			s3_action = await prompt.select({
-				message: 'Create Storage Bucket?',
-				options: [
-					{ value: 'Skip', label: 'Skip or Setup later' },
-					{ value: 'Create New', label: 'Create a new bucket' },
-					...resources!.s3.map((bucket) => ({
-						value: bucket.bucket_name,
-						label: `Use bucket: ${tui.tuiColors.primary(bucket.bucket_name)}`,
-					})),
-				],
-			});
-		} else {
-			// Headless without flag - skip
-			s3_action = 'Skip';
 		}
 
-		// Custom DNS: only prompt in interactive mode if not already provided
-		if (!domains?.length && isInteractive) {
-			const customDns = await prompt.text({
-				message: 'Setup custom DNS?',
-				hint: 'Enter a domain name or press Enter to skip',
-				validate: (val: string) =>
-					val === ''
-						? true
-						: /^(?=.{1,253}$)(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[A-Za-z]{2,63}$/.test(
-								val
-							),
-			});
-			if (customDns) {
-				_domains = [customDns];
+		// === Configure each selected resource: Database → Storage → Domain ===
+
+		// Database
+		if (wantDb) {
+			let dbAction = dbFlagAction;
+			if (dbAction === undefined && isInteractive) {
+				const existing = resources?.db ?? [];
+				if (existing.length > 0) {
+					dbAction = await prompt.select<string>({
+						message: 'SQL Database',
+						options: [
+							{ value: 'Create New', label: 'Create a new database' },
+							...existing.map((db) => ({
+								value: db.name,
+								label: `Use database: ${tui.tuiColors.primary(db.name)}`,
+							})),
+						],
+					});
+				} else {
+					// No existing databases — user already opted in via the multi-select, so create new.
+					dbAction = 'Create New';
+				}
 			}
-		}
 
-		// Process storage action
-		switch (s3_action) {
-			case 'Create New': {
-				let bucketName: string | undefined;
-				let bucketDescription: string | undefined;
+			if (dbAction === 'Create New') {
+				let dbName: string | undefined;
+				let dbDescription: string | undefined;
 
-				// Only prompt for name/description in interactive mode
 				if (isInteractive) {
-					const bucketNameInput = await prompt.text({
-						message: 'Bucket name',
-						hint: 'Optional - lowercase letters, digits, hyphens only',
+					const suggestion = suggestDatabaseName(projectName);
+					const dbNameInput = await prompt.text({
+						message: 'Database name',
+						hint: 'Optional · lowercase letters, digits, underscores',
+						placeholder: suggestion,
 						validate: (value: string) => {
 							const trimmed = value.trim();
 							if (trimmed === '') return true;
-							const result = validateBucketName(trimmed);
+							const result = validateDatabaseName(trimmed);
 							return result.valid ? true : result.error!;
 						},
 					});
-					bucketName = bucketNameInput.trim() || undefined;
-					bucketDescription =
+					dbName = dbNameInput.trim() || undefined;
+					dbDescription =
 						(await prompt.text({
-							message: 'Bucket description',
-							hint: 'Optional - press Enter to skip',
+							message: 'Database description',
+							hint: 'Optional · press Enter to skip',
 						})) || undefined;
 				}
 
 				const created = await tui.spinner({
-					message: 'Provisioning New Bucket',
+					message: 'Provisioning New SQL Database',
 					clearOnSuccess: true,
 					callback: async () => {
 						return createResources(catalystClient!, orgId!, region!, [
-							{
-								type: 's3',
-								name: bucketName,
-								description: bucketDescription,
-							},
+							{ type: 'db', name: dbName, description: dbDescription },
 						]);
 					},
 				});
-				// Collect env vars from newly created resource
-				if (created[0]?.env) {
-					Object.assign(resourceEnvVars, created[0].env);
-				}
-				break;
-			}
-			case 'Skip': {
-				break;
+				if (created[0]?.env) Object.assign(resourceEnvVars, created[0].env);
+			} else if (dbAction && dbAction !== 'Skip') {
+				// Existing database selected — reuse its env vars.
+				const selectedDb = resources?.db.find((d) => d.name === dbAction);
+				if (selectedDb?.env) Object.assign(resourceEnvVars, selectedDb.env);
 			}
-			default: {
-				// User selected an existing bucket - get env vars from the resources list
-				const selectedBucket = resources?.s3.find((b) => b.bucket_name === s3_action);
-				if (selectedBucket?.env) {
-					Object.assign(resourceEnvVars, selectedBucket.env);
+		}
+
+		// Storage
+		if (wantStorage) {
+			let s3Action = storageFlagAction;
+			if (s3Action === undefined && isInteractive) {
+				const existing = resources?.s3 ?? [];
+				if (existing.length > 0) {
+					s3Action = await prompt.select<string>({
+						message: 'Storage Bucket',
+						options: [
+							{ value: 'Create New', label: 'Create a new bucket' },
+							...existing.map((bucket) => ({
+								value: bucket.bucket_name,
+								label: `Use bucket: ${tui.tuiColors.primary(bucket.bucket_name)}`,
+							})),
+						],
+					});
+				} else {
+					s3Action = 'Create New';
 				}
-				break;
 			}
-		}
 
-		// Process database action
-		switch (db_action) {
-			case 'Create New': {
-				let dbName: string | undefined;
-				let dbDescription: string | undefined;
+			if (s3Action === 'Create New') {
+				let bucketName: string | undefined;
+				let bucketDescription: string | undefined;
 
-				// Only prompt for name/description in interactive mode
 				if (isInteractive) {
-					const dbNameInput = await prompt.text({
-						message: 'Database name',
-						hint: 'Optional - lowercase letters, digits, underscores only',
+					const suggestion = suggestBucketName(projectName);
+					const bucketNameInput = await prompt.text({
+						message: 'Bucket name',
+						hint: 'Optional · lowercase letters, digits, hyphens',
+						placeholder: suggestion,
 						validate: (value: string) => {
 							const trimmed = value.trim();
 							if (trimmed === '') return true;
-							const result = validateDatabaseName(trimmed);
+							const result = validateBucketName(trimmed);
 							return result.valid ? true : result.error!;
 						},
 					});
-					dbName = dbNameInput.trim() || undefined;
-					dbDescription =
+					bucketName = bucketNameInput.trim() || undefined;
+					bucketDescription =
 						(await prompt.text({
-							message: 'Database description',
-							hint: 'Optional - press Enter to skip',
+							message: 'Bucket description',
+							hint: 'Optional · press Enter to skip',
 						})) || undefined;
 				}
 
 				const created = await tui.spinner({
-					message: 'Provisioning New SQL Database',
+					message: 'Provisioning New Bucket',
 					clearOnSuccess: true,
 					callback: async () => {
 						return createResources(catalystClient!, orgId!, region!, [
-							{
-								type: 'db',
-								name: dbName,
-								description: dbDescription,
-							},
+							{ type: 's3', name: bucketName, description: bucketDescription },
 						]);
 					},
 				});
-				// Collect env vars from newly created resource
-				if (created[0]?.env) {
-					Object.assign(resourceEnvVars, created[0].env);
-				}
-				break;
-			}
-			case 'Skip': {
-				break;
-			}
-			default: {
-				// User selected an existing database - get env vars from the resources list
-				const selectedDb = resources?.db.find((d) => d.name === db_action);
-				if (selectedDb?.env) {
-					Object.assign(resourceEnvVars, selectedDb.env);
-				}
-				break;
-			}
-		}
-	}
-
-	// Auth setup - either from template, CLI flag, or user choice
-	const templateHasAuth = selectedTemplate.id === 'agentuity-auth';
-
-	let authEnabled = templateHasAuth; // Auth templates have auth enabled by default
-	let authDatabaseName: string | undefined;
-	let authDatabaseUrl: string | undefined;
-
-	// Handle auth enablement: CLI flag > interactive prompt > disabled (headless)
-	if (enableAuthOption !== undefined) {
-		// CLI flag provided
-		authEnabled = enableAuthOption;
-	} else if (canProvision && isInteractive && !templateHasAuth) {
-		// For non-auth templates in interactive mode, ask if they want to enable auth
-		const enableAuth = await prompt.select({
-			message: 'Enable Agentuity Authentication?',
-			options: [
-				{ value: 'no', label: "No, I'll add auth later" },
-				{ value: 'yes', label: 'Yes, set up Agentuity Auth' },
-			],
-		});
-
-		if (enableAuth === 'yes') {
-			authEnabled = true;
-		}
-	}
-	// In headless mode without --enable-auth flag, authEnabled stays false (unless template has auth)
-
-	// Set up database and secret for any auth-enabled project
-	if (authEnabled && canProvision) {
-		// If a database was already selected/created above, use it for auth
-		if (resourceEnvVars.DATABASE_URL) {
-			authDatabaseUrl = resourceEnvVars.DATABASE_URL;
-			// Extract database name from URL using proper URL parsing
-			try {
-				const dbUrl = new URL(authDatabaseUrl);
-				const dbName = dbUrl.pathname.replace(/^\/+/, ''); // Remove leading slashes
-				// Validate: non-empty and contains only safe characters
-				if (dbName && /^[A-Za-z0-9_-]+$/.test(dbName)) {
-					authDatabaseName = dbName;
-				}
-			} catch {
-				// Invalid URL format, authDatabaseName stays undefined
-			}
-		} else {
-			// No database selected yet, create one for auth
-			const created = await tui.spinner({
-				message: 'Provisioning database for auth',
-				clearOnSuccess: true,
-				callback: async () => {
-					return createResources(catalystClient!, orgId!, region!, [{ type: 'db' }]);
-				},
-			});
-			const createdDb = created[0];
-			if (!createdDb) {
-				logger.fatal('Failed to create database for auth', ErrorCode.RESOURCE_NOT_FOUND);
-				return undefined as never;
-			}
-			authDatabaseName = createdDb.name;
-
-			// Get env vars from created resource
-			if (createdDb.env) {
-				authDatabaseUrl = createdDb.env.DATABASE_URL;
-				// Also add to resourceEnvVars if not already set
-				if (!resourceEnvVars.DATABASE_URL) {
-					Object.assign(resourceEnvVars, createdDb.env);
-				}
+				if (created[0]?.env) Object.assign(resourceEnvVars, created[0].env);
+			} else if (s3Action && s3Action !== 'Skip') {
+				const selectedBucket = resources?.s3.find((b) => b.bucket_name === s3Action);
+				if (selectedBucket?.env) Object.assign(resourceEnvVars, selectedBucket.env);
 			}
 		}
 
-		// Install auth dependencies (skip for agentuity-auth template which has them)
-		if (!templateHasAuth) {
-			await ensureAuthDependencies({ projectDir: dest, logger });
-
-			// Generate auth.ts
-			const authFilePath = resolve(dest, 'src', 'auth.ts');
-			if (!existsSync(authFilePath)) {
-				const srcDir = resolve(dest, 'src');
-				if (!existsSync(srcDir)) {
-					await Bun.write(resolve(srcDir, '.gitkeep'), '');
-				}
-				await Bun.write(authFilePath, generateAuthFileContent());
-				tui.success('Created src/auth.ts');
-			}
-		}
-
-		// Run migrations
-		if (authDatabaseName) {
-			const sql = await tui.spinner({
-				message: 'Preparing auth database schema...',
-				clearOnSuccess: true,
-				callback: () => generateAuthSchemaSql(logger, dest),
-			});
-
-			await runAuthMigrations({
-				logger,
-				auth,
-				orgId,
-				region,
-				databaseName: authDatabaseName,
-				sql,
-				config,
+		// Custom Domain
+		if (wantDomain && !domainFlagProvided && isInteractive) {
+			const customDns = await prompt.text({
+				message: 'Custom domain',
+				hint: 'e.g. agents.example.com',
+				validate: (val: string) =>
+					val === ''
+						? 'Domain is required (or go back and uncheck Custom Domain)'
+						: DOMAIN_REGEX.test(val)
+							? true
+							: 'Invalid domain',
 			});
+			if (customDns) _domains = [customDns];
 		}
 	}
 
@@ -702,28 +595,9 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 			},
 		});
 
-		// Add auth secret to resourceEnvVars if auth is enabled
-		if (authEnabled && !resourceEnvVars.AGENTUITY_AUTH_SECRET) {
-			const devSecret = `dev-${crypto.randomUUID()}`;
-			resourceEnvVars.AGENTUITY_AUTH_SECRET = devSecret;
-		}
-
 		// Write resource environment variables to .env
 		if (Object.keys(resourceEnvVars).length > 0) {
 			await addResourceEnvVars(dest, resourceEnvVars);
-
-			// Show user feedback for auth-related env vars
-			if (authEnabled) {
-				if (resourceEnvVars.DATABASE_URL) {
-					tui.success('DATABASE_URL added to .env');
-				}
-				if (resourceEnvVars.AGENTUITY_AUTH_SECRET) {
-					tui.success('AGENTUITY_AUTH_SECRET added to .env');
-					tui.info(
-						`Generate one with: ${tui.muted('npx @better-auth/cli secret')} or ${tui.muted('openssl rand -hex 32')}`
-					);
-				}
-			}
 		}
 
 		// After registration, push any existing env/secrets from .env
@@ -819,11 +693,6 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		}
 	}
 
-	// Print auth integration examples if auth was enabled (skip for auth template - already set up)
-	if (authEnabled && !templateHasAuth) {
-		printIntegrationExamples();
-	}
-
 	return {
 		projectId,
 		orgId,
@@ -838,6 +707,28 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 	};
 }
 
+/**
+ * Normalize a CLI flag value (`--database` / `--storage`) into the same
+ * action vocabulary the interactive flow uses:
+ *   - 'new'  -> 'Create New'
+ *   - 'skip' -> 'Skip'
+ *   - any other string -> treated as an existing-resource name (returned as-is)
+ *   - undefined -> undefined (no flag passed; multi-select decides)
+ *
+ * The existence check for named resources happens later, after the resource
+ * list is fetched.
+ */
+function resolveFlagAction(
+	flag: string | undefined,
+	_kind: 'database' | 'storage'
+): string | undefined {
+	if (flag === undefined) return undefined;
+	const lower = flag.toLowerCase();
+	if (lower === 'new') return 'Create New';
+	if (lower === 'skip') return 'Skip';
+	return flag;
+}
+
 /**
  * Sanitize a project name to create a safe directory/package name
  * - Converts to lowercase

package/src/composite-logger.ts

@@ -7,6 +7,12 @@
  */
 
 import type { Logger } from '@agentuity/core';
+import { format } from 'node:util';
+import { ErrorCode, getExitCode } from './errors';
+
+function isErrorCode(value: unknown): value is ErrorCode {
+	return typeof value === 'string' && Object.values(ErrorCode).includes(value as ErrorCode);
+}
 
 /**
  * A logger that delegates to multiple child loggers
@@ -45,6 +51,20 @@ export class CompositeLogger implements Logger {
 	}
 
 	fatal(message: unknown, ...args: unknown[]): never {
+		const maybeErrorCode = args[args.length - 1];
+		if (isErrorCode(maybeErrorCode)) {
+			const formatArgs = args.slice(0, -1);
+			const formattedMessage = format(message, ...formatArgs);
+			for (const logger of this.loggers) {
+				try {
+					logger.error(formattedMessage);
+				} catch {
+					// Keep fatal exits reliable even if one delegate cannot write.
+				}
+			}
+			process.exit(getExitCode(maybeErrorCode));
+		}
+
 		// Call fatal on all loggers, but only the first one will exit
 		for (const logger of this.loggers) {
 			try {